package codept-lib

  1. Overview
  2. Docs

Module M2lSource

The M2l module (for Module Meta Language) defines the codept AST.

This AST is a restriction of the Ocaml parsetree AST, that can describe all constructions at the module level but have a very simplified view of value (and type) level expressions.

For instance,

  module A = struct
    module Inner = struct let f x = x end
  end
  let x = 1
  open A
  module B = struct let y = Inner.f x end

is translated to

  module A = struct
    module Inner = struct end
  end
  open A
  module B = struct [%access {Inner}]  end

Main types

Sourcetype 'a bind = {
  1. name : Name.t option;
  2. expr : 'a;
}

'a bind is an auxilliary type used for module/module type binding

Sourcetype kind =
  1. | Structure
  2. | Signature
    (*

    The nature (ml/mli) of an m2l ast

    *)
Sourcetype m2l = expression Loc.ext list

An m2l ast/code fragment is a list of module level expression

Sourceand expression =
  1. | Open of module_expr
    (*

    open A.B.C ⇒ Open [A;B;C]

    *)
  2. | Include of module_expr
    (*

    struct include A end

    *)
  3. | SigInclude of module_type
    (*

    struct include A end

    *)
  4. | Bind of module_expr bind
    (*

    struct module A = struct … end

    *)
  5. | Bind_sig of module_type bind
    (*

    struct module type A = sig … end

    *)
  6. | Bind_rec of module_expr bind list
    (*

    module rec A = … and B = … and …

    *)
  7. | Minor of minor list
    (*

    value level expression. Invariant: for any pure outliner f, f (Minor m :: q ) ≡ f q , i.e, this expression constructor is only meaningful for dependencies tracking.

    *)
  8. | Extension_node of extension
    (*

    [%ext …]

    *)

The expression type is the basic building block of the m2l AST

Sourceand minor =
  1. | Access of access
    (*

    see access below

    *)
  2. | Pack of module_expr Loc.ext
    (*

    (module struct ... end)

    *)
  3. | Extension_node of extension Loc.ext
    (*

    %ext ...

    *)
  4. | Local_open of Loc.t * module_expr * minor list
    (*

    let open struct ... end in ...

    *)
  5. | Local_bind of Loc.t * module_expr bind * minor list
    (*

    let module M = ... in ...

    *)

A minor element represents a short description of type or value level constructions, that contains only the information relevant for dependency tracking.

M.N.L.x ⇒ access {M.N.L = Normal } type t = A.t ⇒ access { A = ε }

Sourceand module_expr =
  1. | Ident of Paths.Simple.t
    (*

    A.B… *

    *)
  2. | Apply of {
    1. f : module_expr;
    2. x : module_expr;
    }
    (*

    F(X)

    *)
  3. | Fun of module_expr fn
    (*

    functor (X:S) -> M

    *)
  4. | Constraint of module_expr * module_type
    (*

    M:S

    *)
  5. | Str of m2l
    (*

    struct … end

    *)
  6. | Val of minor list
    (*

    val …

    *)
  7. | Extension_node of extension
    (*

    [%ext …]

    *)
  8. | Abstract
    (*

    empty module expression, used as a placeholder. In particular, it is useful for constraining first class module unpacking as Constraint(Abstract, signature).

    *)
  9. | Unpacked
    (*

    (module M)

    *)
  10. | Open_me of {
    1. opens : Paths.Simple.t Loc.ext list;
    2. expr : module_expr;
    }
    (*

    M.(…N.( module_expr)…) Note: This construction does not exist (yet?) in OCaml proper. It is used here to simplify the interaction between pattern open and first class module.

    *)
  11. | Proj of {
    1. me : module_expr;
    2. proj : Paths.Simple.t;
    }

Module level expression representation

Sourceand module_type =
  1. | Alias of Paths.Simple.t
    (*

    module m = A…

    *)
  2. | Ident of Paths.Expr.t
    (*

    module M : F(X).s Note: Paths.Expr is used due to F.(X).s expressions that do not have an equivalent on the module level

    *)
  3. | Sig of m2l
    (*

    sig … end

    *)
  4. | Fun of module_type fn
    (*

    functor (X:S) → M

    *)
  5. | Of of module_expr
    (*

    module type of …

    *)
  6. | Extension_node of extension
    (*

    %%…

    *)
  7. | Abstract
    (*

    module type T

    *)
  8. | With of {
    1. body : module_type;
    2. with_constraints : with_constraint list;
    }
    (*

    S with ...

    *)

Module type level representation

Sourceand with_constraint = {
  1. lhs : Paths.S.t;
  2. delete : bool;
  3. rhs : with_rhs;
}
Sourceand with_rhs =
  1. | Type of minor list
    (*

    S with type t =/:= ...

    *)
  2. | Module of Paths.S.t Loc.ext
    (*

    S with module N.M := … we need to track abstract module type strenghthening.

    *)
  3. | Module_type of module_type
Sourceand 'a fn = {
  1. arg : module_type Module.Arg.t option;
  2. body : 'a;
}

Functor auxiliary type

Sourceand extension = {
  1. name : string;
  2. extension : extension_core;
}

An specific represention for an extension node

Sourceand extension_core =
  1. | Module of m2l
  2. | Val of minor list

A type for extension payload

Sourcetype t = m2l

Schematic serialization

Sourcemodule Sch : sig ... end
Sourcemodule Annot : sig ... end
Sourcemodule Build : sig ... end

Basis analysis

Sourcemodule Sig_only : sig ... end

Printers

Sourceval pp : Format.formatter -> m2l -> unit
Sourceval pp_expression : Format.formatter -> expression -> unit
Sourceval pp_annot : Format.formatter -> minor list -> unit
Sourceval pp_me : Format.formatter -> module_expr -> unit
Sourceval pp_mt : Format.formatter -> module_type -> unit
Sourceval pp_with_constraints : Format.formatter -> with_constraint list -> unit
Sourceval pp_access : access Pp.t