Fellow cat girls of the functional persuasion, I have had it up to here with the Haskell propaganda machine. It is time for a civilized, measured, and completely unbiased discussion. I will go first.

OCaml is simply better. I will now enumerate the reasons with the rigor befitting this esteemed community.

1. PRAGMATISM vs IVORY TOWER NONSENSE

OCaml is impure and strict. You can do effects anywhere you want. You do not need to wrap your entire life in an IO monad just to print "nya~" to stdout. Real programs have side effects and OCaml respects that.

2. THE MODULE SYSTEM

OCaml's module system — with first-class modules, functors, and module signatures — is a tour de force of language design. It gives you parameterized abstractions without needing the entire MTL stack and 47 language pragmas. You get explicit, readable, traceable code structure.

3. OCaml 5 ALGEBRAIC EFFECTS

We don't need monads anymore. OCaml 5's algebraic effects let you write direct-style async code without the let*-hell that even we OCaml people admit is a little cumbersome. Eio is beautiful. The future is now.

4. PERFORMANCE

Strict evaluation = predictable performance. No thunks leaking memory at 3am. No needing to annotate ! everywhere because GHC decided your integer is now a lazy box of sadness. See benchmarks thread.

Haskell people, your rebuttal please. Keep it civilized. (=^.^=)

Ah yes, the classic "I don't want to think about effects" argument. Let me introduce you to the concept of correctness, darling. nyaa~

Haskell's purity is not ivory tower nonsense — it is a guarantee. When a function has type Int -> Int, it actually just takes an Int and returns an Int. No hidden HTTP calls. No secretly writing to a file. No mutating global state while you're not looking. The type IS the spec.

Also, do-notation is beautiful. It reads like imperative code but with the full power of monadic sequencing. Your let* in OCaml is literally just a sadder version of this. You are doing monads poorly without calling them monads.

As for type classes vs module system: I wrote 4000 words on this but the short version is — type classes give you ad-hoc polymorphism with implicit dispatch. OCaml modules force you to carry dictionaries manually like some kind of 1995 programmer. The ergonomics are simply not comparable.

Lazy evaluation is also a feature, not a bug. Infinite lists are purring elegance. [1..] just works. When did you last produce a lazy infinite stream in OCaml without a library? Exactly.

I love how Haskell people brag about do-notation making things "read like imperative code" as if that's a selling point for a pure functional language. You invented a complicated system specifically to escape it... only to make it look like what you escaped. (=^◡^=)

OCaml has let* (binding operators since 4.08) and it works perfectly well, thank you:

Also re: performance — I ran the n-body simulation benchmark last week. OCaml native: 1.4s. GHC with -O2: 4.1s (space leak, had to add BangPatterns everywhere like a caveman). The OCaml result was predictable. The Haskell result required archaeology to fix.

The OCaml compiler is "way simpler and produces code with more predictable performance" — this is just factual. Meanwhile Haskell programs require you to understand the entire GHC optimization pipeline just to get reasonable runtime behavior. That is not a feature. That is a tax.

Okay you know what let's talk about the module system vs type classes properly because I actually have opinions.

Type classes give you ad-hoc polymorphism with global coherence. This is not a small thing! Functor, Monad, Foldable, Traversable — these are a shared vocabulary across the entire Haskell ecosystem. When I see traverse, I know exactly what it does regardless of what container I'm working with. The types enforce the laws. This is civilization.

OCaml functors are powerful but you have to manually instantiate everything. You can't write show x — you have to write FooModule.show x or whatever name that specific library decided to use this week. Every library reinvents its own wheel. The lack of a common vocabulary is genuinely OCaml's biggest structural weakness.

Also: BangPatterns for a benchmark is totally normal and you know it. You're being dramatic. nyaa~

i feel like you're both ignoring the elephant in the room

OCaml 5 has algebraic effects. Like. That's genuinely a big deal. Effects let you implement monads, green threads, async I/O, etc. as a library. You get direct-style code without monadic noise AND the ability to abstract over effects. The Haskell runtime does similar things but it's all hardcoded C. OCaml's primitives are generic and composable.

isn't that just... better? nya~

(=^.^=) haskell won, cope

MeownadTransformer please I am trying to have a civilized discussion

(=^.^=) haskell won, cope

It's genuinely interesting! But let's be clear: OCaml effects are still untyped in the current release. You can perform any effect anywhere and the type system doesn't track this. Haskell tracks effects in the type — that's the whole point.

OCaml effects are like... if you took the good idea behind monads (structured effects) and removed the static guarantees. The typed effects RFC is apparently coming eventually but "eventually" is doing a lot of heavy lifting there.

Also lazy evaluation means I can write:

Try doing that in OCaml without a Seq library. nyaa~ ✨

Have you two considered that you're both wrong and the correct answer is Idris 2?

Dependent types. Quantitative type theory. Linear types. Your little "is this function pure" debate is cute but in Idris the compiler can verify that your sort function actually sorts. Not just type-checks — proves it correct. Go on then. Both of you. Explain why you don't want your programs to be provably correct.

I'll wait. (=ↀωↀ=)

TabbyTypeTheory, we are not doing this right now. Idris is a research language. We are talking about production code. Things that ship. Things that Jane Street uses to make money.

... that said the Vec type is pretty cool. I'll give you that.

But no. Sit down. Idris is not the answer to this question. nya~

(=^.^=) haskell won, cope

Wait, we're mentioning Idris? Then I'm legally required to mention Agda.

Agda has universe polymorphism, cubical type theory, and the most beautiful unicode syntax you've ever seen in your life. Your OCaml modules and your Haskell type classes are, with all due respect, adorable little toys compared to a system where you can write proofs and programs in the same language.

The head function above cannot be called on an empty list — the type literally forbids it. Not at runtime. At compile time. Forever. By mathematical proof.

Discuss. (=^-ω-^=)

AgdaKitten I am TRYING to defend Haskell here. Can you please not make this a full dependent types derail. I have limited patience for this thread and MeownadTransformer is already wasting it.

Yes Agda is cool. Yes proofs-as-programs is beautiful. No it is not "practical" in the sense that I have a job and a deadline. There is literally an entire thread for this.

Also Haskell has DataKinds and TypeFamilies and you can get surprisingly close to dependent types with enough LANGUAGE EXTENSIONS. Don't test me on this.

nyaa~ 😤

(=^.^=) haskell won, cope
(=^.^=) haskell won, cope
(=^.^=) haskell won, cope

GaloisCat thank you for the intervention. I accept Proposition 1 and 2 as reasonable framings. I contest that "neither is strictly superior" because pragmatically, OCaml's approach has demonstrably better outcomes in large-scale codebases — see the entire Jane Street codebase. Their Core library is a masterclass in functor-based design.

But fine. Fine. "Neither is strictly superior" nya~. I'll allow it. For now.

I am still correct about effects though.

(=^.^=) haskell won, cope

(this is not going to stop)

Ok. With the chaos contained (temporarily), let me try to actually summarize this thread fairly since page 1 is about to fill up:

The real answer:

Both languages are excellent and the choice depends on your use case. There, I said it. nya~

• Haskell: purity, laziness, type class ecosystem, do-notation, GHC optimizations
• OCaml: strictness, pragmatism, module system, effects (OCaml 5), predictable perf
• Agda/Idris: when you want to prove things (see those threads)
• MeownadTransformer: suspended

I'll see you all in page 2 where CamelCat will inevitably bring up Jane Street again. (=^ω^=) ✨