Specifically, I’m interested in BEAM, but I’m not sure if I should go for Elixir or Gleam. What seems cool about Gleam is that it has static typing.
I have no experience with functional programming at all btw
Haskell:
https://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).
In practical terms, “monad” means “chainable”.
And I thought it was about morphisms and burritos. The more you know…
Uummmm
Haskell isn’t the best venue for learning currying, monads, or other category-theoretic concepts because Hask is not a category. Additionally, the community carries lots of incorrect and harmful memes. OCaml is a better choice; its types don’t yield a category, but ML-style modules certainly do!
@thingsiplay@beehaw.org and @Kache@lemmy.zip are oversimplifying; a monad is a kind of algebra carried by some endofunctor. All endofunctors are chainable and have return values; what distinguishes a monad is a particular signature along with some algebraic laws that allow for refactoring inside of monad operations. Languages like Haskell don’t have algebraic laws; for a Haskell-like example of such laws, check out 1lab’s Cat.Diagram.Monad in Agda.
When I read about Monads, it looks like to me like generic Rust struct with a generic trait and a (more complex) result as a return value. I have no idea if this is what a Monad basically is or not. For context, I never learned Haskell properly (just tried hello world and read a few topics).
You should think of
Monadas basically giving you a way to provide your own implementation of the semicolon operator so that you can dictate what it means to sequence computations of a given type.I think the mistake I do (and many others) is trying to compare existing mechanisms from other languages, without the full picture around that mechanic. Every time I think to understand what a Monad is, its wrong. :D Guess I have to dive deeper to understand what that actually means, not just as an explanation. Just out of curiosity.
Why do you want to learn functional programming? If just for fun and learning, then you can’t go wrong with scheme.
Kinda funny, I’ve also been thinking about scheme as another option. Yes, (currently) it is just for fun and learning.
“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
You misspelled Haskell.
Raymond’s document does not, and I believe never has, mentioned Haskell.
I also disagree with him, given that it does recommend Java, but the quote is correct.
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#?
I feel like this is the way. It ensures you get exposed to multiple paradigms and can help you easily switch to a language that’s more invested in one paradigm.
I second this. And bonus point: This way you’ll learn a language that has actual real world applications. All thos obscure single paradigm languages are nice toys to play around with, but that’s about it.
I’d just like to mention ML, as I myself found its type system really enlightening.
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.
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 |> Funwas 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.
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 (https://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.
₹ = Indian Rupee, in case anyone is wondering.
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.
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).
I would advise going in the opposite direction, learning a purely functional language first to then being able to appreciate functional parts
That is beside the point of an opinionated list of the good and the bad, that will differ for others
The only things on the bad list that I agree with are top-level type inference and small communities. And ocamls windows support is terrible. Haskell’s is more than ok now.
In Haskell, any style guide worth its salt requires annotations on top level functions, and many of them also require annotations on local bindings. This pretty effectively works around the problem.
Bad code will be unreadable in any language of course. But the other things don’t themselves make code unreadable once you’re actually familiar with the language and its ecosystem.
Bad code will be unreadable in any language of course.
Yeah I’m talking about good code, or at least not bad code. Let’s not “no true Scotsman” this.
Even for good code you don’t need syntax highlighting to easily see which identifiers are function names and which are their parameters in Rust.
I don’t need syntax highlighting for that in Haskell either. My usual highlighting just leaves them both in the default text color.
And I’m specifically arguing that the other things on your list do not inherently make code bad.
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.
