I'm not sure your example makes sense. `a b c` means `a(b, c)`. MLs just leaves out the parens. You can't know just form looking at `a b c` what `b` and `c` a

I'm not sure your example makes sense. `a b c` means `a(b, c)`. MLs just leaves out the parens. You can't know just form looking at `a b c` what `b` and `c` are. They may be functions of course. But also any other value. This would be exactly the same in for example JS. Nobody in JS ever complained that you can pass functions as arguments to functions and "don't see the arguments". (If you would write arguments you would actually call the function, and not pass it as a value.) But in OCaml you have a static type-system that can tell you at any point what `a`, `b`, or `c` are! Just hover the symbol. > I think the strength of ML and Haskell got eroded as more "mainstream"y languages got decent type systems (TS/Flow, Hack, Kotlin, even Rust, Python is getting there). I don't think so. Especially given those examples. TS/Flow doesn't have a sound type system. It may "type-check" fine and than explode at runtime. That's imho worse than dynamic typing as with dynamic typing you know at least that such fuck-up will happen. But TS delivers a false feeling of security about type safety where there is none. Hack is "gradually typed" which is just another word for dynamically typed with some static checks. So not even close to MLs. Python is also still dynamically typed, and that won't change. The bolted on type-checkers are unsound. So same situation as with TS. Nothing can be said about Kotlin afaik, as there was no formal work on its type-system. And Rust? Rust is a ML (with ugly C syntax)! So Rust is a prime example of how MLs are still one of the most modern and influential language designs to this day on. With Rust and Scala you have even two MLs in the Top20 languages. If something than ML is slowly but finally approaching mainstream. Maybe not in its original form but still the tradition lives on.