典型的な第一級モジュールの使用例は、あるシグネチャの複数の実装を実行時に選択することです。各々の実装は第一級モジュールにカプセル化できるストラクチャで、ハッシュテーブルのようなデータ構造に格納されます。

module type DEVICE = sig ... 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)
      

例えば、コマンドライン引数で実装を選択することができます。

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

また、関数内で実装を選択することもできます。

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

第一級のモジュールを使うと、ファンクタを使わずにコード断片をモジュール内でパラメータ化することができます。

let sort (type s) set l =
  let module Set = (val set : Set.S with type elt = s) in
  Set.elements (List.fold_right Set.add l Set.empty)
      

この関数に対して推論される型は (module Set.S with type elt = ’a) -> ’a list -> ’a list です。この関数を使うには Set.Make ファンクタをラップします。

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)
      

この関数の型は (’a -> ’a -> int) -> (module Set.S with type elt = ’a) です。

第一級モジュールの別の高度な利用法として、存在型を表現するというものがあります。特に、これは一般化代数データ型（GADT）を模倣するのに使うことができます。これを示すために、まず型の等価性を表す型を定義します。

module TypEq : sig
  type ('a, 'b) t
  val apply: ('a, 'b) t -> 'a -> 'b
  val refl: ('a, 'a) t
  val sym: ('a, 'b) t -> ('b, 'a) t
end = struct
  type ('a, 'b) t = ('a -> 'b) * ('b -> 'a)
  let refl = (fun x -> x), (fun x -> x)
  let apply (f, _) x = f x
  let sym (f, g) = (g, f)
end
      

次に、型構成子から型パラメータの情報が得られるような代数データ型を定義します。

module rec Typ : sig
  module type PAIR = sig
    type t and t1 and t2
    val eq: (t, t1 * t2) TypEq.t
    val t1: t1 Typ.typ
    val t2: t2 Typ.typ
  end

  type 'a typ =
    | Int of ('a, int) TypEq.t
    | String of ('a, string) TypEq.t
    | Pair of (module PAIR with type t = 'a)
end = Typ
      

'a typ 型の値が型 'a の実行時の表現になるものとします。 Int と String 構成子は簡単で、型パラメータ 'a と、基盤の型 int （または string）との等価性を与えるだけです。 Pair 構成子はもっと複雑です。型パラメータ 'a と t1 * t2 という形式の型の等価性に、 t1 と t2 の表現を加えたものを与えたいのですが、 t1 と t2 は与えられていません。このコードでは、第一級のモジュールを使って存在型を模倣しています。

'a typ 型の値は次のようにして構成します。

let int = Typ.Int TypEq.refl

let str = Typ.String TypEq.refl

let pair (type s1) (type s2) t1 t2 =
  let module P = struct
    type t = s1 * s2
    type t1 = s1
    type t2 = s2
    let eq = TypEq.refl
    let t1 = t1
    let t2 = t2
  end in
  let pair = (module P : Typ.PAIR with type t = s1 * s2) in
  Typ.Pair pair
      

最後に、例として、ある型 'a の実行時表現とその型の値を取り、その値を文字列として整形して返す多相関数を示します。

open Typ
let rec to_string: 'a. 'a Typ.typ -> 'a -> string =
  fun (type s) t x ->
    match t with
    | Int eq -> string_of_int (TypEq.apply eq x)
    | String eq -> Printf.sprintf "%S" (TypEq.apply eq x)
    | Pair p ->
        let module P = (val p : PAIR with type t = s) in
        let (x1, x2) = TypEq.apply P.eq x in
        Printf.sprintf "(%s,%s)" (to_string P.t1 x1) (to_string P.t2 x2)
      

多相再帰を使うために多相型アノテーションを使っていることに注意してください。