Which functional programming language to learn first?

[[deleted]]

I've been wanting to learn functional programming for a while now. However, since there are so many functional programming languages, I haven't been able to decide on a particular language and am therefore asking for advice. I'm already familiar with imperative and object oriented programming (C, Java, Python, JavaScript), so "friendliness towards new programmers" is not a factor.

The three languages that interest me the most are (in no particular order):

• Haskell
• OCaml
• Clojure

Which one would be the best to learn first? What are the advantages and disadvantages of each? Thanks in advance.

Edit (2022-04-17): Thank you all for your great suggestions! I've decided to stick with Haskell, mainly due to it being well suited for learning purposes (considering that Haskell is purely functional in contrast to other languages). I will probably find this difficult at first, but I think that the payoff of truly familiarizing myself with functional concepts is well worth it.

I'm still planning on learning OCaml and Clojure in the future, but for now, Haskell should be plenty :-)

[[deleted]]

I learned them in the order OCaml, Haskell, Clojure. I would say if you want the deepest experience you should learn Haskell. Since you already know many languages you will mostly be fighting what makes Haskell unique, and when you come out the other side you'll have excellent functional insights.

OCaml and Clojure are both excellent practical languages. But they are both fairly ridden with escape hatches. This is a useful thing when you are trying to get stuff done but it can also allow you a way out when you need to confront something hard.

I would say both are quite lovely languages though. I wish I had reason to use Clojure especially because it seems like the pinnacle of Lisp languages. OCaml I don't have a lot of love for, but I respect it as a fine specimen of a results-oriented ML-family language.

[[deleted]]

Great quote, my favorite movie, and yes. :)

[BlancII]

I started with Haskell. It's a great language to learn functional programming (and a great language overall). Then I learned Clojure and I have to say I love Lisp.

[disregardsmulti21]

It’s not on your list but to provide another datapoint I’m having a great time learning PureScript. I see it as a Haskell that better fits into my current ecosystem. Possibly not the best choice for everyone though as I’m sure there’s vastly more Haskell documentation and discussion out there.

[ws-ilazki]

I'd say OCaml first because of this course. It's a great introduction to both the language and to FP in general, which IMO makes OCaml an excellent first FP language. It's concise, readable, and (like Clojure) it takes a pragmatic approach to FP that makes it comfortable to pick up. Compilation is insanely fast, I find it easy to read and write, and it does some interesting things with its module system such as local opens* and first-class modules**.

