But most of your qualms appear to be that it differs from Common Lisp. This is absolutely true. There is less to unlearn than coming from C, but swathes of both languages don’t fit in the other. I have found that on average Haskell suits me better than Common Lisp, so I use it. If Common Lisp suits you better, then stick with it, but it’s worth sticking with it long enough to figure out monads, monad transformers, and the same structures for arrows. They’re a delightful little enlightenment.

Well, Common Lisp’s Object System is also very powerful, and actually it does similar things that haskell’s type-system does I think. But maybe it is the wrong way to compare Haskell with Common Lisp.

Yes, the point about monads and Lisp macros is entirely true. About the syntax, well, Haskell tries to reflect its mathematicity. You can love it or hate it. But it was noted in another comment that you can also use free alignment, if you use C-style braces. I would still recommend you to try it out. You may like it in the end, because it’s not just some fancy syntax. It allows you to express things concisely. After all you use indentation anyway, so parentheses are usually just redundant. If you want this redundancy, you can use parenthesis in Haskell, too. =)

The point about C vs. Haskell was misunderstood. It’s not that I found C powerful, but that I was convinced that C does The Right Thing, implements The Right Paradigm and enforces The Right Way Of Thinking. Today when forced to use imperative languages I prefer C#, D or Python (sorted alphabetically), but none of them would beat Haskell for me. When forced to use a non-Haskell functional language I would probably use F# or OCaml, because of their advanced type systems, probably rather F#, because it allows one to implement monads, although you don’t get anywhere near Haskell’s monads (this is not related to bad language support, but to the type systems — Haskell has the most advanced type system I have ever seen).

Greets,
Ertes.

Let’s take laziness: Haskell has non-strict evaluation semantics, which is not just an optimization, but a different way of executing code from ground up. It allows you to express algorithms in ways you have never thought of before. For example, to get a list of primes ‘primes’ you create an infinite list of all natural numbers and filter it by an ‘isPrime’ predicate, which in turn checks primality by trial-dividing by all primes. Yes, ‘primes’ depends on ‘isPrime’, which in turn depends on ‘primes’. This works without problems in Haskell. Creating infinite data structures and processing them in seemingly impossible ways is something laziness gives you. This is not optimization, this is a completely different way of thinking.

Let’s take monads: What they really allow you to do is: When you have a certain programming pattern, then you can create a domain-specific language to express it. State is an example of that. Another example is nondeterminism. Some functions could have arbitrarily many results. Monads not only give you a way of expressing such computations conveniently, but also implement functions at a more general level (i.e. not specific to a particular monad). The true power of monads, however, becomes visible as soon as you learn to combine them (using monad transformers). Combining the list monad and a state monad you get nondeterministic state. Combining the list monad and IO you get nondeterministic effects. Even the list monad alone is something very beautiful. It lets you have a variable ‘x’, which stands for all natural numbers or something like that.

Syntax is not ugly, it’s just different. As soon as you get used to it you will love it. This post is from someone, who used to be a fanatic C lover, before he took the time to learn Haskell properly. Now I would never go back to C.

Greets,
Ertes.

There’s just so much fun in the type system: Type classes, higher order stuff, phantom types, existential types, composable monads using the coproduct etcetcetc

You may be able to make Java dynamically typed without changing it much, but neither can you make Common Lisp statically typed nor Haskell dynamically typed without redesigning other parts of the language as well, and while I adore Haskell’s esthetics, and like it as a programming tool partly _because_ of the powerful way it handles data types, there is quite some complexity associated with its type system and syntax (the latter of which is, in turn, modeled such that it matches the type system) that often distracts me from the problem I’m trying to solve when writing a programme. I assume it is these secondary effects that the OP takes issue with, although he doesn’t clearly say so.

Monads for side-effects are – in my oppinion – too complicated. Clojure’s and SML’s approach of explicitly getting and setting global variables is sufficient imo. I mean, thats basically what multicore-architectures will do: Using anything local directly, while accessing anything public through some special call.

But as I said in my post, these are just first impressions of Haskell.