Should I Haskell or OCaml?

For a job - neither.

For personal interest - try both and see which one you like more.

I was about to suggest either, but then I read:

> Primary downside is that it’s purely functional, which means it can be less flexible and makes it less likely it can replace Python as my go-to language.

Learn Haskell so that you can dispel this notion.

You are going to do the same things in a new language whatever you were doing in Python. I understand you are working on web and data science domains.

So I would recommend you check out F# which is like OCaml but runs on the Common Language Runtime. While it is really good on web platform, you might want to investigate the state of data science domain in F#. There are some guides here[1] and here[2].

1. https://fsharp.org/guides/data-science/

2. https://github.com/fsprojects/awesome-fsharp#data-science

I think OCaml is more practical and actually has some parallels to Python. You may find these resources interesting:

- Library to manipulate PDF documents: https://github.com/johnwhitington/camlpdf

- Web framework: https://aantron.github.io/dream/

- Scientific computing library: https://ocaml.xyz/

Last, I wrote a couple of practical-focused OCaml guides:

- https://dev.to/yawaramin/practical-ocaml-314j

- https://dev.to/yawaramin/practical-ocaml-multicore-edition-3...

Haskell. It has a bigger ecosystem, although nowhere close to python’s

I'm learning PROLOG for the funsies. It's really easy for making things like expert systems, and it's reasonably performant, has lots of libraries, including native ones, good FFI binding.

Care to join?

Haskell is purely functional, but if you make ample use of do-notation it's very easy to write in a familiar imperative(ish) style for day-to-day tasks. Most learning materials won't emphasize this but large production Haskell codebases that do a lot of IO usually end up looking a lot more familiar than you might expect.

If you have interest in both OCaml and Haskell, you might also consider just learning Rust which borrows aspects from both of them. Rust traits aren't quite as powerful as Haskell typeclasses and its module system is definitely more limited than OCaml's, but if you write it in a more functional style you'll get exposed to a lot of similar patterns.

A lot of things in Haskell never really clicked for me until I spent some time getting comfortable with Rust.

I loved learning Haskell and wish Haskell and its ecosystem long life and prosperity.

But I find it hard to choose Haskell for practical projects because there are so many options so many cool ways of doing things and there is always that latest better approach and I find myself into a permanent research mode where I learn a lot and get not much done.

Ymmv

How did you select those two as your options?

I'm just a hobbyist that enjoys programming, and I eventually wanted to expand beyond python. I looked at Haskell and read Learn You a Haskell and did some Exercism exercises but never got anywhere close to being able to use it for real projects. Have been trying to learn about Lisp lately and feel like I've come to a similar dead end.

On the other hand, both Go and Rust have felt fulfilling and practical, with static typing and solid tooling, cross compilations, static binaries, and dependency management that is just a huge breath of fresh air coming from python.

The ML / data science scene is nowhere near as developed as in Python, and I still lean on jupyter/polars/PyTorch here, but I think the candle project[0] seems very interesting. Compiling whisper down to a single CUDA-leveraging binary for fast local transcription is pretty cool!

[0]: https://github.com/huggingface/candle

I would suggest neither in your position. I suggest trying a language like F#. F# started as with the idea of developing a language with OCaml like syntax and semantics for the .NET platform. Since then its evolved to being a mature, elegant and robust language. It can run on Windows and Linux.

Advantages over OCaml is I suspect a much larger footprint and the ability to tap into all of .NET (huge ecosystem). Plus your skills will be more portable than Haskell or OCaml.

Both Haskell and OCaml are exceptional languages but the ecosystem and market footprint is not great for either. Jane Street has done a lot to evangelize OCaml but it hasn't really moved the needle. Haskell is probably the most different being a lazy functional language. Definitely learn it but using it in real life will be harder.

I know you said you want something with real static typing, but I think it would still be worth it too check/try out Elixir.

IMO, Elixir is the functional Python. The lack of types in Elixir feels very similar to current Python. Pattern matching and guards instead of type annotations. No compile time checking. Dialyzer instead of MyPy. But unlike Python, Elixir is actively working on adding static typing that will be checked at compile time.

The language tooling, documentation, and testing is miles ahead of Python.

The language is enjoyable, easy to understand and read. It's very simple syntax. (only 15 reserved words)

You can find a lot of similar libraries in Elixir.

Django -> Phoenix

SQLAlchemy -> Ecto

Jupyter -> Livebook

Polars/Pandas -> Explorer

Numpy -> Nx

PyTorch -> Axon

SKLearn -> Scholar

XGBoost -> EXGBoost

Transformers -> Bumblebee

Prefect/ETL -> Broadway and Flow

PyO3 -> Rustler

All of this and you also get the benefits of BEAM VM. Which makes Elixir faster and more scalable than Python in majority of cases.

