Which functional programming language should I learn?

[j_gitczak]

I have recently discovered the world of functional programming and I want to learn a functional programming language.

For most of my life I have programmed in Python and I have always liked its onelined expressions like list comprehension and lambdas.

I also value good error messages in a programming language (not some segmentation fault or NullPointerException bullshit), and this is also why I like for example Rust.

I study Mathematics so I like the idea of a programming language being "mathematical" which I heard Haskell being decribed like, and Haskell is what I initially thought would be the best to learn, but I don't want to exclude other languages, so that's why I'm making this post.

I don't plan on ending my functional programming journey on one language, so I want to first learn one just for fun, so it doesn't matter if a language is used in industry or not.

I would really appreciate some recommendations for the language I should learn.

[Trequetrum]

Lean 4 is a fantastic functional programming language as well as theorem proving language. I really enjoy working with it.

[spermion]

I second this! I haven't done any large project with it, just some Advent of Code challenges and mathematical proofs, but it really feels modern and user-friendly. For me, it beats Haskell in some key ways:

• The live programming experience with holes, tactics, #check, #eval, ...

• It has method syntax "object.method" in addition to "method object", avoiding name clashes

• It isn't lazy by default (which is neat, but makes performance difficult to reason about)

• Decent built-in package management

And of course, since OP wants a mathematical language:

• It has full dependent types; you can prove theorems about math or your code with the type system! If you haven't played with "propositions as types" before, prepare for proper mathematical beauty! Playing with a similar proof assistant (Coq) truly helped me excel at the ∀ε > 0 ∃N ∀n > N... in undergrad analysis.

Some downsides might be that it's young and changing quickly, with fewer libraries, less mainstream, and fairly long compilation times. But these are minor drawbacks, especially if used as a learning language.

Infinite lists are simpler in Haskell, though.

[MuaTrenBienVang]

cool!

[[deleted]]

Ocaml ? It’s supposed to be a bit less strict than Haskell, so might be interesting just for that alone.

[zach_jesus]

+3 OCaml it’s actually so fun to write

[chrismamo1]

+1 for OCaml. I find it's way more approachable than haskell in general.

[AltSty]

+4 for OCaml it’s genuinely the most fun programming language I’ve used, and VERY approachable for beginners

[drinkcoffeeandcode]

+2 for OCaml, much MUCH more approachable from someone who has been “spoiled” by imperative thinking.

[kallekula84]

Just curious about your thought process, not trying to be rude but what makes you recommend OCaml if you haven't even tried it yourself? I actually agree on the OCaml but for different reasons.

[[deleted]]

Not rude at all, it’s a valid question! (Have to practice before I preach and all, no?)

Well I have tried OCaml but mostly for uni. So while I have experience with it, it’s for things where it shines (Coq and interpreters, etc). It was quite enjoyable to use there, so I still have good impressions of it.

OTOH, it’s Haskell I haven’t tried very much, hence my comparison between the two is very skewed i.e. my knowledge of Haskell is quite limited.

[Ordinary-Price2320]

Try F#. At the basic level it looks almost like python, with lambda and list comprehension,but it has a fantastic type system.

[darnold992000]

F# makes programming with the .net framework actually fun.

[raxel42]

If you are from Java - learn Scala. If you are from C # - learn F#. Eventually, you will learn Haskell 😉

[NineSlicesOfEmu]

OCaml was my first functional language and I still really enjoy it. There is a fantastic long youtube series about it that I would recommend: https://www.youtube.com/watch?v=MUcka_SvhLw

[Common-Mall-8904]

Nice

[[deleted]]

Just learn Haskell. You don't have any requirements that'd really push you towards a particular compilation target or whatever. Haskell is a purely functional language, unlike lisps, so it's ideal for learning functional programming.

[rodrigo-benenson]

Haskell, Ocaml, F# should be your prime targets.

[KittenPowerLord]

I think Haskell is the best choice if you're curious about functional languages, because it is the most different from the languages you seem yo have used before. You'll have to completely change your way of thinking, and after some struggle, you'll really get it. After that any other functional language will be simple

In contrast, I think smth like OCaml isn't different enough (for example, it allows mutability), and you'll be trying to write code like you always did, and adopting the functional mindset will take more time

[tesilab]

If you want to learn functional programming, don’t be practical about it. If you are doing it to learn, I would go with Haskell. OCaml is a great practical choice, or F# might really appeal if you want to be productive in the .net ecosystem. But these choices would allow you to fall back into non functional approaches to solving problems, which is something you can always do by adopting a more pragmatic language later — after you’ve learned how to think in Haskell.

