It's a good comparison of the two languages.

Regarding type classes, I personally like Haskell's approach more. I haven't used Scala, so I'm assuming that objects there behave the same as modules in OCaml (at least in practice for this particular purpose). Essentially, Haskell makes the right compromise: the most common case (having one instance per type) is easy while the less common case (explicitly specifying the instance) is less easy. The core difference is this: when you want to use a different "instance" in OCaml, you just pass in a different module; in Haskell, you have to create a new type.

Happily, creating a new type is easy, especially with newtype deriving which lets you bring instances you don't want to change over to your new type for free. This has some advantages: the instance is now encoded in the type, so that you cannot mix different ones by accident. This is useful because it's quite easy to have code that depends on, for example, a consistent compare function in different places on the same type. This also lets the choice of implementation be implicit at the call site, so you only have to specify the instance once rather than repeatedly in different places.

I think there is also a good case for type classes not being reified as modules or dictionaries or objects or what have you: they essentially exist exclusively at the type level. That is, the instances are a property of each type, not part of a module or anything like that. This also makes the syntax for types clearer: the => acts as implication and the type class acts as a predicate on the type.

In summary: type classes are more restrictive than first-class modules, but this is a good compromise. You can get the same effect with newtype, with the added bonus of having the difference reflected in the type system.

I'm afraid I have not managed to make my thoughts on type classes too clear. I've been thinking about that particular design trade-off (type classes vs first-class modules) and writing this has probably helped me get my thoughts together far more than it will help any readers :P. Maybe I'll write a blog post about it--I've been meaning to start a blog for a while now...

Some other thoughts: I think laziness is a good thing because you trade performance for simplicity and expressiveness. It's easier to add strictness to a lazy language than vice-versa. But I essentially use Haskell where others would use something like Python, so its relative performance is well beyond satisfactory even with plenty of space leaks :P.

As far as developer tools go, Scala has Ensime [1] and Haskell has Scion [2] but I've used neither. OCaml has TypeRex [3], which I have used and is pretty cool. Assuming that Ensime and Scion are similar to TypeRex, they're certainly good enough. You never have to leave Emacs :).

[1]: https://github.com/aemoncannon/ensime/

[2]: http://code.google.com/p/scion-lib/

[3]: http://typerex.org/

Coincidentally, OCaml has some of the advantages the author found in Scala while being more like Haskell. I would certainly consider at least playing around with it a bit--it's a very nice language. I still prefer Haskell, but not by too large a margin.