The example here is basically an 8-fold memory saving going from `long[]` from `byte[]` - while still retaining polymorphism (whereas in Java the two are unrelated types).

Hard to say exactly how much performance one would get, as that depends on access patterns.

I often find them handy for locking down admissible states at compile time. Maybe ~10 years ago in a processor design class, I wrote some CPUs in Haskell/Clash for FPGA usage. A nice thing I could do was write a single top-level instruction set, but then lock down the instructions based on what stages of the processor they could exist at.

For example, something like (not an actual example from my code, just conceptually - may be misremembering details):

  data Instruction stages where
   MovLit :: Word64 -> Register -> Instruction '[Fetch, Decode, Execute, Writeback]
   -- MovReg instruction gets rewritten to MovLit in Execute stage
   MovReg :: Register -> Register -> Instruction '[Fetch, Decode, Execute]
   ...

And then my CPU's writeback handler block could be something like:

  writeback :: (Writeback `member` stages) => Instruction stages -> WritebackState -> WritebackState
  writeback (MovLit v reg) = ...
  -- Compiler knows (MovReg _ _) is not required here

So you can use the type parameters to impose constraints on the allowed values, and the compiler is smart enough to use this data during exhaustiveness checks (cf "GADTs Meet Their Match")

It is thanks to the companies like Jane Street that believe there is something else beyond C, that we can have nice toys.

Remember if OCaml wasn't a mature programming language, maybe Rust would not have happened in first place.

Why do you assume it's a drag for them and not a competitive advantage? I don't know if it's such a terrible thing to use a slightly out of mainstream language, when the standard in the business is to accumulate tens of millions of lines of C++.

Concretely how do you think it’s holding them back? Just by being niche?

There are many things to say about this, but one of those things is that I think you are making the assumption that an (e.g.) C programmer who does not want (or even cannot) get into OCaml would somehow be better for this highly specialized, high-performance, and high-correctness-affine use case, than someone who does. And I'd question that assumption.

It's easier to reason in FP plus the python paradox [1] [2].

[1]: https://www.paulgraham.com/pypar.html

[2]: https://blog.janestreet.com/why-ocaml/