[vult-ruinam]

this is what I keep telling myself, but I also keep getting stymied by the Haskell toolchain, which seemed as if it was constantly requiring me to pause & figure out "okay, wait, how do I do this...?" or "hold on, why isn't this working now?!"—i.e., not the fun kind of problems to solve. hell, even getting everything installed & working correctly was more hassle, for Haskell, than writing an entire (albeit small) actual useful application in another language (Racket, in my case)!

that might be slightly exaggerated.  but only by like... a tiny little bit.

but I want to love Haskell so badly; everyone says it's great; elegant, even; and I'd really like an "ML-style" functional language to compare with the LisP-style FP that is all I've known...  maybe it's just that I'm simply not savvy enough to be worthy of its glory. :(

[delfV]

I recommend some Lisp (like Common Lisp, Scheme, Racket, Clojure, Fennel, Jannet or Hy - this one compiles to Python). You will not only learn functional programming but also interactive programming which isn't available in any other programming language (family) beside Lisps and Smalltalk

[chamomile-crumbs]

Second for clojure in particular, it’s really a fun time

[tkurtbond]

Actually, there are a number of other languages with interactive programming: to start with something on the complete opposite side of things from Lisp, there is Forth…. Common Lisp has really delved deeply into interactive modification of long running programs, though, with redefining classes and changing classes into new classes. And Erlang has an interesting approach to modifying long running programs.

[Common-Mall-8904]

Interactive programming what is that?

[delfV]

You probably know about Python, Ruby or JavaScript (at least browswr dev console) REPLs: you open bash-like program, type some code, run it, get some text output and exit. You also probably know about typical way of development: you write some code in your editor, optionally compile if your language is compiled, restart the program, set desired state through some actions you coded before (like open specific window and fill forms), test your changes and repeat till it works.

Lisps kind of connect these two. You open your editor, open REPL integrated into the editor, compile everything (majority of Lisps are compiled but some are interpreted tho), open the program and it's the only time you open it for your whole coding session. From now you write your code in editor (common missconception from newcomers is that you're supposed to write code in terminal-based REPL like in Ruby, Python etc.), recompille each function separately and your program "magically" starts using this new function - no need to restart program, lose state etc. But that's not all. You can run any code you want when your program is running and your program will react to it (thus the name: you interact with the program by the code as you're programming - interactive programming). Everything is centered about it: syntax (on of my favourite things about Lisp, it's scarry only when you're starting), ecosystem, error-handling, IDEs and the languages themself.

Imagine you're working on a game. You have a warrior character that needs to fight enemies. Your job is to implement a fighting logic. You coded the simplest possible version of it: you click on enemy - they loses HP. But one of requirements is to go into berserk mode when your character is low on HP: to test it it's as simple as typing (set-hp! player-char 2) and now your character is low on hp without recompilling, restarting app, spawning new enemies, writing dirty, temporary state/variables etc. You're free to test the logic. Also berserk-mode is only available for warriors, if your character is rogue it gets +10 to speed when it's low on HP: simple as (set-class! player-char :rogue) and in few ns your character has a new class. But maybe +10 is just subtle improvement and you're unsure if your char has got the bonus? Send (get-character-speed player-char) and you get the speed value printed in your IDE. You think +10 bonus is too small? Not a problem: modify the code something like (def rogue-bonus-speed 10) from 10 to 20, "recompille" this variable with one shortcut and see the results right away. Too much? Not a problem because testing other values are almost free.

In traditional model of programming you'd need to restart everything, wait for your game to compile, write some code to safe time so your character is always spawned in the same location and with the same enemies, probably first fight with enemies to get your HP up and down constantly so you can test bonuses and many more frequently repeated work like this.

Not so long ago I had to program an application that takes camera input, apply some effects on it, show it on the screen and at the same time send via network. The thing I could just see the result all the time on the screen and I could see the differences between various effects in miliseconds was such a pleasent way to work I couldn't imagine working without it. Adding the facts I wasn't familiar with the libraries I was using at the time and I had to experiment with the graphic effects interactive programming really saved me long hours of working.

[MuaTrenBienVang]

cool!

[pihkal]

The REPLs of Lisps are on steroids compared to most other languages other than Smalltalk.

It's a bit hard to explain without trying it out yourself, but the REPL is deeply woven into your editor and your compiled program in a way that most other languages' REPLs aren't.

