Module Melange_compiler_libs

module Annot: { ... };
module Ast_helper: { ... };

Helpers to produce Parsetree fragments

module Ast_iterator: { ... };

Ast_iterator.iterator enables AST inspection using open recursion. A typical mapper would be based on Ast_iterator.default_iterator, a trivial iterator, and will fall back on it for handling the syntax it does not modify.

module Ast_mapper: { ... };

The interface of a -ppx rewriter

module Attr_helper: { ... };

Helpers for attributes

module Bs_clflags: { ... };
module Btype: { ... };
module Builtin_attributes: { ... };

Support for some of the builtin attributes

module Cmi_format: { ... };
module Cmt_format: { ... };

cmt and cmti files format.

module Config: { ... };

System configuration

module Consistbl: { ... };

Consistency tables: for checking consistency of module CRCs

module Ctype: { ... };
module Datarepr: { ... };
module Depend: { ... };

Module dependencies.

module Diffing: { ... };

Parametric diffing

module Diffing_with_keys: { ... };

When diffing lists where each element has a distinct key, we can refine the diffing patch by introducing two composite edit moves: swaps and moves.

module Docstrings: { ... };

Documentation comments

module Env: { ... };
module Envaux: { ... };
module Errortrace: { ... };
module Includeclass: { ... };
module Includecore: { ... };
module Includemod: { ... };
module Includemod_errorprinter: { ... };
module Lambda: { ... };
module Lazy_backtrack: { ... };
module Lexer: { ... };

The lexical analyzer

module Load_path: { ... };

Management of include directories.

module Location: { ... };

Source code locations (ranges of positions), used in parsetree.

module Matching: { ... };
module Misc: { ... };

Miscellaneous useful types and functions

module Mtype: { ... };
module Oprint: { ... };
module Outcometree: { ... };
module Parmatch: { ... };

Detection of partial matches and unused match cases.

module Parse: { ... };

Entry points in the parser

module Parser: { ... };
module Parsetree: { ... };

Abstract syntax tree produced by parsing

module Path: { ... };
module Patterns: { ... };
module Persistent_env: { ... };
module Pprintast: { ... };

Pretty-printers for Parsetree

module Predef: { ... };
module Primitive: { ... };
module Printast: { ... };

Raw printer for Parsetree

module Printlambda: { ... };
module Printpat: { ... };
module Printtyp: { ... };
module Printtyped: { ... };
module Rec_check: { ... };
module Shape: { ... };
module Syntaxerr: { ... };

Auxiliary type for reporting syntax errors

module Signature_group: { ... };

Iterate on signature by syntactic group of items

module Simplif: { ... };

Lambda simplification.

module Stypes: { ... };
module Subst: { ... };
module Switch: { ... };
module Tast_iterator: { ... };

Allows the implementation of typed tree inspection using open recursion

module Tast_mapper: { ... };
module Tmc: { ... };

Tail-modulo-cons optimization.

module Translattribute: { ... };
module Translclass: { ... };
module Translcore: { ... };
module Translmod: { ... };
module Translobj: { ... };
module Translprim: { ... };
module Type_immediacy: { ... };

Immediacy status of a type

module Typeclass: { ... };
module Typecore: { ... };
module Typedecl: { ... };
module Typedecl_immediacy: { ... };
module Typedecl_properties: { ... };
module Typedecl_separability: { ... };

The OCaml runtime assumes for type-directed optimizations that all types are "separable". A type is "separable" if either all its inhabitants (the values of this type) are floating-point numbers, or none of them are.

module Typedecl_unboxed: { ... };
module Typedecl_variance: { ... };
module Typedtree: { ... };

Abstract syntax tree after typing

module Typemod: { ... };

Type-checking of the module language and typed ast hooks

module Typeopt: { ... };
module Types: { ... };
module Typetexp: { ... };
module Untypeast: { ... };
module Warnings: { ... };

Warning definitions