How OCaml's Proposed Include Functor Syntax Reduces Repetition

I want to introduce include functor, a feature developed in Jane Street's branch of the OCaml compiler that we are working to upstream. It simplifies a common pattern: writing the core of a module and using the same reusable logic to fill in the rest. The compiler used in the demonstration is linked in the video description.

Consider a module type Mappable with a data type, a key, and four operations: map and iter, plus mapi and iteri, whose functions also receive the key. An array can implement this interface straightforwardly: its key is an int, its data type is an array, and the four functions can use the corresponding array operations.

Now suppose we want another array module that traverses from back to front. The order matters when an iteration function has side effects. The key and data type remain the same, but mapi works backwards: it handles an empty array separately, applies the function to the last element to initialize the result, and then fills the remaining positions down to zero.

The reverse iteri is simpler: it uses a backwards for loop. But I don't want to write map and iter again. They can be derived from mapi and iteri by ignoring the extra key argument, and the same pattern applies whenever we implement Mappable. We could still provide a specialized implementation when efficiency calls for it.

A functor can package the common derivation. First I split the interface into Mappable_minimal, containing the types and indexed operations, and the full Mappable interface, which includes that minimal part and adds map and iter. The functor Make_map_iter takes a module M matching Mappable_minimal.

Inside Make_map_iter, map calls M.mapi with a function that ignores the first argument and otherwise applies the supplied function. Iter does the same with M.iteri. The compiler infers the expected signature, so we now have a reusable way to produce the two ordinary operations.

Applying that functor to the reverse-array definitions is awkward in the conventional syntax. I wrap those definitions in a module M, include M, and include Make_map_iter(M). This works, but it requires the extra wrapper and explicit inclusion; without an enclosing signature, M itself would also remain visible.

Include functor removes that wrapper. After writing the core definitions directly in the module, I write include functor Make_map_iter. Conceptually, it applies the functor to the definitions already present in the module and includes the result. I can therefore define only the core functionality and get the rest without repeating the extra module and includes.

The syntax also works in module types, where it includes the functor's module type, though that is less common than the implementation example. The documentation has more detail on that use.