+1 for Elixir. If you like Rust syntax, you should also check out [Gleam], it compiles to Erlang and has full interop w/ Erlang/Elixir.

[Gleam]: https://gleam.run/

Hope that this one gets some more traction. ML on BEAM would be lovely.

I believe someone has made an OCaml BEAM compiler, but I don’t recall offhand if it’s just a hobbyist product or something that could be used seriously.

It sounds like you are talking about Caramel[1].

As far as I understand its serious enough but quite young.

[1]https://caramel.run/manual/

For me it was a similar story, after many years of python I got deep into the functional world with Elm, F#, some Haskell, and then I found out how complete the elixir ecosystem was but even a week later I could not stand going back to a dynamic and untyped languages, perhaps o didn’t insist enough with spec but I couldn’t go much beyond the second week. Did you have extensive usage of functional strong typed languages before elixir or just basic knowledge? Did it really get better that feeling of missing the types after a while? For me the difference feels as deceiving as falling from an full featured IDE to an environment with notepad and no source control and no compiler errors/stacktraces.

And I used to be the python guru at the previous company and made a whole lot of language evangelizing etc, I am afraid there is no way back for me.

I'm not sure where is the line between extensive and basic knowledge. Here is my more detailed exposure:

In commercial context:

* Of strongly typed ones only Scala (with [shapeless]). Can reluctantly throw in Kotlin as well for it's amazing structured concurrency.

In non-commercial context:

* Went through a few chapters of [Software Foundations] doing Coq proofs.

* Worked through most of the [Types and Programming Languages] (writing typecheckers in Ocaml)

* 3 services in Haskell (1 on Scotty, 2 on Servant). Loved persistent+esqueleto for the ORM layer, disliked Opaleye.

* 2 projects in PureScript (1 with Halogen, 1 with React bindings).

* 1 project in ReasonML (Ocaml).

-

> I am afraid there is no way back for me

I see where you are coming from. In my case I can alternate between "I want all invariants properly expressed and checked" and "I just want to ship that barely-working piece of junk and iterate on it". I learned to adjust depending on organization needs. IMO, for many orgs, especially startups/scaleups, the latter is often the more fitting way. With that in mind, I'm willing to trade the guiding hand of great type systems for other productivity aspects (amazing runtime and cohesive web framework in Elixir's case).

[shapeless]: https://github.com/milessabin/shapeless

[Software Foundations]: https://softwarefoundations.cis.upenn.edu/

[Types and Programming Languages]: https://www.cis.upenn.edu/~bcpierce/tapl/

Can’t speak for the GP, but the most difficult part of Erlang isn’t the syntax, but trying to clear my mind of how I would design something in C#/Java and embracing/understanding OTP.