Here are some references on Haskell:

Learning Haskell - http://www.haskell.org/haskellwiki/Learning_Haskell
Haskell in 5 steps - http://www.haskell.org/haskellwiki/Haskell_in_5_steps

You might even find the time to look into Natural Deduction - http://lambda-the-ultimate.org/node/1892

I have no experience with F# or O'Caml, and have only briefly passed upon some Haskell (It was assumed knowledge for a course I'm doing), but I would definitely recommend it.

Hope you find the time to read the material, as there are only benefits to gain.

Off-topic of Haskell, but on the topic of functional programming, there's a paper titled "Why Functional Programming Matters", it's an interesting read.

Here's a link to the .pdf (I hope it's free!) - http://www.md.chalmers.se/~rjmh/Papers/whyfp.pdf

You might find this free book helpful. It uses Scheme / Lisp though to illustrate the points but I think it is still a highly regarded book.

Structure and Interpretation of Computer Programs.

Quote:Original post by Luctus
We used The Craft of Functional Programming in our introductory course in programming. It's okay as a reference, but we barely used it as a teaching aid so I can't really comment on it as a learning resource.

That is also the "recommended reading" text for my "Formal Methods in Software Engineering" course.

I have read the first 9 chapters, although the only thing(s) I have gotten out of it are list comprehension and recursive functions, but I am slowly getting through it.

It's quite friendly to the reader (I really need to drill things into my head, I am a slow learner :)), and covers material in short, easy to understand paragraphs, which ultimately means the sections are fairly short and to the point (which is an excellent quality for a programming text!).

Quote:Original post by Gage64
A couple of questions:

1) I heard that Haskell is a pure functional language. Given that my goal is to learn a different way of thinking and not really a particular language, do you think that it might be a better choice?

2) I heard that F# is basically O'Caml minus a few features but is somewhat easier to work with (in particular, it's error messages are less cryptic). Do you think that would be a better choice? (again, for my purposes)

Finally, while learning functional programming sounds interesting, I'm sure it will be time consuming, so I would also like to hear some other suggestions.

Thank you both for your suggestions so far.

1) OCaml has imperative features but their use is frowned upon and they are not really obvious to use. you will actually have to hunt to find weird concepts like ref and magic. Just dont use the imperative features like loops and assignment, its simple.

2) (a) I think F# will be the better choice because. It is easier to work with since it is on the .NET framework and has the visual studio IDE. In addition to the massive BCL you get access to loads of libraries released for the .NET framework like SlimDX , SDL.net or the neoaxis engine which are CLS compliant.

(b) It definitely does not have less cryptic errors than OCaml. Because the language is not yet released properly About 40% or more of my errors give the highly descriptive syntax error. The supposedly cryptic errors of functional language will come to become vital to you. stuff like expecting type blah but given type bleh, type this and that are not compatible is actually nice and gets you thinking about what you are doing.

(c) F# is different from OCaml. Although they share the same large core subset, the following are different. F# has an optional lighter whitespace based syntax. This will be important because keeping track of semicolons and let bindings was hard for me when I started.

Most importantly F# does not have Polymorphic Variants nor Parametrized modules. F# does not have row polymorphism, it uses as is aproppriate on the .NET framework subtyping. Essentially F# classes and objects are very not the same as OCaml classes. This will likely be unimportant to you. What F# does have that is different is ad hoc polymorphism aka overloading, interfaces, Object Expressions, Quotations, Computation Expressions,reflection, Active Patterns/Extensible matching and I think that about covers the main differences between the two.

Finally F# has been getting alot of press since it is an official .Net language now but there is another OOP functional language called Nemerle* which I feel does a number of things better than F# (other things worse but I use both since on .Net using multiple languages in one project is no different than using multiple classes).

*That twice today Ive posted that. heh.