8.6 First-class modules

(Introduced in OCaml 3.12; pattern syntax and package type inference introduced in 4.00; structural comparison of package types introduced in 4.02.; fewer parens required starting from 4.05)

Modules are typically thought of as static components. This extension makes it possible to pack a module as a first-class value, which can later be dynamically unpacked into a module.

The expression ( module module-expr : package-type ) converts the module (structure or functor) denoted by module expression module-expr to a value of the core language that encapsulates this module. The type of this core language value is ( module package-type ). The package-type annotation can be omitted if it can be inferred from the context.

Conversely, the module expression ( val expr : package-type ) evaluates the core language expression expr to a value, which must have type module package-type, and extracts the module that was encapsulated in this value. Again package-type can be omitted if the type of expr is known. If the module expression is already parenthesized, like the arguments of functors are, no additional parens are needed: Map.Make(val key).

The pattern ( module module-name : package-type ) matches a package with type package-type and binds it to module-name. It is not allowed in toplevel let bindings. Again package-type can be omitted if it can be inferred from the enclosing pattern.

The package-type syntactic class appearing in the ( module package-type ) type expression and in the annotated forms represents a subset of module types. This subset consists of named module types with optional constraints of a limited form: only non-parametrized types can be specified.

For type-checking purposes (and starting from OCaml 4.02), package types are compared using the structural comparison of module types.

In general, the module expression ( val expr : package-type ) cannot be used in the body of a functor, because this could cause unsoundness in conjunction with applicative functors. Since OCaml 4.02, this is relaxed in two ways: if package-type does not contain nominal type declarations (i.e. types that are created with a proper identity), then this expression can be used anywhere, and even if it contains such types it can be used inside the body of a generative functor, described in section 8.16. It can also be used anywhere in the context of a local module binding let module module-name = ( val expr₁ : package-type ) in expr₂.

Basic example

A typical use of first-class modules is to select at run-time among several implementations of a signature. Each implementation is a structure that we can encapsulate as a first-class module, then store in a data structure such as a hash table:

 type picture = …
 module type DEVICE = sig
   val draw : picture -> unit
   …
 end
 let devices : (string, (module DEVICE)) Hashtbl.t = Hashtbl.create 17

 module SVG = struct … end
 let _ = Hashtbl.add devices "SVG" (module SVG : DEVICE)

 module PDF = struct … end
 let _ = Hashtbl.add devices "PDF" (module PDF: DEVICE)

We can then select one implementation based on command-line arguments, for instance:

 let parse_cmdline () = …
 module Device =
   (val (let device_name = parse_cmdline () in
         try Hashtbl.find devices device_name
         with Not_found ->
           Printf.eprintf "Unknown device %s\n" device_name;
           exit 2)
    : DEVICE)

 let draw_using_device device_name picture =
   let module Device =
     (val (Hashtbl.find devices device_name) : DEVICE)
   in
   Device.draw picture

Advanced examples

With first-class modules, it is possible to parametrize some code over the implementation of a module without using a functor.

 let sort (type s) (module Set : Set.S with type elt = s) l =
   Set.elements (List.fold_right Set.add l Set.empty)
val sort : (module Set.S with type elt = 's) -> 's list -> 's list = <fun>

 let make_set (type s) cmp =
   let module S = Set.Make(struct
     type t = s
     let compare = cmp
   end) in
   (module S : Set.S with type elt = s)
val make_set : ('s -> 's -> int) -> (module Set.S with type elt = 's) = <fun>