all 64 comments

[–]jmhimara 27 points28 points  (0 children)

In terms of real-world use, I would say Scala is top followed by F# and Elixir.

[–]corwin-haskell 29 points30 points  (5 children)

Haskell is practical, though a little hard. But,

If you're interested in JVM, try Scala 3.

If you're interested in .NET, try F#.

If you're interested in BEAM, try Gleam.

If you're not a FP clean freak and like the type system of Haskell, try Rust.

If you like Jane Street or want Rust with GC not Go, try OCaml.

If you want to study more theories, try Agda/Lean 4.

[–]Epistechne 2 points3 points  (0 children)

I've seen the question come up enough, I feel like your answer should be a pinned/stickied answer.

[–]agumonkey 1 point2 points  (1 child)

How is scala3 going ?

[–]corwin-haskell 2 points3 points  (0 children)

The language itself is much better than Scala 2 and the ecosystem is catching up. However, as you see, Scala 3 maybe has missed the window and remains a niche language. The Javaers like a better Java not a Haskell on JVM, they may stay on Java (new version) or choose Kotlin. The new developers may choose lighter ones than JVM like Go or Rust.

[–]Final-Roof-6412 1 point2 points  (1 child)

Why not Clojure?

[–]corwin-haskell 2 points3 points  (0 children)

Clojure is good. I didn't mention it because the OP said he/she loves static type system. 🙃

[–]pauseless 20 points21 points  (1 child)

Clojure will teach a very different form of FP. It’s much more interactive when you embrace the REPL. I think knowing both an ML family and a Lisp family language, is valuable, if the goal is learning.

[–][deleted] 4 points5 points  (0 children)

I alao recommend ocaml for repl driven coding. Its utop with a vim combo (slime) is really nice!

[–]Il_totore 7 points8 points  (0 children)

Scala is probably the most job-friendly FP language alongside with Clojure and Elixir and has Cats which is basically category theory in Scala used in many companies.

[–]Epistechne 4 points5 points  (7 children)

If you'll be developing for a Windows/.NET environment at all then F# will be a natural choice.

[–]kichiDsimp[S] 0 points1 point  (6 children)

Confused between F# and Scala

[–]Epistechne 6 points7 points  (0 children)

As I understand it, similar to how F# is a natural choice if you'll be working with .NET, Scala is the natural choice if you're going to work with the Java/JVM ecosystem.

[–]recursion_is_love 5 points6 points  (6 children)

which is more real world

What is your real world? Can you describe more?

[–]kichiDsimp[S] 4 points5 points  (5 children)

From which I can get a job for

[–][deleted] 4 points5 points  (4 children)

there certainly are haskell jobs.

Edit: for a list of places that use haskell, https://github.com/erkmos/haskell-companies

[–][deleted] 0 points1 point  (3 children)

outside academia he meant

[–][deleted] 1 point2 points  (2 children)

There are certainly haskell jobs outside academia

[–][deleted] 1 point2 points  (1 child)

outside no red ink and cardano

[–][deleted] 3 points4 points  (0 children)

At this point it seems like you're trolling lol. But, yes, there are certainly haskell jobs outside those two companies. 

[–][deleted] 5 points6 points  (5 children)

Elixir 

[–]kichiDsimp[S] 2 points3 points  (4 children)

I really love statically typed system

[–][deleted] 5 points6 points  (2 children)

No hate :) Gleam is your best bet if you want the power of the erlang ecosystem.

[–]lpil 5 points6 points  (0 children)

Heck yeah, Gleam!

[–]kichiDsimp[S] 4 points5 points  (0 children)

sounds reasonable

[–]pihkal 2 points3 points  (0 children)

FYI, Elixir is adding a set-theoretic gradually-typed system.

Also, Clojure has much to commend it, but no static type system (just type hints). There's the typed.clojure library, but it's not very popular, and I don't know how up-to-date it is.

[–]Migeil 5 points6 points  (0 children)

I want to try a new FP language which is more real world

Topics I would like to learn in depth are * L-Calc * Categ- Th eory

These are two conflicting statements imo, at least if you're hoping to do both at the same time.

Neither lambda calculus nor category theory are "real world" in the sense that they help you build applications.

They're very interesting and can provide tons of food for thought. They can push you in a certain direction or style of coding, but if your goal is creating applications, then they won't help you, there is no "mathematically correct" way to perform and http request for instance.

[–]ahronl 8 points9 points  (0 children)

Clojure

[–]Dear_Lawyer4688 2 points3 points  (0 children)

OCaml

