I'll politely hijack this thread to ask for suggestions about what functional language to learn next.

I have no functional experience apart from dealing with similar, toned down concepts in JavaScript.

I was considering Clojure or Elixir depending on tooling, ecosystem, market worth and most importantly, what can it teach me.

The reason I got inclined to Elixir was to learn Phoenix/LiveView. The reason for Clojure was it's very much adored here and it seems a good starting language for FP.

Rust is in my list but maybe sometime later this year.

While I like the functional aspects of Rust, not sure I would call it a functional language - still very much worth learning though.

Maybe a slightly unconventional answer, but F# is quite nice.

https://fsharpforfunandprofit.com/

As someone pretty plugged-in to the Elixir community, I can fully endorse it. There are a lot of really exciting new developments happening on the regular, but it also has really solid foundation, being built on the BEAM (Erlang's VM).

As a language, the syntax is pragmatic and approachable like Ruby, but the VM scales super well since it's Actor model provides concurrency by default.

There are even projects working to enable GPU-accelerated numerical computations (Elixir Nx) and Jupiter Notebook style collaboration and code sharing.

If you're primary goal is to learn something fun that's also great for getting actual work done, you'll probably really like Elixir.

My recommended introduction would be installing it, and running through their official guide from the top:

http://elixir-lang.org/getting-started/introduction.html

My 2 cents about how Clojure appears in StackOverflow surveys: https://piero.github.io/stories/2022/06/23/the-clojure-parad...

Key points:

- Most respondents are junior-mid developers.

- Clojure was written by an experienced developer (Rich Hickey) and is adopted mostly by experienced developers.

- Clojure is not beginner-friendly, however it is extremely pragmatical.

- The appreciation of pragmatism over perfectionism is an acquired taste, which takes time and experience to develop.

- It is remarkable how the love for Clojure came out despite its user base being so under-represented.

I’m sympathetic to both Clojure and Elixir (or Gleam), but for easing into FP then I’d start with F# (or ReScript), just because they are both in the OCaml family of languages (best in class for pragmatic typed FP), and because of everything Jesse Warden writes:

https://jessewarden.com/2021/01/in-search-of-the-best-functi...

F# in particular because of the established ecosystem and possibility to fall back to OOP if you need it, since it is multi-paradigm.

«JavaScript to ReScript» where he evaluates a lot of FP languages: https://youtu.be/dFHj1d9FG8M

NB: He’s all about static types though.

Clojure is an excellent language for high productivity within small teams but is a very rough beginner experience. The language itself is elegant and a joy to use, but there are plenty of sharp edges in getting a productive developer environment working and interpreting obtuse stack traces.

My experience with Clojure was that it wasn’t especially beginner friendly. With elixir you can have a simple app running within a few minutes and there are a lot of up to date learning resources.

As someone using Elixir since 2013, I would suggest always learn you some lisp.

They work really well together. Check out Rustler.[1]

[1]: https://github.com/rusterlium/rustler

Both Rust and Elixir are languages people generally love, and I too really like them both.

I'd recommend Rust even if just because the available material for learning it is really good: https://www.rust-lang.org/learn

I'm just recommending Rust in general, not over Elixir, because I've never used Elixir and have no experience in that area. Rust is a pretty easy language to love.

Yeah elixir is really nice for distributed stuff. It’s pretty easy to toss in some rust with rustler if needed, but often you won’t need it. If you’re waiting on IO at all, it will likely outweigh the benefits of jumping to rust at least in some cases I’ve seen. That said, they’re both really interesting languages.