## ﻿9.11 Module expressions (module implementations)

- 9.11.1 Simple module expressions
- 9.11.2 Structures
- 9.11.3 Functors

Module expressions are the module-level equivalent of value expressions: they evaluate to modules, thus providing implementations for the specifications expressed in module types.

module-expr | ::= | module-path
| ∣ | struct[module-items]end
| ∣ | functor ( module-name : module-type ) -> module-expr
| ∣ | module-expr ( module-expr )
| ∣ | ( module-expr )
| ∣ | ( module-expr : module-type )
module-items | ::= | {;;} (definition∣expr) { {;;} (definition∣;; expr) } {;;}
definition | ::= | let[rec]let-binding{and let-binding}
| ∣ | external value-name : typexpr = external-declaration
| ∣ | type-definition
| ∣ | exception-definition
| ∣ | class-definition
| ∣ | classtype-definition
| ∣ | module module-name{( module-name : module-type )} [: module-type]= module-expr
| ∣ | module type modtype-name = module-type
| ∣ | open module-path
| ∣ | include module-expr

See also the following language extensions: recursive modules, first-class modules, overriding in open statements, attributes, extension nodes and generative functors.

### ﻿9.11.1 Simple module expressions

The expression module-path evaluates to the module bound to the name module-path.

The expression ( module-expr ) evaluates to the same module as module-expr.

The expression ( module-expr : module-type ) checks that the type of module-expr is a subtype of module-type, that is, that all components specified in module-type are implemented in module-expr, and their implementation meets the requirements given in module-type. In other terms, it checks that the implementation module-expr meets the type specification module-type. The whole expression evaluates to the same module as module-expr, except that all components not specified in module-type are hidden and can no longer be accessed.

### ﻿9.11.2 Structures

Structures struct … end are collections of definitions for value names, type names, exceptions, module names and module type names. The definitions are evaluated in the order in which they appear in the structure. The scopes of the bindings performed by the definitions extend to the end of the structure. As a consequence, a definition may refer to names bound by earlier definitions in the same structure.

For compatibility with toplevel phrases (chapter 12), optional ;; are allowed after and before each definition in a structure. These ;; have no semantic meanings. Similarly, an expr preceded by ;; is allowed as a component of a structure. It is equivalent to let _ = expr, i.e. expr is evaluated for its side-effects but is not bound to any identifier. If expr is the first component of a structure, the preceding ;; can be omitted.

#### ﻿Value definitions

A value definition let [rec] let-binding { and let-binding } bind value names in the same way as a let … in … expression (see section 9.7.2). The value names appearing in the left-hand sides of the bindings are bound to the corresponding values in the right-hand sides.

A value definition external value-name : typexpr = external-declaration implements value-name as the external function specified in external-declaration (see chapter 20).

#### ﻿Type definitions

A definition of one or several type components is written type typedef { and typedef } and consists of a sequence of mutually recursive definitions of type names.

#### ﻿Exception definitions

Exceptions are defined with the syntax exception constr-decl or exception constr-name = constr.

#### ﻿Class definitions

A definition of one or several classes is written class class-binding { and class-binding } and consists of a sequence of mutually recursive definitions of class names. Class definitions are described more precisely in section 9.9.3.

#### ﻿Class type definitions

A definition of one or several classes is written class type classtype-def { and classtype-def } and consists of a sequence of mutually recursive definitions of class type names. Class type definitions are described more precisely in section 9.9.5.

#### ﻿Module definitions

The basic form for defining a module component is module module-name = module-expr, which evaluates module-expr and binds the result to the name module-name.

One can write

module module-name : module-type = module-expr

instead of

module module-name = ( module-expr : module-type ).

Another derived form is

module module-name ( name1 : module-type1 ) … ( namen : module-typen ) = module-expr

which is equivalent to

module module-name = functor ( name1 : module-type1 ) -> … -> module-expr

#### ﻿Module type definitions

A definition for a module type is written module type modtype-name = module-type. It binds the name modtype-name to the module type denoted by the expression module-type.

#### ﻿Opening a module path

The expression open module-path in a structure does not define any components nor perform any bindings. It simply affects the parsing of the following items of the structure, allowing components of the module denoted by module-path to be referred to by their simple names name instead of path accesses module-path . name. The scope of the open stops at the end of the structure expression.

#### ﻿Including the components of another structure

The expression include module-expr in a structure re-exports in the current structure all definitions of the structure denoted by module-expr. For instance, if you define a module S as below

module S = struct type t = int let x = 2 end

defining the module B as

module B = struct include S let y = (x + 1 : t) end

is equivalent to defining it as

module B = struct type t = S.t let x = S.x let y = (x + 1 : t) end

The difference between open and include is that open simply provides short names for the components of the opened structure, without defining any components of the current structure, while include also adds definitions for the components of the included structure.

### ﻿9.11.3 Functors

#### ﻿Functor definition

The expression functor ( module-name : module-type ) -> module-expr evaluates to a functor that takes as argument modules of the type module-type1, binds module-name to these modules, evaluates module-expr in the extended environment, and returns the resulting modules as results. No restrictions are placed on the type of the functor argument; in particular, a functor may take another functor as argument (“higher-order” functor).

When the result module expression is itself a functor,

functor ( name1 : module-type1 ) -> … -> functor ( namen : module-typen ) -> module-expr

one may use the abbreviated form

functor ( name1 : module-type1 ) … ( namen : module-typen ) -> module-expr

#### ﻿Functor application

The expression module-expr1 ( module-expr2 ) evaluates module-expr1 to a functor and module-expr2 to a module, and applies the former to the latter. The type of module-expr2 must match the type expected for the arguments of the functor module-expr1.