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.