I wrote a royal flush simulator in OCaml just to not forget the language.
OCaml is cool. I took a class, Abstraction and Design in Computation, that used OCaml exclusively. It was a good language for that class because we began with functional programming, including using modules and functors, and then moved to object oriented programming. It handles both paradigms well.
A fellow programmer who doesn’t write functional code asked why I liked OCaml after taking this class, and I told him about algebraic data types. The best example I could think of was expressing a deck of cards in code, which is certainly possible in any programming paradigm and language, but I think much more pleasant in OCaml.
Here’s an algebraic data type I defined to represet card faces (in cards.ml):
I did the same thing to define a type for suits…
… and then defined a card as a suit, face tuple:
Now I could use variables to represent each face value and assign a numeric value, but that has a few drawbacks.
First of all, because face_value is a type now, OCaml will handle enforcement anywhere you specificy you want a face_value. You don’t have to just use an int and then check every time that it’s within the specified range.
Second, it’s easier to read.
Third, with OCaml’s pattern matching, I now use these types to write relatively readable, and short, code to test for a royal flush:
This method takes a hand (a list of items of type card) and then tests if it matches the “pattern” for a royal flush. A royal flush contains an Ace, King, Queen, Jack and Ten, all of the same suit. I take the “suit” of the first card, and then test whether the pattern holds. Notice that “suit” is a variable.
I believe the above code is much more elegant and readable than could otherwise be written without pattern matching and algebraic data types.
I don’t get to use OCaml in my daily work, and I miss it.