4 ms·

They're similar but not really the same. The big differences are: * Haskell is pure whereas Ocaml is not * Haskell has a great story for parallelism whereas O

• spekcular 6y ago
  Note that multicore OCaml is almost ready: https://discuss.ocaml.org/t/multicore-ocaml-may-2020-update/5898 https://discuss.ocaml.org/t/multicore-ocaml-may-2020-update/...
  • vkazanov 6y ago
    Oh-h-h-h... I've heard this so many times before :-)
    • yaantc 6y ago
      This time is different ;) Look at the end of the GP link on multi-core Ocaml progress report: everything under the "OCaml" title is work on the upstream compiler. It's still limited, but the upstreaming process has started.
      • ghostwriter 6y ago
        Having an SMP compiler/runtime is half of the story, the other half is safe parallelism. I expect another decade is going to be spent on chasing bugs due to mutable data escape hatches in OCaml world.
        • pdimitar 6y ago
          This is my main worry about Multicore OCaml. You nailed it. There's a lot of legacy in the ecosystem -- which is not a bad thing at all! Many people appreciate stable environments and learn to circumvent their problems. All completely fine and we all do it. But I worry that by chasing backwards compatibility and not just saying "guys, you need to modernise your libraries to do X and Y, otherwise you will never be Multicore OCaml-friendly" the maintainers will invite a lot of legacy cruft -- which will now be subtly broken -- that they will either have to fix themselves or just concede that it's impossible. Then again, I suppose they don't want the Python 2 vs. Python 3 split (or Perl 5 vs. Perl 6 / Raiku; EDIT: It's actually "Raku" as a commenter below clarified). But I fear it will happen anyway due to the reasons above. I very quickly fell in love with OCaml but eventually settled at Rust for these, and a few other reasons. It's an otherwise excellent language and has one of the most underrated compilers on the planet. It's a shame that it's moving so slowly... :( EDIT: As for safe parallelism, here's what one of the maintainers said soon ago: https://news.ycombinator.com/item?id=22735176 https://news.ycombinator.com/item?id=22735176 It looks like they prefer to do the lowest level possible so people can build their own abstractions on top. Completely fair though, not criticising.
          • lizmat 6y ago
            It's actually called Raku (https://raku.org https://raku.org using the #rakulang tag on social media), not Raiku.
            • pdimitar 6y ago
              Whoops. I was sure I got it wrong. Thanks.
• chewxy 6y ago
  I've heard it best as: both Ocaml and Haskell are pure functional languages. Haskell is Extra Virgin. That said, the notion of purity is a bit BS. At some point in your program you are definitely going to invoke the world-at-large. Whether you do it through IO(), tap your nose and call it "pure" or you do it other way is all down to semantics (not in the PLT sense of the word - the PLT term to use would be "pragmatics"). The core of both Ocaml and Haskell are pure functions. Also, Ocaml doesn't really need typeclasses. Modules. Modules are everything
  • sweeneyrod 6y ago
    OCaml is a lot less pure in spirit as well. Not only can you read and write to the outside world without having to jump through hoops, you can also write all your code with pointers, for loops and (mutable) arrays if you so desire.
• millimeterman 6y ago
  Haskell certainly has a _better_ parallelism story than OCaml but I wouldn't call it great. It's really nothing special.