OCaml for the Masses

Re:OCaml for the Masses by rauljara on Wednesday January 18, 2012 @04:41PM (#3481965)

To someone who has only just looked at Haskell (and not gotten very far) the syntax looks very similar. Can anyone speak to the differences between the two languages?

[ Parent | on HN ]

Re:OCaml for the Masses by mbowcock on Wednesday January 18, 2012 @04:50PM (#3481987)

http://matt.might.net/articles/best-programming-languages/

This write-up describes the basics of ocaml and haskell and some of their individual strengths. (along with scala and scheme)

[ Parent | on HN ]

Re:OCaml for the Masses by tel on Wednesday January 18, 2012 @05:34PM (#3482179)

OCaml is strict and impure, Haskell lazy and pure. Syntactically they're pretty different, but since they both make heavy use of the H-M type system you see pretty similar semantic operations across the board. Probably the first thing that sets them apart is that IO is a lot more direct in OCaml, a direct implication of strictness and impurity.

Extensions to the type system are really different, OCaml's is more flexible and specific, but Haskell's is very convenient, but by the time that becomes an issue you'll probably know a lot more of how the languages differ.

[ Parent | on HN ]

Re:OCaml for the Masses by eru on Thursday January 19, 2012 @05:49PM (#3487265)

> Syntactically they're pretty different,

Did you want to say that they are pretty similar? Or semantically different?

[ Parent | on HN ]

Re:OCaml for the Masses by tel on Saturday January 21, 2012 @01:46PM (#3494226)

Syntax is different, semantics are informed by the type system so programming in one after being familiar with the other is pretty concept-friendly.

[ Parent | on HN ]

Re:OCaml for the Masses by stonemetal on Wednesday January 18, 2012 @05:29PM (#3482158)

The type systems is one major difference. OCaml as the name suggests supports objects. Haskell's type system is more expressive. I believe OCaml's type inference system is fully decidable Haskell's isn't. The evaluation models are different Haskell is lazy default, Ocaml is eager default. Ocaml doesn't support multiple native threads(green threads only.) Ocaml isn't pure.

[ Parent | on HN ]

Re:OCaml for the Masses by eru on Thursday January 19, 2012 @05:51PM (#3487274)

> I believe OCaml's type inference system is fully decidable Haskell's isn't.

That depends on the extensions you are using.

The biggest difference between the typesystems in practice seems to be the ubiquitous use of type classes in Haskell. OCaml's modules can do the same as type classes, but they require annotations and aren't used as pervasively.

[ Parent | on HN ]

Re:OCaml for the Masses by zem on Wednesday January 18, 2012 @07:40PM (#3482636)

ocaml is multiparadigm and eager. in practical terms it has excellent support for just hammering out a solution in an imperative fashion and then refactoring it once it works. i personally find it second only to ruby in terms of getting work done.

[ Parent | on HN ]

Re:OCaml for the Masses by michaelochurch on Wednesday January 18, 2012 @07:19PM (#3482565)

Haskell: lazy and essentially pure. In Haskell, an Int is a lazy thunk that returns an Int, so if you write "a = 5 + 6" you're actually creating a thunk that will compute 5 + 6 if needed. For side effects, you use the IO monad and construct an IO Int, a type of a thunk that does I/O (all side effects are treated as IO) and returns an Int. Note that the Int can be evaluated once and its value stored, but the IO Int has to be evaluated again and again (because it may change, and if it's being eval'd multiple times that means we want to enact its side effects multiple times).

Ocaml: strict and impure if needed, but has everything you need to write great functional code (and not much more, which makes Ocaml actually fun to read; I can't say the same of that horror they call C++). I tend to think of it as a functional C. It's a bare-bones, simple language but it's awesome.

Haskell uses type classes for what Ocaml achieves more generally (but also with more work) with functors. Type classes are prettier. Functors handle complex cases (multiple related types) better. Hard call which is "better".

Haskell is more mind-blowing, Ocaml is more practical for most purposes, but probably not as practical as Scala. I like them both (and Scala).

Sadly, I wouldn't bet on either reaching the mainstream. Haskell is lazy, which makes it really hard to reason about memory usage. Ocaml's a great language, but the libraries available are quite poor and the effort to get it ready for multicore is DOA. I wish these languages have more of a future than I think they actually do. Now we're in the "raiding phase" where languages like Scala are borrowing awesomeness from them just like Ruby and Python did to Lisp 15 years ago.

On that, I think Scala's actually a good bet for the next 5 years, and not a bad language at all, although it's hard to learn because most of the online resources are pretty poor. (Odersky's Scala book is great.)

[ Parent | on HN ]

Re:OCaml for the Masses by rauljara on Wednesday January 18, 2012 @07:49PM (#3482665)

Thanks everyone!

[ Parent | on HN ]