Module Mylib.Ocamlary

Level 1

Level 2

Level 3

Level 4

Basic module stuff

module Empty : sig ... end

A plain, empty module

module type Empty = sig ... end

An ambiguous, misnamed module type

module type MissingComment = sig ... end

An ambiguous, misnamed module type

module EmptyAlias = Empty

A plain module alias of Empty

EmptySig

module type EmptySig = sig ... end

A plain, empty module signature

module type EmptySigAlias = EmptySig

A plain, empty module signature alias of

module ModuleWithSignature : EmptySig

A plain module of a signature of EmptySig (reference)

module ModuleWithSignatureAlias : EmptySigAlias

A plain module with an alias signature

module One : sig ... end
module type SigForMod = sig ... end

There's a signature in a module in this signature.

module type SuperSig = sig ... end
module Buffer : sig ... end

Buffer.t

Basic exception stuff

After exception title.

exception Kaboom of unit

Unary exception constructor

exception Kablam of unit * unit

Binary exception constructor

exception Kapow of unit * unit

Unary exception constructor over binary tuple

exception EmptySig

EmptySig is general but EmptySig is a module and EmptySig is this exception.

exception EmptySigAlias

EmptySigAlias is this exception.

Basic type and value stuff with advanced doc comments

type ('a, 'b) a_function = 'a -> 'b

a_function is general but a_function is this type and a_function is the value below.

val a_function : x:int -> int

This is a_function with param and return type.

parameter x

the x coordinate

returns

the y coordinate

val fun_fun_fun : a_function
val fun_maybe : ?⁠yes:unit -> unit -> int
val not_found : unit -> unit
raises Not_found

That's all it does

val ocaml_org : string
see http://ocaml.org/

The OCaml Web site

val some_file : string
see some_file

The file called some_file

val some_doc : string
see some_doc

The document called some_doc

val since_mesozoic : unit

This value was introduced in the Mesozoic era.

since
mesozoic
val changing : unit

This value has had changes in 1.0.0, 1.1.0, and 1.2.0.

before 1.0.0

before 1.0.0

before 1.1.0

before 1.1.0

version
1.2.0
val with_foo : unit

This value has a custom tag foo. @foo the body of the custom foo tag

Some Operators

val (~-) : unit
val (!) : unit
val (@) : unit
val ($) : unit
val (%) : unit
val (^) : unit
val (&) : unit
val (*) : unit
val (-) : unit
val (+) : unit
val (<) : unit
val (>) : unit
val (-?) : unit
val (/) : unit
val (-|) : unit
val (:=) : unit
val (=) : unit
val (land) : unit

Advanced Module Stuff

module CollectionModule : sig ... end

This comment is for CollectionModule.

module type COLLECTION = module type of CollectionModule

module type of

module Recollection : functor (C : COLLECTION) -> COLLECTION with type collection = list and type element = C.collection
module type MMM = sig ... end
module type RECOLLECTION = MMM with module C = Recollection(CollectionModule)
module type RecollectionModule = sig ... end
module type A = sig ... end
module type B = sig ... end
module type C = sig ... end

This module type includes two signatures.

module FunctorTypeOf : functor (Collection : module type of CollectionModule) -> sig ... end

This comment is for FunctorTypeOf.

module type IncludeModuleType = sig ... end

This comment is for IncludeModuleType.

module type ToInclude = sig ... end
include ToInclude
module IncludedA : sig ... end
module type IncludedB = sig ... end

Advanced Type Stuff

type record = {
field1 : int;

This comment is for field1.

field2 : int;

This comment is for field2.

}

This comment is for record.

This comment is also for record.

type mutable_record = {
mutable a : int;

a is first and mutable

b : unit;

b is second and immutable

mutable c : int;

c is third and mutable

}
type universe_record = {
nihilate : a. 'a -> unit;
}
type variant =
| TagA

This comment is for TagA.

| ConstrB of int

This comment is for ConstrB.

| ConstrC of int * int

This comment is for binary ConstrC.

| ConstrD of int * int

This comment is for unary ConstrD of binary tuple.

This comment is for variant.

This comment is also for variant.

type poly_variant = [
| `TagA

This comment is for `TagA.

| `ConstrB of int

This comment is for `ConstrB.

]

This comment is for poly_variant.

Wow! It was a polymorphic variant!

type (_, _) full_gadt =
| Tag : full_gadt
| First : 'a -> full_gadt
| Second : 'a -> full_gadt
| Exist : 'a * 'b -> full_gadt

This comment is for full_gadt.

Wow! It was a GADT!

type 'a partial_gadt =
| AscribeTag : partial_gadt
| OfTag of partial_gadt
| ExistGadtTag : ('a -> 'b) -> partial_gadt

This comment is for partial_gadt.

Wow! It was a mixed GADT!

type _ record_arg_gadt =
| With_rec : {
foo : int;
} -> record_arg_gadt
| With_poly_rec : {
bar : a. 'a -> 'a;
} -> record_arg_gadt

This comment is for record_arg_gadt.

Wow! It was a GADT with record arguments

type alias = variant

This comment is for alias.

type tuple = (alias * alias) * alias * (alias * alias)

This comment is for tuple.

type variant_alias = variant =
| TagA
| ConstrB of int
| ConstrC of int * int
| ConstrD of int * int

This comment is for variant_alias.

type record_alias = record = {
field1 : int;
field2 : int;
}

This comment is for record_alias.

