Here’s a reasonably exhaustive list of languages that do:

https://gist.github.com/macintux/6349828#alternative-languag...

Luerl is probably the closest thing in terms of semantics, but Elixir might feel right in terms of Syntax. Actually running Python on the BEAM would probably be pretty challenging based on what I've read about the GraalVM python efforts.

There is efene (https://efene.org) which claims to embrace the ZEN of python.

go for elixir. the differences compared to python are minuscule.

Python and Elixir could not be further from each other. Just for starters, Python is OOP and Elixir is FP, which is a far bigger difference than you seem to imply. Elixir is compiled while Python is interpreted. Python has absolutely incredible community package support while Elixir is much more niche. It's hardly miniscule. It's a completely different way of programming.

I think the parent comment is referring to the philosophical similarities. Both languages focus on constrained and careful language design, good standard libraries, friendly human readable syntax, and saying no to requests that don't fit.

OOP and FP are really not all that different anymore. I joke it's become like risc/cisc: OOPLs (including python) these days have lambdas, map, and reduce... Elixir has inheritance (behaviours) and polymorphism (protocols).

What elixir doesn't have is pass-by-reference. Which, imho, is a huge win, unless you are going matrix math.

Polymorphism is not an OOP concept. Behaviors are like interfaces, not inheritance. Behaviors allow dynamic dispatch but let's not try to fit OOP where it doesn't belong.

When people talk about how similar are OOP and FP languages they miss the elephant in the room - immutability.

Maybe my PL history is wrong, but weren't interfaces made popular by java as a way to avoid C++ - style problems with multiple inheritance?

> When people talk about how similar are OOP and FP languages they miss the elephant in the room - immutability.

>> What elixir doesn't have is pass-by-reference

But immutability is not INHERENT to the FP style. In the strictest sense BEAM languages are not immutable, because message-passing is not state-safe, and there's also the Process library (and NIFs), but practically they are. Julia is also a very powerful FP language that isn't immutable by default, and Swift is an OO-ish? is it OO? language that is pass-by-value by default.

You're not going to run imperative code on BEAM (or ERTS?). It just wasn't built for it.