OCaml Compiler Hacking: how to add a primitive

I also recommend the notes for L28[1] - Advanced Functional Programming at Cambridge. They might be a little hard to follow, but they are extremely insightful and teach concepts that may be difficult to learn elsewhere

[1] https://www.cl.cam.ac.uk/teaching/1415/L28/materials.html

I first started using ocaml (f# actually and then re-wrote it in ocaml) for writing a simple interpreter to generate java code from mysql schema tables to deal with hibernate boiler plates etc. The code was much succinct than a comparable parser written in say antlr. That was my first introduction to typesafety helping me move forward. Specially, when coming back to the code, the compiler will scream at you for either not handling all the patterns that matched or adding new ones that didnt exist yet and needed to be changed. I went away from OCAML towards Haskell because a coworker convinced me to switch: also haskell seems to have a better support for multicore architectures. Of course, my applications are more web/networking apps, crud, websites etc. So i could have gone either way. The one difference i find when programming with Haskell as opposed to ocaml is that in ocaml, my instinct would be to write a little interpreter(or a quasi quoter). In Haskell, I still think that template haskell is a necessary evil, therefore, do it only when I really know what I am doing. I found this link to be quite helpful: http://pleac.sourceforge.net/pleac_ocaml/

One warning. Some functional programming materials (books, tutorials, etc) can be way too theoretical. However this has changed a lot in recent years.

The language itself isn't rocket science. If whatever you're reading isn't a good fit, try to find something else.

> I content that it would be a good choice as a default programming language for most programmers.

Strongly agree. I now write all of my everyday “glue code” in F#, and use C# for the low-level algorithmic/library stuff. This is directly opposed to the received wisdom, but I find that it works far better (although I think in ML no matter what language I’m using).

My theory as to why this works is that designing and writing robust “line-of-business apps” is really tantamount to designing and implementing a protocol, which, in turn, requires writing something like a parser or recognizer, and it just so happens that ML is really good for writing parsers and recognizers.

> my feeling is that with Python it's easy to start programs and with OCaml (ML) it's easy to finish them.

I’m stealing this.

I have had a quick skim (10 - 15 minute reads at a random points, until I have time to read it properly) of Real World Ocaml.

So far it looks great, and is very pragmatic and also covers useful tools for working in Ocaml (imho that should be in every modern specific programming language book, but it probably will date faster the rest of the book).

> The core of ML is the real gold.

I think that's the thing that keeps me interested in OCaml and is making me interested in F#: the core ML language is not very complex, and it can carry you a long way before you start requiring advanced features. I wrote a few compilers in OCaml using only the core language and very simple modules (basically just signature + struct, no functors) and the end result was very easy to read and modify. I think very few languages can make a similar claim: either the language doesn't get you all the way and you need external help (e.g. C and its pre-processor) or overshoots into too much complexity (e.g. C++).

ML is not a language for all tasks (I am learning Rust for those times when OCaml is not appropriate), but I think that ML languages could be used beneficially in many more applications today.

Functors => higher-kinded types

yeah but I'm dead scared of the stories I've heard about indeterminate execution time in certain cases. For my real-time production use case this would be a deal breaker. Am I misguided?

There's at least one financial firm that chose Haskell and presented good results from it. Galois works miracles with Haskell left and right. So, there's a slow build-up of momentum in that direction. I'm hesitant to use it due to the learning curve. I have a feeling I could probably get productive in Ocaml faster than in Haskell. I figure I would learn them in that order.

Not sure if that's true as I use neither and only did minimal functional programming in LISP. I mostly do an imperative style along lines of Cleanroom methodology. I'd like to hear veterans' opinions as to whether Ocaml's learning curve would be easier on imperative programmers than Haskell.

Things I like for Ocaml over Haskell:

* Predictable performance; No need to worry about space leaks. * The module system is pretty nice. * Named/optional function parameters. * Being able to write filthy imperative code without needing to use monads for everything. :)