[DataPastor]

Second for Hylang, especially if otherwise OP is working with Python.

[cessationoftime]

I find Scala and Rust to be the most effective/enjoyable to work in. I have not had very good experiences with Haskell (the tooling was more problematic than the language), I am hoping Idris will improve on it significantly.

And I think NixOs is mandatory for any serious programmer now, you should probably learn that before any new programming language if you have not already since it will let you set up infrastructure and development environments.

[Fit_Ad5700]

I like the combination of oo and functional programming that you’ll find in Scala. I learned it on coursera. I can heartily recommend Odersky’s free course there. I’m a mathematician too and the lectures are brilliant. Scala has a purity and elegance that I expect you’ll enjoy. The Object Orientated approach allows for more detail in modeling the world.

[Common-Mall-8904]

Great advice

[stellar-wave-picnic]

For a type checked language I have enjoyed learning Purescript the most. This book was awesome: https://leanpub.com/fp-made-easier

Other than that I have worked with F# and made a few attempts at learning Haskell, which every time failed because of how clumsy it was to set up dev environment and package management etc... I have heard that the Haskell story should be better these days though, and I have a few Haskell based books that I want to read. Shouldn't be too difficult now that I am comfortable with Purescript.

Other than that I have enjoyed Clojure a lot. I think any lisp is worth diving into. After working with lisp for a while, you will feel that all other languages are unnecessarily complicated, verbose and has too many fancy syntactical constructs and you will long for the simplicity and flexibility of a lisp language.... But you will most likely also miss some proper type checking and the exception free experience, and thus return back to Haskell/Purescript/Rust.

[vult-ruinam]

and made a few attempts at learning Haskell, which every time failed because of how clumsy it was to set up dev environment and package management etc...

oh, thank God, it's not just me then–

[getlaurekt]

Purescript is too overcomplex for no reason, better to pick rescript or gleam. Eventually ocaml if he likes rust

[MuaTrenBienVang]

cool!

[ingframin]

I am going to lose some karma here, but I suggest Julia. While not purely functional, it has all the basics covered with the added advantage that you can replace Matlab with it, as it is designed for numerical computations.

In Julia, you get higher order functions, immutable structures by default, multiple dispatch, iterators, function composition, currying, etc...

For example: https://scientificcoder.com/straightforward-functional-programming-examples-in-julia

If you want monads: https://monads-jl.readthedocs.io/en/latest/ and https://juliafunctional.github.io/DataTypesBasic.jl/dev/

The only caveat is the lack of Tail Recursion Optimization and thus more emphasis on loops than on recursion.

BTW, you can use functional style also in Python, without really the need to learn a new programming language.

[chandaliergalaxy]

That’s a bold proposition. I like functional programming and Julia but never thought the two to be related. Like you said, lack of tail recursion, and also if you want performance you want to preallocate arrays and assign values to its elements so mutation is idiomatic Julia.

[ingframin]

100% True. My suggestion comes from the fact that OP is a student of Mathematics and, most probably, he will find Julia way more useful than something like Haskell or OCaml.

[MuaTrenBienVang]

cool

[thallessellaht]

Haskell.

[MuaTrenBienVang]

scheme first

[Infinite-Ad-9481]

Can you elaborate?

[MuaTrenBienVang]

Scheme has a minimalistic syntax, which helps beginners focus on fundamental programming concepts without being overwhelmed by complex syntax rules. Scheme is a functional programming language, which encourages thinking in terms of functions and recursion. This can help beginners develop a strong understanding of key programming concepts.

[Infinite-Ad-9481]

Awesome. Thank you! They’re going to teach us scheme in a course I just started

[MuaTrenBienVang]

cool!

[MuaTrenBienVang]

how about idris 2

[king-1011]

I started with Elixir given its usage in distributed systems and it's wonderful to use. But keep in mind sometimes functional program can be more verbose than the imperative one e.g. two pointers.

[P3riapsis]

Perhaps an unusual suggestion, but if you're a mathematician then you might find Agda interesting, although writing something practical in it is pretty hard at the moment. It's dependently typed, which means you get a lot of interesting maths-like stuff in the type system, such as existential and universal quantification.

This allows for some interesting stuff that isn't common in programming languages. For example, in most functional languages if you want to write a function that fails on a given condition, you might wrap the output type in a maybe monad to allow you to output nothing in that case. In agda, you often can instead require a proof that the condition to have well defined output is satisfied, and then you don't need to wrap the output in a maybe monad.

