Why do you want to learn functional programming? If just for fun and learning, then you can’t go wrong with scheme.

I think it doesn’t matter in what language you start, as long as it is the paradigm you are learning. You can still pick and choose the language later. Maybe start with a pure functional language, just to learn its concepts. Haskell comes to mind, but it kind of is not the best usable language in every day programming; its more academical nature in my opinion. I personally find Closure also interesting, but I’m not the biggest Java fan at all. At least the language is for practical usage.

I’d go with Erlang over elixir, but it sounds like you already have an interest in gleam.

FWIW: just pick one and get started. There are some major axes to consider: pure versus impure, lazy versus strict, static versus dynamic typing, but to kick off if you’ve done no FP before it’s probably better to just go for it.

There are some really intriguing “next steps”: SICP, the ML module system, the Haskell ecosystem, the OTP approach to state, but to begin with it’s just worth getting used to some basics.

F# is “beautiful” and “pretty well supported”, making it a good ramp-up.

Scheme.

Haskell:

learnyouahaskell.com/introduction

It’s been a while since writing some (2018), but the concepts you learn from Haskell are great (though I still can’t explain Monads, even if my life depended on it) and can be applied in other languages.

Anyway, I can’t speak to BEAM, but Haskell is very typeful, it teaches you currying, very great language, awful tooling (but that was ~10 years ago, so I hope things have improved since).

Clojure always seems to be more popular than I expect it to be. Though I have no experience with it myself. It benefits from access to the JVM ecosystem as well I believe.

If you’re interested in BEAM anyways, Gleam is just a lovely language to work with. It makes many functional principles easy to work with rather than mathematical. Although I don’t have any experience in Elixir, so I can’t judge how it compares in detail.

I’d just like to mention ML, as I myself found its type system really enlightening.

“Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot.” — Eric S. Raymond, How to Become a Hacker

I love functional programming and hate object oriented. It’s just how my brain thinks, I can and regularly do OOP, but I have to force myself to do it. Why not python? You can do BEAM in python, it’s pretty easy to learn, and it’s incredibly versatile, and you can program functionally in it too.

Elixir is quite amazing to write and read, the major libraries (Pheonix, Ecto, etc.) have excellent documentation, the tools are generally excellent and it is built on to BEAM which is amazing. But it is a dynamically typed language with all the pain that can incur. Of course, there are tools (such as Dialyzer) to give some amount of static type checking but they were not very good when I tried them some years ago. Using things that need mutation can also be a pain. Programming Elixir 1.6 Functional |> Concurrent |> Pragmatic |> Fun was the book I used to learn functional programming and Elixir and it served me well.

There are other good languages you can look into such as Ocaml (that has good free resources for new programmers) and Racket with the amazing free course you can find on OSSU.

Rust is not fully functional. But I am legally obligated to recommend it any time I can.

Jokes aside, this doesn’t apply to you, since you seem to actively learn functional programming. But for people that are scared of it, rust looks like “normal” languages, but has tons of features that can be attributed to functional programming. Even more so if you avoid using references. You can easily “mutate” objects the functional way, by passing the object to the function, and the function creates a new object with just some value changed.

It has algebraic data types. Function pointers. Iterators. Pattern-based match statements. Don’t have class inheritance. Inmutable by default. Recursion. Monads. And probably other FP features that I’m missing.

It has basically every functional feature while having familiar syntax.

It’s also extremely easy to install. Which I didn’t use to appreciate, but then I tried to learn OCaml and had to give up because I couldn’t set up a proper dev environment on windows.

My ₹1. It may depend on what you plan to write in it (for fun). The BEAM sounds great for long-running processes, but not as much for point tools; Erlang and co supposedly run slower than Python, which isn’t fast either.

My other ₹ ;-) if you stick to the BEAM: OCaml sort of runs on it, as there is the Caramel project to replicate it (caramel.run). One of the Erlang creators also ported Prolog to the BEAM (erlog), as well as Lua (erlua) and Lisp (LFE). Elixir is probably great, as it is inspired by Ruby (I found Ruby very pleasant, other languages have so much semantic noise).

Freebie! The BEAM inspired an inspirational design for parallel programming, the Pony language. I am somewhat sad development slowed down, it is a Rust killer.

I’d start with logo.

Rust. It has all the good bits of functional programming but basically none of the bad bits.

Good bits:

• Strong type system (though not quite as sophisticated as Haskell or OCaml).
• Map, filter, etc.
• First class functions (though lifetimes can make this a bit awkward)
• Everything is an expression (well most things anyway).

Bad bits:

• “Point free style” and currying. IMO this is really elegant, but also makes code difficult to read very quickly. Not worth the trade-off IMO.
• No brackets/commas on function calls. Again this feels really elegant but in practice it really hurts readability.
• Global type inference. Rust requires explicit types on globals which is much much nicer.
• Custom operators. Again this is clever but unreadable.
• Small communities.
• Poor windows support (not a fundamental thing but it does seem to be an issue in practice for lots of functional languages).

gleam feels cozy.

Clojure is simple, is a lisp (huge plus since they are super simple and you gain access to a whole realm of languages), and practical. You can do anything from backend to frontend dev with it, and the philosophy and community are lovely.

Scheme is less practical but easier to start with.

Haskell is the least practical but isdefinitely beautiful and helps you understand things better.

I assume this suggestion will get me torched for reasons I don’t understand, but why not a multi-paradigm language like JavaScript/Typescript, or C#?

Erlang learnyousomeerlang.com If you know golang and recurrence it should be easy, google basically stole channels from Erlang and syntax from Swift. Like everything else, they just stealing stuff and claiming they’re great. Fucking rich script kiddies.

I’ve only used one, and I’m only mentioning it since nobody else has, but I recommend Lean; moreso as a second functional language if you want to build stuff as opposed to just learn the paradigm. It’s mostly used in maths because it supports dependent types, but it was fine for writing simple scripts, and it can be easily compiled to binary formats. I don’t like the package management system and toolchain complexity, but most languages kinda suck at that, imo.

I did a functional programming course in university snd we learned Haskell and really loved it. By far my favourite subject in all 4 years of uni. Have never used it since tho but it was fun XD

F# is a decent introduction into functional programming. You can use .NET libraries and occasionally fall back to imperative code when needed.