Think of it this way, the way Python/Crystal/Etc parallelization is is how OCaml’s is in it’s stock compiler. It has great concurrency, but no built-in parallelization due to a GIL.
However there is a multi-core ocaml compiler out (which you can install) that gets rid of the GIL and is experimenting with an Algebraic Effects system (hands down one of the best I’ve seen for a statically typed language out!) that will let you implement any form of concurrency and parallelization that you wish from both cooperative and preemptive multi-threading to Actor style systems to whatever else you can come up with. It will not be merged into OCaml’s core compiler until it is very well defined and set. OCaml seems slow moving at times but only because they exceedingly think through the design of features that are added to it now (it had issues at the start of some odd design choices that are hard to go back on now, specifically some of the standard library calls that they have better alternatives for now but they keep the old calls in for backwards compat).
However, like Python/Crystal/Etc… you can parallelize OCaml via starting multiple processes (this is how it’s web servers work for example, a set of worker processes to handle socket tasks).
Actually if you are going in to it for learning purposes I’d say learn a lisp’y language first, like https://racket-lang.org/ as it will teach you so much more. It even has a HM-style typed variant (
typed-racket) built in! A Lispy language is so powerful that it can quite literally take any feature from any language anywhere and integrate it fully and easily. Learning this power is an amazing ‘opening’ of how to do things. I like OCaml because I use it like a faster and safer Python when I don’t need a python-specific library (and ocaml has a lot of libraries to choose from), plus easier C/C++/Rust integration.
Erlang/Elixir are interesting as they are a pure Actor model. Erlang is prolog’y and Elixir is Ruby’ish. One big thing Elixir has over Erlang is an almost lispy style macro support, which is quite nice to create DSEL’s with, though the underlying language hampers its full use.
No point learning swift/elm if you learn OCaml as OCaml will teach you the basics of better than either. Swift has a nicer syntax though, but not quite as powerful and safe.
Prolog is amazing, not something you’ll use but it is a fantastic thing to learn with how it kind of ‘inverts’ everything (this is where erlang/elixir got their Pattern matching idea from!).
Scala is basically a classful, JVM, Haskell, it’s awesome if you want to use the JVM, otherwise meh.
D was designed to be a better C++, and it really is, but it’s ecosystem is… a mess. ^.^;
Also add Forth to your list. Forth is one of the languages I have the most fun with. You can implement it in almost any language very easily (even implemented in assembly it’s only a couple thousand lines) and writing programs in it is like a puzzle, so succinct, readable, and easy to use, but crafting the ‘incantations’ to manage the stack right is a real brain teaser at times but SO nice when you figure it out. Forth is the unheralded champion of trivially embeddable languages used in places you wouldn’t expect (from water readers to NASA satellites) that works at dang near native speed with little work and is trivially implementable.
Just started looking at Nim recently as well for a Learning purpose and it’s pretty interesting. I’d pick Rust for real work over it easily, but it is absolutely in the realm of speed of Rust and C/C++ with full parallelization and concurrency. Fascinating little language.