Here's the same in O'Caml, with comments:

let choices menu =      (* declare function 'choices'                             type of 'menu' is inferred to be 'string list list'*)    let rec helper menu sofar = (*declare recursive nested function 'helper' with two arguments *)        match menu with        |   [] -> print_string (sofar^"\n")     (* match 'menu' to an empty list *)        |   head::tail ->                       (* match to a list with at least one element *)                List.iter (fun item -> helper tail (sofar^item^" ")) head                    (* Function List.iter is called with an anonymous function                       as the first argument to recursively print out the menu choices *)    in helper menu "" (* Invoke the helper function *);;choices [["small"; "medium"; "large"];    ["vanilla"; "ultra chocolate"; "lychee"; "rum raisin"; "ginger"];    ["cone"; "cup"]];;

The above example shows the use of pattern matching (not the same thing as regex), which is one of the most powerful features of O'Caml. A longer example would be needed to properly highlight why it's so useful.

If you want a language that will not only teach you a lot, but provide a good practical experience, Ocaml wins. It has probably 85% of the expressivity of Haskell, but also good support for procedural and object-oriented programming as well. Because, as good as the functional style is, it isn't the end-all be-all of programming that some make it out to be.

It also has a fantastic implementation with an interpreter, byte-code compiler, and very efficient native code compiler (check out how well it did in the Computer Language Shootout.

There are also a fair amount of free resources. I'd start with this free book, or this tutorial. Later check out this book.

</advocacy>

Quote:Original post by Gage64
Some of the comments on O'Caml got me interested so I decided to do a google search on it. Interestingly enough, the 4th result was: O'Caml Language Sucks. Any thoughts?

Most of his complaints seem to be that Ocaml is not Lisp. For example, he complains that Ocaml lacks some Lisp features like macros and something called places. He also seems to be trying to use Lisp idioms in his Ocaml progrmas like his with-open-file example.

The only things he mentions which really bother me are the "Record field naming hell" and the lack of overloaded arithmetic operators (which I would rather go without than lose the static type inference).

Quote:Original post by Simian Man
The only things he mentions which really bother me are the "Record field naming hell" and the lack of overloaded arithmetic operators (which I would rather go without than lose the static type inference).

Type inference in SML works fine with overloaded operators for float and int math. My guess is that the O'Caml developers just didn't think that it was worth the trouble to implement. The record fields thing can be a bit annoying, but it is an understandable consequence of how the type system works. I suppose it could easily enough be fixed by requiring ambiguous field names to be prefixed with the name of the datatype defining them.

Definitely look at Haskell. Along with Clean and Miranda, it's one of the few purely-functional languages available. If you're coming from a purely C-family background, you may find it a little difficult to pick up though. If this is the case, you might want to look at Lisp first to help you pick up the most basic functional concepts (although to say that Lisp is a functional programming language is really missing the point of Lisp).

There are also a few excellent resources online for Common Lisp:

Practical Common Lisp - http://gigamonkeys.com/book/
On Lisp - http://www.paulgraham.com/onlisp.html (best read after getting a little experience with lisp)

I'd consider learning both an ML-family language and a lisp. They are quite disparate, and both have interesting and powerful constructs that are worth learning.