You can't bypass Haskell no matter whatever FP language you want to learn. Because Haskell is like the textbook of all FP languages with a lot of important features.

And if you like scripting, try Clojure, it's immutable but much more dynamic and flexible. Since I'm a big fan of Clojure, I will suggest Clojure as the choice.

Other languages are also nice. Each of them emphasis' on a subset of the features, like immutable data, algebra data type, lazy evaluation, JVM integration, JavaScript integration, pure, S Expressions, performance... You'd better find out what you want most and choose the best one you can live with.

I would say it depends on you :-), the amount of time you are dedicating to this learning and what is the goal of your learning.

It's easier to start learning a language in your current environment, for example learning Scala if you are a Java developer or learning F# (OCaml-like) if you are a c#.

If you wanna master functional programming thinking, maybe Haskell or Idris are the best school (language fully based in the concept of function as mathematical entity, pure as they don't have side effects).

I will love to learn Elixir or Erlang but more for the beauty of OTP and the elegance of the actor model than the languages themself.

Clojure is an interesting language (lisp family) and JVM world, but here you are more in the dynamic world (vs strong type system as Haskell or Idris), so it may be an option if you are interested by an elegant implementation of a dynamic language.

You can add many other interesting languages to the list (like Elm-lang which is a very intersting option if you want to do web development using a functional language)

So every language have his pros and cons, define your goal and the amount of time you will dedicate for this learning, if you can experience different language that will be even better.

Cheers

if you are just starting programming, then I would advise you against functional programming. If not, go Scala. It's a perfect practical language. But, if you are in search of purity, go Idris or Haskell.

Functional Swift By Chris Eidhof, Florian Kugler, and Wouter Swierstra Available at Amazon, but updated for Swift 2.x at objc.io objc.io/books/functional-swift/preview

JavaScript is also a candidate.

drboolean.gitbooks.io/mostly-adequate-guide

My first introduction to functional programming was Land of Lisp by Conrad Barski. I found it nicely written, with a lot of cartoons (but not too many) to make it more engaging. I ended up liking Lisp better than the other functional languages, but then I haven't done any major Lisp projects yet.

I still recommend the book, though. It's a good (and yet fun) intro to functional programming, even if you plan to use a different language in the end.

I recommend you to pick Elixir.

I can't describe it without writing a roman but here are some points which I do love about Elixir.

• Elixir uses immutable datastructures all the time.
• Elixir syntax is inspired by Ruby <3
• Elixir strickly follows pattern matching.
• Elixir is mostly written in macros.
• Elixir allows meta programming.
• Elixir has great tools like mix which create, compile and test your project.
• Elixirs code documentation can be used for unit tests through running mix.

• Elixir runs without performance penalties on ErlangVM.
• Elixir can interop with Erlang code and libraries.

• Elixir inherits all the great goods of ErlangVM. (Too much to list here)

Functional programming boils down to one simple idea: do everything with functions. No other language can show you the power of functional programming as Scheme will. It has a small core and it's easy to learn and with minimal accidental complexity.

Haskell is another language you can pick. It has a great community and can help you see programming from a different angle. Keep in mind that Haskell can be a bit frustrating at first. You will be introduced to a lot new concepts and paradigms.

As Jan mentioned, if you want to do something meaningful and get real work done, pick Scala.

If you're looking to learn all the ins and outs of functional, go Haskell, if you want to get real work done, go Scala