Jared Updike wrote:
>> [a,b,c ; tail] === a :: b :: c :: tail --
>> where ::
>> How is [a,b,c ; tail] simpler, clearer or less typing than
> a:b:c:tail ? I think that the commas and semicolons are easy to
> confuse.
It seems strange that you can write [a,b,c] with a nice list sugar but if
you want to include a tail you have to switch to the infix notation using
list cons. Prolog for example allows you to write [a,b,c|Tail] but neither
Haskell nor ML allows this. In Haskell, | is used to introduce a list
comprehension so I was just trying to find a replacement symbol for when you
want the equivalent of the Prolog list sugar so that you wouldn't be forced
to use infix notation.
All this was not to replace a:b:c:tail but was to replace a::b::c::tail so
that : could be used for type annotations instead.
>> While we're talking about the aesthetics of "::" and ":", I like how a
> line with a type annotation stands out strongly with "::", e.g.
> map :: (a -> b) -> [a] -> [b]
> Compare this to
> map : (a -> b) -> [a] -> [b]
> where the identifier looks more connected to the type.
This is no doubt because you are used to thinking of : as meaning list cons
whereas I find the :: notation confusing for precisely the same reason.
>> If you are designing your own langauge, you will of course have your
> own aesthetics and reasons for doing it your way. As for me, I started
> to design (in my head) the "perfect" language (for me), but the more I
> learned and used Haskell, the more I realized how carefully designed
> it was and how it was better for me to use my efforts to learn from
> Haskell (especially conceptually, since the syntax is so transparent
> and the ideas are so amazing) than to try to insert clever ideas to
> satisfy my own whims. Sure, there are always little things to nitpick,
> but on the whole, can you think of more succinct language with more
> power? (and less parentheses!) Plus, what other languages let you more
> easily add (infix) operators, etc. and change things to fit your whim,
> anyway (and still be strongly type!).
I've spent at least 3 years looking into various languages (Prolog, ML,
Scheme, Lisp, Logo, Smalltalk, Mozart) before finally arriving at the
pleasant shores of Haskell which has an incredibly well thought out and neat
syntax not to mention a powerful type system. However there are some things
that are just plain crazy, such as the existing layout rule which forces you
to use a monospaced font when it would have been so simple to make a simpler
layout rule using tabs that would result in grammatically robust code in the
face of identifier renamings and editor font choices (as I've indicated on
other threads), and the way constructors and field labels for different
types are allowed to collide with each other in a module's namespace.
Feedback from this forum has been invaluable in helping me find a solution
to this second problem and arrive at a good field selection syntax with
semantics based on a compiler-defined global typeclass for each field label,
although it has taken at least 3 months to discover this...
There are some funny things with the semantics I'm puzzled about - such as
why Haskell is still based on Hindley Milner type inference with its
troublesome monomorphism restrictions instead of intersection types which
would allow everything to be mutually recursive with separate compilation of
modules etc, but AFAIK no other language uses intersection types yet either,
and Haskell is at least heading in the right direction with arbitrary rank
forall polymorphism.
So I agree that Haskell is one of the best languages in existence at the
moment all things considered, especially because it is a very good place to
start when trying to develop the "perfect" language.
Regards, Brian.