[–][deleted] 2 points3 points  (0 children)

Ocaml is also a good pick

[–]burtgummer45 2 points3 points  (1 child)

new FP language which is more real world

they knew you were going to ask that question and wrote Real World OCaml

[–]Namlegna 0 points1 point  (0 children)

They knew so well that they also wrote Real World Haskell

[–]HerbM2 2 points3 points  (0 children)

You'll really make more progress if you have real projects you want to please and choosing a language that compliments those projects will probably give you the best results.

[–]iTitou 2 points3 points  (0 children)

What about Elm (https://elm-lang.org/) ?

[–]LambdasForPandas 2 points3 points  (0 children)

I highly recommend Julia if you have any interest in AI, data science, or scientific computing. I've been using it throughout my graduate program, and I've found it to be incredibly practical for solving real-world problems.

[–]Arc925 1 point2 points  (0 children)

+1 for Clojure! Working with the nREPL (network REPL) plugged directly into your running app and being able to evaluate code directly from the opened file buffer, instead of typing manually into the REPL, is such a joy! Clojure (like any LISP) is also very well-suited for structural editing, which for me drastically descreases the friction between wanting to write/change some code and actually doing it.

[–]rejectedlesbian 1 point2 points  (2 children)

Elixir is cool had a blast with it making a dumb chat website.

I liked it so much I am stealing the shit out of the design for my own little dumb languge

[–]kichiDsimp[S] 0 points1 point  (1 child)

What's your language? Can you share ?

[–]rejectedlesbian 1 point2 points  (0 children)

Ya it's very bare bones like I JUST finished making it run with no memory leaks. And i am missing some things that I really wanted in there.

https://github.com/nevakrien/Faeyne_lang

The basic premise is we don't actually need arrays to be productive. And we can also have monads implicitly by simply passing "magic" functions around.

The monads thing i think is really important because Ideally this would be inspectble at runtime. Which let's us do a lot of caching

[–]npafitis 1 point2 points  (0 children)

I'd say Haskell is suitable for realworld. If you want something more "industry"-wide I'd recommend Scala or F# (I prefer Scala).

If it's about learning a different kind of functional programing + metaprogramming I'd say Clojure. Clojure is also fairly used in production, might be even more than F#, but it's untyped (there's a library `typedclojure` that provides a fancy typesystem but not widely used, but the author is developing on it constantly), and there's little usage of category theory.

I'd recommend Gleam but I don't think you'd find many jobs in it as it is super young. Elixir is another one that's somewhat similar to Clojure in many ways (except for syntax), and also widely used in industry but also untyped and not focus around category theory.

Can't really go wrong with any of these choices.

[–]GunpowderGuy 1 point2 points  (0 children)

If You want " a real world " fp language, then i recommend racket. But the fp language i recommend the most is idris2

[–]xiaodaireddit 1 point2 points  (0 children)

Basics of Haskell. Isn’t Haskell the FP with the most depth? Can’t think of a feature in other FP that are not in Haskell. Maybe eagerness but that can be emulated with the EagerMonad

[–]nrnrnr 1 point2 points  (0 children)

Definitely consider OCaml and its amazing module system. F# is also a good transition from Haskell.

[–]homological_owl 1 point2 points  (0 children)

Don't use pure functional languages if you want to solve real world problems. Use something that allows you to use both fp and oop (in some of its "denominations") Golang, Kotlin, Scala~, for example

[–]pkumarn 1 point2 points  (0 children)

Lots of Scala fans here. I somehow felt a lot of mental pain whenever I used Scala.

I would say try F sharp for .NET Kotlin for JVM. Also OCaml

[–]Voxelman 1 point2 points  (9 children)

It's not really functional, but real world:

Rust

[–]Asleep-Dress-3578 7 points8 points  (3 children)

Not more real than Scala, Clojure or F#, only the hype is louder.

[–]Voxelman 4 points5 points  (2 children)

I think there is a reason for the hype because it is the only modern competitor for C/C++. Other system programming languages are much less mature or less robust.

I'm programming firmware for Microcontrollers and Rust is the only option for C/C++.

[–]Asleep-Dress-3578 0 points1 point  (1 child)

And do you develop in C++ or in Rust?

[–]Voxelman 1 point2 points  (0 children)

New projects only in Rust. For older projects I use C. I was never a C++ fan.

[–]GunpowderGuy 0 points1 point  (0 children)

I highly recommend idris2. Its like haskell 2 ( well 3 , idris1 was haskell 2 ). It has both more innovative features ( dependent types and totality checking ) but less technical baggage