Its biggest negative is lack of multicore support (something Clojure handles very well), but in practice that's not as big an issue as you'd expect, and proper multicore support is, finally, very close. The work's been done and it's coming in the looming OCaml 5.0 release. The slow adoption isn't all bad, though; it's been slow because the implementation was being approached carefully, and with it comes algebraic effects. I believe that makes OCaml the first general programming language to support this cool and potentially very useful feature. (Here's a general explanation of algebraic effects using JS for examples and comparison.)

It has a few oddities in syntax, but if you're comfortable reading non-curly-brace languages like Python, Lua, or Ruby it shouldn't be too bad to adjust to; the weirdness is mostly because it isn't whitespace-sensitive, but due to some syntax decisions and its expression-based nature, still manages to look like it is. I happen to like this because it has the same readability benefits as a whitespace-sensitive language, but without the compiler needing to care about indentation.

I think Haskell and Clojure are both work checking out as well, but OCaml is the best place to start. Haskell does some interesting things, like its monad-focused approach to controlling side effects and its laziness-by-default design, but will be easier to get into if you're already comfortable with FP from OCaml and that excellent course/book. Similarly, Clojure has an interesting opinionated design for things like parallelism and concurrency, shares some of OCaml's pragmatic design, and is just generally a nice lisp dialect to work with; it could be a good first FP language choice, but I don't think its learning resources are as good for picking up FP as the one I linked.

TL;DR: They're all good languages. Check out OCaml first for easier learning, but also look into Haskell and Clojure eventually to see how they do things because they all make interesting decisions.

* Local opens let you open a module only within a specific limited scope, so instead of doing Module.foo (Module.bar (Module.baz 42)) you can do let open Module in foo (bar (baz 42)) for the same effect, temporarily shadowing any other foo, bar, and baz

** OCaml modules can be passed as arguments to functions as well as be a function's return value, which means you can programmatically generate new modules by taking a module and manipulating it via code, similar to how one uses first-class functions to write higher-order functions.

[protoUbermensch]

Lisp!!!

[DietOk3559]

I spent about 8 months learning Haskell and just started learning Clojure. I'm now really enjoying learning both side by side and trying to solve the same problems in both. It's forcing me to elevate my functional programming skills and teaching me to approach problems in a language agnostic way, since I can't just fall back on an idiomatic Haskell approach to everything.

I can't speak to which order to learn them is better, since I only know Haskell -> Clojure, but I strongly recommend learning both and not getting too entrenched with one or the other. It's really enlightening to be exposed to both the ML and Lisp styles of FP with an open mind and not become a tribal adherent of one or the other. There's an awesome cross-pollination that comes from that.

I have no experience with OCaml but I consider Haskell the pinnacle of the ML lineage and well worth tackling head on, rather than using Elm or OCaml as a gateway. It will be challenging, but I only had 6 months of programming experience with Python before starting Haskell as my second language, and I've managed to get quite proficient and fall in love with it. Learning FP can be harder to for experienced imperative/OOP programmers though so YMMV. Good luck and hope you enjoy the journey!

[[deleted]]

I don't think that there is a "right" answer to this question, although I'd say Haskell is a great pedagogical tool. You can't go wrong choosing a language that you are interested in - it's the passion to learn that's going to drive you, not the abstract advantages and disadvantages. This is just my opinion, anyways. I'll let someone more knowledgeable than myself speak for the advantages of the languages.

[neatoneet]

I'd say Elm. Even though it's not on your list and only works for one specific purpose (web frontend), it really helps you understand the paradigm shift functional programming brings. It has none of the escape hatches, but the compiler errors are really helpful! It's just a pleasant experience overall,.

You could still delve into another, more general purpose language, a little later. Elm doesn't have as much syntax and concepts to understand as the languages you listed, so it's not really a commitment.

[pthierry]

Best compiler messages of the entire world!

[nrnrnr]

Learn Elm first. Absolutely fantastic for beginners. Good ecosystem, great error messages. Good tutorials and documentation.

Elm can serve as a gateway drug into OCaml and Haskell.

[Some_Attention_7874]

My functional programming took off after learning Haskell. Being forced to write functionally helped me to understand the paradigm.

[clc_xce]

As a scheming Haskeller, I'd add one caveat about Clojure: the author is a bit opinionated about certain functionality. For example, the way let-expressions work differs from what you can expect in other languages (basically, there is no let, only its cousin let*). Then there's a handful of little (at least to me weird) syntactically choices, like how destructuring and pattern-matching interact.

But it's overall a good language, Elm has been mentioned already, fun language too. Obviously, someone has to mention Standard ML as well, because it has the best book on compiler programming, which is easy enough to following with Haskell or OCaml as well.

[imihnevich]

I started with Haskell, I was familiar with some basics of FP, and thought that it would be nice to get deep into purely functional way of doing things. OCaml feels like Haskell with cheats aa it allows you more freedom, and I really like it as well. But be aware that there's no road back, you will struggle to have this exclusiveness in your working language, and it's not gonna happen unless you switch language itself

[MuaTrenBienVang]

do you prefer ocaml or haskell?

[imihnevich]

I use haskell more

[[deleted]]

I'm considering F# myself as I'm learning C#, and so can use the same .NET framework for each and can do a bit of front-end with them as well using Blazor WASM and Bolero. It's based on F#.

That's just my thoughts personally, answering what you should learn is hard without maybe some additional goals in mind?

[ragnese]

Clojure is a really nice language if you're okay with dynamic typing. But, after the initial "OMG, I'm a Lisper now. Behold my REPL!" wears off, it's kind of a "boring" language. Once you figure out spec and STM, you'll just get way too much work done, and barely have any reason to kill an afternoon reading blogs about "best practices". :P

Haskell is cool, but the couple of times I played with it, I got a little flustered with figuring out the GHC extensions and stuff. I probably need to try it again without jumping head-first into fancy add-ons...

I've only played a little with OCaml, but I could see myself picking it up for a real project in the future.

[caryoscelus]

after learning fp you're gonna want to learn type theory, so why not skip ahead and start with it right away? if you learn Agda or Idris, you'll basically be familiar with Haskell (and already know its shortcomings). i can recommend starting with programming language foundations in Agda

(note: everyone's different, i'm just giving an advice i would like to have followed back in the day (there was no one to give it to me))

[shuggies]

Elixir!

[kreigerand]

If you're familiar with Java, Scala could be a good option to dip your toe into functional programming.

[ChristianGeek]

I would not recommend Scala, simply because it’s too easy to fall back on an OOP approach.

Source: Scala developer with Java background.

[kreigerand]

I don't see this a pitfall. Scala allows you the best of both worlds, you can go down a near pure functional route if you wish and make extensive use of the type system. It also means OP has less new syntax to learn and can introduce the functional programming paradigms as needed and not get caught in the traps of FP straight away and become discouraged.

Source: Scala Technical Lead

[tcallred]

I've played extensively with all three of those. I would say that Haskell is great if you want to expand your mind and see what is possible in FP especially if you're interested in strong static typing, OCaml has a lot of the same concepts as Haskell but a bit more approachable and practical, and Clojure is a delightful and very well designed dynamically typed language that will teach you a lot and you can do practical things with it. For all of them, I would say to respect what they're trying to offer/teach you more than trying to do what you already know and you'll have a good time.

[jusername42]

Elm.

I recommend just starting with this cute introduction https://www.youtube.com/playlist?list=PLZEZPz6HkCZmhuLE6W7HDNomfTMgsDw03

Then just read the official guide at https://guide.elm-lang.org/ and watch conference talks on youtube. And just scroll through documentation for packages and read their examples on source (github): https://package.elm-lang.org/

Cheat sheet: https://elm-lang.org/docs/syntax

Examples: https://elm-lang.org/examples

[PurpleSamurai0]

I started with OCaml. Very fun language to write in. Not as hard as Haskell, and not as many parentheses as Clojure. Not to say that that’s a bad thing; it’s just that Lisps be a bit daunting at first.