F# might give you an experience closer to Python but that is still functional programming. This is not just the syntax, but also the community has a pragmatic bent. It also has the biggest ecosystem, since it can easily use any .NET library.

For ML, none of these are popular options. However, F# has bindings for Torch that are maintained by Microsoft.

All 3 are great choices though.

A lot of commenters have already suggested F#, I'll just add this resource as a good way to dive in: https://fsharpforfunandprofit.com/

Up until a few days ago, I was also vacillating between learning OCaml or Haskell, before deciding on Haskell for reasons.

I surveyed many free and paid-for references to build my foundation, before picking John Whitington's "Haskell From the Very Beginning" (https://www.haskellfromtheverybeginning.com), because it "takes a no-prerequisites approach to teaching the basics of a modern general-purpose programming language".

I am also using Replit's "free-tier" as my Haskell learning environment. Replit let me jump right into the fun of Haskell, while postponing dealing with installation/configuration nuances until absolutely necessary. This is also letting me do learning any time I have a free moment from wherever I last left off on any computing device I have handy, including my tablets or smartphone.

So far, my learning experience has been a joy.

If you decide on OCaml, Whitington also wrote "OCaml From the Very Beginning" (http://ocaml-book.com), which available via free pdf or HTML thanks to the OCaml Software Foundation, and looks to be structured similar to his Haskell book.

Hope this helps.

I went from Python to F# but now I think I should have gone to Rust instead. My reasoning has to do with making standalone executables and being able to call C libraries. That can be done in F# but is easier in other languages.

Perhaps at this point you have made up your mind, I haven't tried OCaml, but I can recommend you Haskell. I am not sure what approach you'd like to take by learning it, but typing code isn't enough, I mean, what's the point of knowing too much syntax? In the era of Massive Information Availability. I also don't know at what stage of your journey you are related to the functional programming paradigm but still I do have two related recommendations about it: FP101x (Provided by DelftX through edX [Now archived but still doable])[1] and the book Programming in Haskell by Graham Hutton.[2] Remember what Mr. Leslie Lamport says: "If people is trying to learn programming by being taught to code, well they are being taught writing by being taught how to type. And that doesn't make much sense." [3]

Python? You may be surprised to know one or two pending tricks about that programming language, take a look at Design of Computer Programs by Peter Norvig at Udacity [4]

Scala is a good option too, since you mentioned getting tired from lack of real statically typing. EPFL Extension School has a good one: Effective Programming in Scala (Also available for free at Coursera).

Hope that helps, and happy learning!

[1] https://www.edx.org/learn/computer-programming/delft-univers...

[2] http://www.cs.nott.ac.uk/~pszgmh/pih.html

[3] https://www.youtube.com/watch?v=rkZzg7Vowao

[4] https://www.udacity.com/course/design-of-computer-programs--...

Why aren't you using Pyre? Don't blame the tools when you're not utilizing them. I hate to state the obvious, but discontent is unlikely to be solved by either novelty or becoming a student novice again.

OCaml is not more flexible than Haskell. The primary differences are greedy vs. lazy evaluation.

Haskell is used in production in finance and military applications. It was previously used at Twitter and Facebook. Haskell lets you create heavily-abstracted, curried monads and define custom operators. Basically, every mathematician's dream-kitchen sink-swiss army knife-footgun. Code so readily esoteric than 5 people on the planet will be able to maintain it. ;)

OCaml is used in a smattering of niche MAANG backend services and in XenAPI and Coq.

Rust or Elixir+Erlang are more useful alternatives because they translate to job skills. If you want speed, resource efficiency, correctness, concurrency, and maintainability then Rust. If you don't care about correctness or speed, but want apparent simplicity and rapid development then use Go. ;)

I was in a similar position using Python at work. At first I learnt Ocaml on the side, which was really fun, and taught me to work with types instead of avoiding thinking about them as I did with C++. Then I got a job where I got to write "simple" Haskell – picking up Haskell after Ocaml was no problem, mostly just felt like a change of syntax. It's been fun, and for the domains I've used it for (mainly combining data from various sources, analysing, predicting), a very good fit. Also used it for web stuff with IHP lately, which has also been a success.

The Haskell ecosystem is somewhat larger than Ocaml's (more support, users, learning materials, libraries). The difficulty with Haskell is mostly that it makes abstraction so easy that you can be tempted to make your code too abstract. But if you can manage to KISS, it can feel like a safer, cleaner, faster Python. Haskell doesn't require you to code in pure functions, but it will let you know through the types that a function is not pure / is "in IO", and it has lots of features to let you easily do things purely that you would otherwise do in IO. That may lead to more of your code being pure in the end. F#'s main advantage is access to the C# ecosystem, though at the cost of possibilities for null pointers when calling C# libraries / .NET API's.