type poly_variant_union = [
| poly_variant
| `TagC
]

This comment is for poly_variant_union.

type 'a poly_poly_variant = [
| `TagA of 'a
]
type ('a, 'b) bin_poly_poly_variant = [
| `TagA of 'a
| `ConstrB of 'b
]
type 'a open_poly_variant = [> `TagA ] as a
type 'a open_poly_variant2 = [> `ConstrB of int ] as a
type 'a open_poly_variant_alias = open_poly_variant2
type 'a poly_fun = [> `ConstrB of int ] as a -> 'a
type 'a poly_fun_constraint = 'a -> 'a constraint 'a = [> `TagA ]
type 'a closed_poly_variant = [< `One | `Two ] as a
type 'a clopen_poly_variant = [< `One | `Two of int | `Three Two Three ] as a
type nested_poly_variant = [
| `A
| `B of [ `B1 | `B2 ]
| `C
| `D of [ `D1 of [ `D1a ] ]
]
type ('a, 'b) full_gadt_alias = full_gadt =
| Tag : full_gadt_alias
| First : 'a -> full_gadt_alias
| Second : 'a -> full_gadt_alias
| Exist : 'a * 'b -> full_gadt_alias

This comment is for full_gadt_alias.

type 'a partial_gadt_alias = partial_gadt =
| AscribeTag : partial_gadt_alias
| OfTag of partial_gadt_alias
| ExistGadtTag : ('a -> 'b) -> partial_gadt_alias

This comment is for partial_gadt_alias.

exception Exn_arrow : unit -> exn

This comment is for Exn_arrow.

type mutual_constr_a =
| A
| B_ish of mutual_constr_b

This comment is between mutual_constr_a and mutual_constr_b.

This comment is for mutual_constr_a then mutual_constr_b.

and mutual_constr_b =
| B
| A_ish of mutual_constr_a

This comment must be here for the next to associate correctly.

This comment is for mutual_constr_b then mutual_constr_a.

type rec_obj = < f : int; g : unit -> unit; h : rec_obj; >
type 'a open_obj = < f : int; g : unit -> unit; .. > as a
type 'a oof = < a : unit; .. > as a -> 'a
type 'a any_obj = < .. > as a
type empty_obj = < >
type one_meth = < meth : unit; >
type ext = ..

A mystery wrapped in an ellipsis

type ext += ExtA
type ext += ExtB
type ext += ExtC of unit | ExtD of ext
type ext += ExtE
type ext += ExtF
type 'a poly_ext = ..

'a poly_ext

type poly_ext += Foo of 'b | Bar of 'b * 'b
type poly_ext += Quux of 'c
module ExtMod : sig ... end
type ExtMod.t += ZzzTop0
type ExtMod.t += ZzzTop of unit
val launch_missiles : unit -> unit

Rotate keys on my mark...

type my_mod = (module COLLECTION)

A brown paper package tied up with string

class empty_class : object ... end
class one_method_class : object ... end
class two_method_class : object ... end
class 'a param_class : 'a -> object ... end
type my_unit_object = param_class
type 'a my_unit_class = unit param_class as a
module Dep1 : sig ... end
module Dep2 : functor (Arg : sig ... end) -> sig ... end
type dep1 = Dep2(Dep1).B.c
module Dep3 : sig ... end
module Dep4 : sig ... end
module Dep5 : functor (Arg : sig ... end) -> sig ... end
type dep2 = Dep5(Dep4).Z.X.b
type dep3 = Dep5(Dep4).Z.Y.a
module Dep6 : sig ... end
module Dep7 : functor (Arg : sig ... end) -> sig ... end
type dep4 = Dep7(Dep6).M.Y.d
module Dep8 : sig ... end
module Dep9 : functor (X : sig ... end) -> sig ... end
module type Dep10 = Dep9(Dep8).T with type t = int
module Dep11 : sig ... end
module Dep12 : functor (Arg : sig ... end) -> sig ... end
type dep5 = Dep13.c
module type With1 = sig ... end
module With2 : sig ... end
module With3 : With1 with module M = With2
type with1 = With3.N.t
module With4 : With1 with module M := With2
type with2 = With4.N.t
module With5 : sig ... end
module With6 : sig ... end
module With7 : functor (X : sig ... end) -> sig ... end
module type With8 = With7(With6).T with module M = With5 and type M.N.t = With5.N.t
module With9 : sig ... end
module With10 : sig ... end
module type With11 = With7(With10).T with module M = With9 and type N.t = int
module type NestedInclude1 = sig ... end
include NestedInclude1
module type NestedInclude2 = sig ... end
include NestedInclude2 with type nested_include = int
type nested_include = int
module DoubleInclude1 : sig ... end
module DoubleInclude3 : sig ... end
include module type of DoubleInclude3.DoubleInclude2
type double_include
module IncludeInclude1 : sig ... end
include module type of IncludeInclude1
module type IncludeInclude2 = sig ... end
include IncludeInclude2
type include_include

Trying the {!modules: ...} command.

With ocamldoc, toplevel units will be linked and documented, while submodules will behave as simple references.

With odoc, everything should be resolved (and linked) but only toplevel units will be documented.

  • Dep1.X
  • DocOckTypes
  • Ocamlary.IncludeInclude1
  • Ocamlary

Weirder usages involving module types

  • IncludeInclude1.IncludeInclude2
  • Dep4.T
  • A.Q

Playing with @canonical paths

module CanonicalTest : sig ... end
val test : CanonicalTest.Base.List.t -> unit

Some ref to CanonicalTest.Base__Tests.C.t and CanonicalTest.Base__Tests.L.id. But also to CanonicalTest.Base__.List and CanonicalTest.Base__.List.t

Aliases again

module Aliases : sig ... end

Section title splicing

I can refer to

But also to things in submodules:

And just to make sure we do not mess up:

  • {{!section:indexmodules}A} : A
  • {{!aliases}B} : B
  • {{!section:SuperSig.SubSigA.subSig}C} : C
  • {{!Aliases.incl}D} : D

New reference syntax

module type M = sig ... end
module M : sig ... end
module Only_a_module : sig ... end