• Cyclohexane
      link
      fedilink
      arrow-up
      8
      arrow-down
      1
      ·
      2 months ago

      Sad I had to scroll to the end to see this.

      Ocaml is brilliant and has the nicest type features. It’s almost like Haskell but more approachable imo.

      • paperplane@lemmy.world
        link
        fedilink
        arrow-up
        3
        ·
        2 months ago

        Coming from Haskell, OCaml always felt a bit strange to me. The double semicolons, the inconsistency in the standard library between curried and uncurried functions etc. Maybe I’m confusing it with Standard ML though, can’t remember.

        • Cyclohexane
          link
          fedilink
          arrow-up
          2
          ·
          2 months ago

          I know double semicolons are a thing, but I’ve never had to use them. I forget what they’re for, but yeah it’s supposed to be an escape hatch for something that shouldn’t be happening iirc.

          The curried snd uncurried functions… Maybe you are confusing with SML, because everything in ocaml is curried by default. Though admittedly the standard library could be more complete, but I personally am happy to use third party dependencies for less common things.

      • AbelianGrape@beehaw.org
        link
        fedilink
        arrow-up
        2
        ·
        edit-2
        1 month ago

        As a Haskell programmer, “OCaml has the nicest type features” hurts just a little bit.

        I sometimes teach a course in OCaml. The students who are very engaged inevitably ask me about Haskell, I encourage them to try it, and then they spend the rest of the semester wondering why the course is taught in OCaml. Bizarre how different that is from when colleagues in industry want to try Haskell.

          • AbelianGrape@beehaw.org
            link
            fedilink
            arrow-up
            1
            ·
            1 month ago

            Largely reasonable?

            Haskell is not good for systems programming which sums up about 60-70% of that post. Laziness is lovely in theory but many industry uses of Haskell use stricthaskell for all or most of their code, so I certainly agree with that part too.

            Their largest complaint about using Haskell for small non-systems programs seems to be the mental overhead induced by laziness. But for me, for small programs where performance isn’t a huge concern (think Advent of code or a script for daily life) laziness reduces my mental overhead. I think that author is just especially concerned about having a deep understanding of their programs’ performance because of their systems background. I worry about performance when it becomes relevant. Debugging Haskell performance issues is certainly harder than strict languages but still totally doable.

            The lack of type classes or other form of ergonomic overloading in OCaml is easily the single “feature” most responsible for the language never taking off.

            • Cyclohexane
              link
              fedilink
              arrow-up
              1
              ·
              1 month ago

              As someone who is not deep into type theory or functional programming, can you please explain why you mean by “ergonomic overloading”?

              My understanding is that ocaml mitigates the need for type classes through its more advanced module system. So far I have been enjoying the use of OCaml modules, so I’m curious what exactly I’m missing out on, if any.

              Thanks for taking the time to talk with me btw!

              • AbelianGrape@beehaw.org
                link
                fedilink
                arrow-up
                1
                ·
                1 month ago

                You have to be explicit about which module you’re using at all times, even though 99% of the time only one could apply. When the type class resolution is unique, but complicated, there’s no mental overhead for the Haskell programmer but getting all the right modules is a lot of overhead for the OCaml programmer. It also lets us write functions that are polymorphic under a class constraint. In OCaml you have to explicitly take a module argument to do this. If you want to start composing such functions, it gets tedious extremely fast.

                And then even once you’re using a module, you can’t overload a function name. See: + vs +.. Basically modules and type classes solve different problems. You can do some things with modules that you cannot ergonomically do with type classes, for example. create a bit-set representation of sets of integers, and a balanced search tree for sets of other types, and expose that interface uniformly from the same module functor. But Haskell has other ways to achieve that same functionality and more.

                OCaml’s type system cannot replicate the things you can do with Haskell’s higher kinded types, type families, or data kinds at all (except for a fraction of Haskell’s GADTs).