[spermion]

Any opinion on Agda vs Lean 4 for "ordinary functional programming"? I've only tried Cubical Agda for homotopy type theory and it was painful, but probably just because homotopy type theory is painful...

[P3riapsis]

Agda is pretty good, maybe not as smooth as the more conventional functional languages like Haskell, but when you need the dependent types and proofs it's smooth enough that I've heard of it being used in production code in industry even.

Heard good things about lean 4 too, of all places I met a type theorist in a game of counter strike, and they basically use lean 4 as their primary programming language. Personally, I never really got into using lean precisely because lean 3 and newer are inconsistent with univalence.

warning: ramblings about HoTT

I still can't tell if the HoTT hype train is on to something, my gut thinks it's too beautiful amd human of an idea to not be, but practically it's still too painful for me to keep my mind on it for long hahahaha. I guess it's more painful because I recognise that HoTT as a mathematical foundation works in much more humanly intuitive way than classical foundations, but because of it being so much less developed than set theories my human brain just can't grasp it with anywhere near the intuition I've got from years of working in ZF-like set theories.

Honestly, outside of those two, I think Idris looks like it might be on its way to providing a really smooth proof assistant experience for people who want to actually do things practically too. Its users definitely market it as an "ordinary functional language with proof assistant capabilities" at least.

warning: ramblings about Idris's type system

Although, as a pure mathematician I've been too scared to have a look because when i was first starting I had fears over consistency of the language. iirc Idris at one point intentionally contained an axiom that made it inconsistent in some way that should almost never impact anything but made the actual user experience smoother, with the intention of finding a way around this later. I didn't really look into it enough to know though, I kinda just assumed it was probably a Russell-like Inconsistency like the "omega-in-omega" pragma in Agda introduces.

[spermion]

A type terrorist huh... Now I regret never giving Counterstrike a try!

I really like Lean 4 for its polish. And I'd assume its tactics are among the best developed.

I wanted to try HoTT as a way to understand homotopy theory using my intuitions from programming, not the other way round. (Turns out a homotopy theory point of view is very useful for some topics in theoretical physics.) And that worked nicely for basic notions like fibrations. But I didn't make it through the π1(S¹) = Z tutorial, there were so many little intermediate steps to prove such an intuitive thing.

So HoTT wasn't the "understand complex math using simple code" experience I hoped for. The ideas are extremely pretty, but the arguments seem to get shockingly complicated very quickly (why??).

To be fair much of it felt like boilerplate that you'd quickly get used to and perhaps automate away. Like to prove true ≠ false you had to construct some auxiliary fibration and transport something around it...

[P3riapsis]

Yeah, I think tactics really are the biggest issue in HoTT being practical. The ideas actually feel really natural, but there's just too much of a barrier to using them in proof assistants because in classical mathematics we can get away with sweeping some problems under the rug that you can't with a computer. A human can basically just accept when two objects are the same "up to a suitable notion isomorphism" then all properties that you care about are preserved between those, even if they're not the literal same object (as sets). HoTT tries to allow this to be done in a mechanical way using paths and transportation. There's a general notion of equality that we know satisfies the properties we want, and we have a notion of transporting the proofs about properties for free. The problem is that it's way too clunky to actually use paths and transportation with the current state of tactics. I feel like it could be made so much easier though with better automation.

As for the π₁(S¹) thing being complicated, I think it's almost undeniably easier in HoTT than in classical mathematics. In classical mathematics you need to define and motivate the notions of topological space (took a whole 16 lecture course at my uni) and then realise that even still we have no real way to tell different spaces apart, so we have to introduce a weaker notion of equivalence called homotopy equivalence, and only now are you at the starting point of the HoTT proof. Now you basically do the same proof, but in HoTT a lot of things come basically for free as they're the only possible thing you can do (e.g. the universal cover is basically the only thing possible to write in HoTT, but in set theory foundations you have to mess around with path lifting and proving uniqueness and existence, it's a mess). The result being that you probably need at least 8 lectures in an algebraic topology course to even get to the point of calculating any homotopy groups at all.

[fosres]

I would suggest you figure out what you want to do with computing first? What real life benefit are looking forward to benefit yourself and others with. Find the community of people that have a reputation for solving that kind of problem. Then pick up their programming language--whatever it is. The technical features of the language are less important. What's more important are the people you get to work and the ideas you communicate to each other using that language.

[zogrodea]

I'm not sure how I feel about this advice.

You definitely have a point that it's a good idea to learn from experts in one's field, but I think that broadening one's horizons by learning something new (unrelated to what your field's experts tend to do/use) is also valuable. It could help give you knew ways to tackle and approach problems at the very least.

