Hacker News Reader

This is a good rundown of the basics of ML modules, the syntactic aspects, if you will. But it doesn't really give you the important insight:

  Abstraction. is. powerful.

if you consider the IntMap module provided in the article, you notice that the type `t` is not defined. It is kept "abstract". One defining property of ML modules is that you can indeed keep the definition of types hidden and nothing can break abstraction. The rest of the program can only manipulate the type `t` through the functions provided by the module.

This allows, in practice, to encode pretty much any property you would like. In the case of maps, you can use BST and never have to worry about users breaking the invariants: the user can't even see it's a BST! You can provide any form of validation and be sure that the data you manipulate will stay validated (as long as the module is correct, of course).

Functors allows you to rely on this by giving you a way to abstract away a whole module. This gives you excellent guarantees: if two modules behaves exactly the same, swapping them is semantic-preserving. Said in another way: if I can prove that sets-as-lists and sets-as-bst are functionally equivalents, then I can swap one for the other, and the rest of the program will behave the same!

Refactoring becomes a breeze. Functors (and modules) makes all the Javaesque reflections and dependency injections completely redundant: modules are (in OCaml) first class objects that you can manipulate and apply as you wish.

It also gives you separate compilation! A lot of people say that the OCaml compiler is blazing fast: this is precisely because OCaml's module system ensure that each module can be typechecked and compiled incrementally.

It pains me that modules get so little appreciation. Many ML programmers get a sort of selective blindness: just like fish in the sea, they don't realize the power of what they're swimming in. Proper modules with actual abstraction are, in my opinion, the single most essential feature for "large scale" programming.

View on HN

class M { // This is private std::vector<int> _sorted; public: // This is your "import" M(const std::vector<int>& v) : _sorted(v) { std::sort(_sorted.begin(), _sorted.end()); } // Add other ADT operations that preserve the invariant }

struct M { // Everything private; but as M is "friend" it can access all members class Sorted { friend M; std::vector<int> value; } static Sorted import(std::vector<int> v) { std::sort(v.begin(), v.end()); return Sorted{v}; } }