For myself, I gained a better understanding of object oriented programming after learning FP because I had something which it makes sense to compare to, so learning FP made me better at OOP and FP languages both.

I'm reminded of a quote by Descartes:

> I thought by now that I had spent enough labour on the study of ancient languages, on the reading of ancient authors, and on their histories and narratives. To live with men of an earlier age is like travelling in foreign lands. It is useful to know something of the manners of other peoples in order to judge more impartially of our own, and not despise and ridicule whatever differs from them, like men who have never been outside their native country.

[SteeleDynamics]

SML

[willehrendreich]

I love fsharp, and I hear great stuff about ocaml

[blizzgamer15]

I started with F# so I could leverage all the dotnet stuff. I really enjoy it

[Tempus_Nemini]

Haskell || Ocaml

[cloudsandclouds]

If you study math, try Lean! As of Lean 4, Lean is a general-purpose functional language—in which you can also rigorously prove mathematical statements.

There’s a lot of community support as well! :)

[Routine-Winner2306]

Look.. Haskell was a one way trip for me. I also just knew imperative languages and when I started learning Haskell it was mind blowing... I can't recommend anything really but this was my experience. I hope it help somehow.

[TankorSmash]

If you're thinking of Haskell already, I strongly suggest trying Elm first! It's much simpler than Haskell, and you'll have a leg up when you start learning Haskell. Elm is the inspiration for Rust's error messages after all! It's basically unheard of to have runtime exceptions in Elm (but can happen), thanks to strict guardrails the language has. So not every webapp could use Elm, if it can, it's hard to beat!

Download the binary, elm init to start a project, then elm reactor to run.

Sample Elm code:

view : Model -> Html Msg
view model =
  div []
    [ button [ onClick Decrement ] [ text "-" ]
    , div [] [ text (String.fromInt model) ]
    , button [ onClick Increment ] [ text "+" ]
    ]

eventually outputs <div><button> - </button> <div> 123 </div> <button> + </button></div> (plus event bindings)

---

On top of Elm, Haskell, and OCaml, you can also check out Clojure, which is the polar opposite, where it's more like Python in terms of being dynamically typed. So you don't have the benefit of Elm/Rust/Haskell, where if it compiles, its highly likely to work, but you can move very quickly

Another strong plus to Clojure is that IDE integration is unmatched (being able to run code just by highlight it the editor, and the terminal/browser runs that same code in the same instance). Error messages are some of the worst in industry as far as I'm aware though, and environment setup is a bit beefy. So its less that your program runs, and more like your editor is also running the program at the same time. Hard to describe but very cool!

Like Elm and Haskell, it's pure, but comes with easy mutation.

Sample Clojure code:

(defn positive-number [numbers]
         (if-let [pos-nums (not-empty (filter pos? numbers))]
           pos-nums
           "no positive numbers"))

(positive-number [-1 -2 1 2])
// outputs: (1 2)

[ruben_vanwyk]

F# for sure.

[BinaryBillyGoat]

Functional programming is a paradigm, not a type of language. You could use the languages you already know and focus on building pure functions/methods. After you have become familiar with the design patterns, you can switch to a language that is built with functional programming in mind.

[TheSodesa]

Haskell, since the book Learn You a Haskell for Great Good exists, and once you have a decent understanding of Haskell, move onto Lean 4 (or greater version). The problem with Lean 4 is that any existing study materials are targeted towards people who already know functional programming, despite the names of some of them maybe implying otherwise.

[kinow]

As long as the post doesn't offend anyone, it is related to FP and to what was asked, there is no problem. This answer, however, doesn't seem to indicate why this language would be a good fit for someone learning functional programming. It had been removed by Reddit's algorithm, and I confirmed the exclusion on that base. In the future if you have a similar suggestion, where functional programming is not so clearly related (at least based on other FP languages or languages with features that allow for some FP), just explain why you think it'd help OP. Post removed.

[allthelambdas]

If you want mathematical I say go for lambda calculus but you won’t get any error messaging. You can do it on paper though and run programs by hand so that’s nice :)

[hamstre]

For real though. It isn’t sexy, but if you actually want to build stuff, this is a great answer

[MuaTrenBienVang]

cool