Module Ocaml_typing.TypedtreeSource

Abstract syntax tree after typing

By comparison with Parsetree:

Sourcemodule Uid = Shape.Uid
Sourcetype partial =
  1. | Partial
  2. | Total

Extension points

Sourcetype attributes = attribute list

Core language

Sourcetype value =
  1. | Value_pattern
Sourcetype computation =
  1. | Computation_pattern
Sourcetype _ pattern_category =
  1. | Value : value pattern_category
  2. | Computation : computation pattern_category
Sourceand 'k general_pattern = 'k pattern_desc pattern_data
Sourceand 'a pattern_data = {
  1. pat_desc : 'a;
  2. pat_loc : Ocaml_parsing.Location.t;
  3. pat_extra : (pat_extra * Ocaml_parsing.Location.t * attributes) list;
  4. pat_type : Types.type_expr;
  5. pat_env : Env.t;
  6. pat_attributes : attributes;
}
Sourceand pat_extra =
  1. | Tpat_constraint of core_type
    (*

    P : T pat_desc = P ; pat_extra = (Tpat_constraint T, _, _) :: ...

    *)
  2. | Tpat_type of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc
    (*

    #tconst pat_desc = disjunction ; pat_extra = (Tpat_type (P, "tconst"), _, _) :: ...

    where disjunction is a Tpat_or _ representing the branches of tconst.

    *)
  3. | Tpat_open of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Env.t
  4. | Tpat_unpack
    (*

    (module P) pat_desc = Tpat_var "P" ; pat_extra = (Tpat_unpack, _, _) :: ... (module _) pat_desc = Tpat_any ; pat_extra = (Tpat_unpack, _, _) :: ...

    *)
Sourceand 'k pattern_desc =
  1. | Tpat_any : value pattern_desc
    (*

    _

    *)
  2. | Tpat_var : Ident.t * string Ocaml_parsing.Asttypes.loc * Uid.t -> value pattern_desc
    (*

    x

    *)
  3. | Tpat_alias : value general_pattern * Ident.t * string Ocaml_parsing.Asttypes.loc * Uid.t -> value pattern_desc
    (*

    P as a

    *)
  4. | Tpat_constant : Ocaml_parsing.Asttypes.constant -> value pattern_desc
    (*

    1, 'a', "true", 1.0, 1l, 1L, 1n

    *)
  5. | Tpat_tuple : value general_pattern list -> value pattern_desc
    (*

    (P1, ..., Pn)

    Invariant: n >= 2

    *)
  6. | Tpat_construct : Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Types.constructor_description * value general_pattern list * (Ident.t Ocaml_parsing.Asttypes.loc list * core_type) option -> value pattern_desc
    (*

    C (, None) C P (P, None) C (P1, ..., Pn) (P1; ...; Pn, None) C (P : t) (P, Some (, t)) C (P1, ..., Pn : t) (P1; ...; Pn, Some (, t)) C (type a) (P : t) (P, Some (a, t)) C (type a) (P1, ..., Pn : t) (P1; ...; Pn, Some (a, t))

    *)
  7. | Tpat_variant : Ocaml_parsing.Asttypes.label * value general_pattern option * Types.row_desc ref -> value pattern_desc
    (*

    `A (None) `A P (Some P)

    See Types.row_desc for an explanation of the last parameter.

    *)
  8. | Tpat_record : (Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Types.label_description * value general_pattern) list * Ocaml_parsing.Asttypes.closed_flag -> value pattern_desc
    (*

    l1=P1; ...; ln=Pn (flag = Closed) l1=P1; ...; ln=Pn; _ (flag = Open)

    Invariant: n > 0

    *)
  9. | Tpat_array : value general_pattern list -> value pattern_desc
    (*

    | P1; ...; Pn |

    *)
  10. | Tpat_lazy : value general_pattern -> value pattern_desc
    (*

    lazy P

    *)
  11. | Tpat_value : tpat_value_argument -> computation pattern_desc
    (*

    P

    Invariant: Tpat_value pattern should not carry pat_attributes or pat_extra metadata coming from user syntax, which must be on the inner pattern node -- to facilitate searching for a certain value pattern constructor with a specific attributed.

    To enforce this restriction, we made the argument of the Tpat_value constructor a private synonym of pattern, requiring you to use the as_computation_pattern function below instead of using the Tpat_value constructor directly.

    *)
  12. | Tpat_exception : value general_pattern -> computation pattern_desc
    (*

    exception P

    *)
  13. | Tpat_or : 'k general_pattern * 'k general_pattern * Types.row_desc option -> 'k pattern_desc
    (*

    P1 | P2

    row_desc = Some _ when translating Ppat_type _, None otherwise.

    *)
Sourceand tpat_value_argument = private value general_pattern
Sourceand expression = {
  1. exp_desc : expression_desc;
  2. exp_loc : Ocaml_parsing.Location.t;
  3. exp_extra : (exp_extra * Ocaml_parsing.Location.t * attributes) list;
  4. exp_type : Types.type_expr;
  5. exp_env : Env.t;
  6. exp_attributes : attributes;
}
Sourceand exp_extra =
  1. | Texp_constraint of core_type
    (*

    E : T

    *)
  2. | Texp_coerce of core_type option * core_type
    (*

    E :> T Texp_coerce (None, T) E : T0 :> T Texp_coerce (Some T0, T)

    *)
  3. | Texp_poly of core_type option
    (*

    Used for method bodies.

    *)
  4. | Texp_newtype of string
    (*

    fun (type t) ->

    *)
  5. | Texp_newtype' of Ident.t * Ocaml_parsing.Asttypes.label Ocaml_parsing.Asttypes.loc * Uid.t
    (*

    merlin-specific: keep enough information to correctly implement occurrences for local-types. Merlin typechecker uses Texp_newtype' constructor, while upstream OCaml still uses Texp_newtype. Those can appear when unmarshaling cmt files. By adding a new constructor, we can still safely uses these.

    *)
Sourceand expression_desc =
  1. | Texp_ident of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Types.value_description
    (*

    x M.x

    *)
  2. | Texp_constant of Ocaml_parsing.Asttypes.constant
    (*

    1, 'a', "true", 1.0, 1l, 1L, 1n

    *)
  3. | Texp_let of Ocaml_parsing.Asttypes.rec_flag * value_binding list * expression
    (*

    let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive) let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)

    *)
  4. | Texp_function of function_param list * function_body
    (*

    fun P0 P1 -> function p1 -> e1 | p2 -> e2 (body = Tfunction_cases _) fun P0 P1 -> E (body = Tfunction_body _)

    This construct has the same arity as the originating Pexp_function. Arity determines when side-effects for effectful parameters are run (e.g. optional argument defaults, matching against lazy patterns). Parameters' effects are run left-to-right when an n-ary function is saturated with n arguments.

    *)
  5. | Texp_apply of expression * (Ocaml_parsing.Asttypes.arg_label * expression option) list
    (*

    E0 ~l1:E1 ... ~ln:En

    The expression can be None if the expression is abstracted over this argument. It currently appears when a label is applied.

    For example: let f x ~y = x + y in f ~y:3

    The resulting typedtree for the application is: Texp_apply (Texp_ident "f/1037", (Nolabel, None); (Labelled "y", Some (Texp_constant Const_int 3)) )

    *)
  6. | Texp_match of expression * computation case list * partial
    (*

    match E0 with | P1 -> E1 | P2 | exception P3 -> E2 | exception P4 -> E3

    Texp_match (E0, [(P1, E1); (P2 | exception P3, E2); (exception P4, E3)], _)

    *)
  7. | Texp_try of expression * value case list
    (*

    try E with P1 -> E1 | ... | PN -> EN

    *)
  8. | Texp_tuple of expression list
    (*

    (E1, ..., EN)

    *)
  9. | Texp_construct of Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Types.constructor_description * expression list
    (*

    C C E E C (E1, ..., En) E1;...;En

    *)
  10. | Texp_variant of Ocaml_parsing.Asttypes.label * expression option
  11. | Texp_record of {
    1. fields : (Types.label_description * record_label_definition) array;
    2. representation : Types.record_representation;
    3. extended_expression : expression option;
    }
    (*

    l1=P1; ...; ln=Pn (extended_expression = None) E0 with l1=P1; ...; ln=Pn (extended_expression = Some E0)

    Invariant: n > 0

    If the type is l1: t1; l2: t2 , the expression E0 with t2=P2 is represented as Texp_record fields = [| l1, Kept t1; l2 Override P2 |]; representation; extended_expression = Some E0

    *)
  12. | Texp_field of expression * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Types.label_description
  13. | Texp_setfield of expression * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Types.label_description * expression
  14. | Texp_array of expression list
  15. | Texp_ifthenelse of expression * expression * expression option
  16. | Texp_sequence of expression * expression
  17. | Texp_while of expression * expression
  18. | Texp_for of Ident.t * Ocaml_parsing.Parsetree.pattern * expression * expression * Ocaml_parsing.Asttypes.direction_flag * expression
  19. | Texp_send of expression * meth
  20. | Texp_new of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Types.class_declaration
  21. | Texp_instvar of Path.t * Path.t * string Ocaml_parsing.Asttypes.loc
  22. | Texp_setinstvar of Path.t * Path.t * string Ocaml_parsing.Asttypes.loc * expression
  23. | Texp_override of Path.t * (Ident.t * string Ocaml_parsing.Asttypes.loc * expression) list
  24. | Texp_letmodule of Ident.t option * string option Ocaml_parsing.Asttypes.loc * Types.module_presence * module_expr * expression
  25. | Texp_letexception of extension_constructor * expression
  26. | Texp_assert of expression * Ocaml_parsing.Location.t
  27. | Texp_lazy of expression
  28. | Texp_object of class_structure * string list
  29. | Texp_pack of module_expr
  30. | Texp_letop of {
    1. let_ : binding_op;
    2. ands : binding_op list;
    3. param : Ident.t;
    4. body : value case;
    5. partial : partial;
    }
  31. | Texp_unreachable
  32. | Texp_extension_constructor of Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * Path.t
  33. | Texp_open of open_declaration * expression
    (*

    let open! M in e

    *)
  34. | Texp_hole
Sourceand meth =
  1. | Tmeth_name of string
  2. | Tmeth_val of Ident.t
  3. | Tmeth_ancestor of Ident.t * Path.t
Sourceand 'k case = {
  1. c_lhs : 'k general_pattern;
  2. c_guard : expression option;
  3. c_rhs : expression;
}
Sourceand function_param = {
  1. fp_arg_label : Ocaml_parsing.Asttypes.arg_label;
  2. fp_param : Ident.t;
    (*

    fp_param is the identifier that is to be used to name the parameter of the function.

    *)
  3. fp_partial : partial;
    (*

    fp_partial = Partial if the pattern match is partial Total otherwise.

    *)
  4. fp_kind : function_param_kind;
  5. fp_newtypes : string Ocaml_parsing.Asttypes.loc list;
    (*

    fp_newtypes are the new type declarations that come *after* that parameter. The newtypes that come before the first parameter are placed as exp_extras on the Texp_function node. This is just used in Untypeast.

    *)
  6. fp_loc : Ocaml_parsing.Location.t;
    (*

    fp_loc is the location of the entire value parameter, not including the fp_newtypes.

    *)
}
Sourceand function_param_kind =
  1. | Tparam_pat of pattern
    (*

    Tparam_pat p is a non-optional argument with pattern p.

    *)
  2. | Tparam_optional_default of pattern * expression
    (*

    Tparam_optional_default (p, e) is an optional argument p with default value e, i.e. ?x:(p = e). If the parameter is of type a option, the pattern and expression are of type a.

    *)
Sourceand function_body =
  1. | Tfunction_body of expression
  2. | Tfunction_cases of {
    1. cases : value case list;
    2. partial : partial;
    3. param : Ident.t;
    4. loc : Ocaml_parsing.Location.t;
    5. exp_extra : exp_extra option;
    6. attributes : attributes;
      (*

      attributes is just used in untypeast.

      *)
    }
    (*

    The function body binds a final argument in Tfunction_cases, and this argument is pattern-matched against the cases.

    *)
Sourceand binding_op = {
  1. bop_op_path : Path.t;
  2. bop_op_name : string Ocaml_parsing.Asttypes.loc;
  3. bop_op_val : Types.value_description;
  4. bop_op_type : Types.type_expr;
  5. bop_exp : expression;
  6. bop_loc : Ocaml_parsing.Location.t;
}
Sourceand class_expr = {
  1. cl_desc : class_expr_desc;
  2. cl_loc : Ocaml_parsing.Location.t;
  3. cl_type : Types.class_type;
  4. cl_env : Env.t;
  5. cl_attributes : attributes;
}
Sourceand class_expr_desc =
  1. | Tcl_ident of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * core_type list
  2. | Tcl_structure of class_structure
  3. | Tcl_fun of Ocaml_parsing.Asttypes.arg_label * pattern * (Ident.t * expression) list * class_expr * partial
  4. | Tcl_apply of class_expr * (Ocaml_parsing.Asttypes.arg_label * expression option) list
  5. | Tcl_let of Ocaml_parsing.Asttypes.rec_flag * value_binding list * (Ident.t * expression) list * class_expr
  6. | Tcl_constraint of class_expr * class_type option * string list * string list * Types.MethSet.t
  7. | Tcl_open of open_description * class_expr
Sourceand class_structure = {
  1. cstr_self : pattern;
  2. cstr_fields : class_field list;
  3. cstr_type : Types.class_signature;
  4. cstr_meths : Ident.t Types.Meths.t;
}
Sourceand class_field = {
  1. cf_desc : class_field_desc;
  2. cf_loc : Ocaml_parsing.Location.t;
  3. cf_attributes : attributes;
}
Sourceand class_field_kind =
  1. | Tcfk_virtual of core_type
  2. | Tcfk_concrete of Ocaml_parsing.Asttypes.override_flag * expression
Sourceand class_field_desc =
  1. | Tcf_inherit of Ocaml_parsing.Asttypes.override_flag * class_expr * string option * (string * Ident.t) list * (string * Ident.t) list
  2. | Tcf_val of string Ocaml_parsing.Asttypes.loc * Ocaml_parsing.Asttypes.mutable_flag * Ident.t * class_field_kind * bool
  3. | Tcf_method of string Ocaml_parsing.Asttypes.loc * Ocaml_parsing.Asttypes.private_flag * class_field_kind
  4. | Tcf_constraint of core_type * core_type
  5. | Tcf_initializer of expression
  6. | Tcf_attribute of attribute
Sourceand module_expr = {
  1. mod_desc : module_expr_desc;
  2. mod_loc : Ocaml_parsing.Location.t;
  3. mod_type : Types.module_type;
  4. mod_env : Env.t;
  5. mod_attributes : attributes;
}
Sourceand module_type_constraint =
  1. | Tmodtype_implicit
    (*

    The module type constraint has been synthesized during typechecking.

    *)
  2. | Tmodtype_explicit of module_type
    (*

    The module type was in the source file.

    *)

Annotations for Tmod_constraint.

Sourceand functor_parameter =
  1. | Unit
  2. | Named of Ident.t option * string option Ocaml_parsing.Asttypes.loc * module_type
Sourceand module_expr_desc =
  1. | Tmod_ident of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc
  2. | Tmod_structure of structure
  3. | Tmod_functor of functor_parameter * module_expr
  4. | Tmod_apply of module_expr * module_expr * module_coercion
  5. | Tmod_apply_unit of module_expr
  6. | Tmod_constraint of module_expr * Types.module_type * module_type_constraint * module_coercion
    (*

    ME (constraint = Tmodtype_implicit) (ME : MT) (constraint = Tmodtype_explicit MT)

    *)
  7. | Tmod_unpack of expression * Types.module_type
  8. | Tmod_hole
Sourceand structure = {
  1. str_items : structure_item list;
  2. str_type : Types.signature;
  3. str_final_env : Env.t;
}
Sourceand structure_item = {
  1. str_desc : structure_item_desc;
  2. str_loc : Ocaml_parsing.Location.t;
  3. str_env : Env.t;
}
Sourceand structure_item_desc =
  1. | Tstr_eval of expression * attributes
  2. | Tstr_value of Ocaml_parsing.Asttypes.rec_flag * value_binding list
  3. | Tstr_primitive of value_description
  4. | Tstr_type of Ocaml_parsing.Asttypes.rec_flag * type_declaration list
  5. | Tstr_typext of type_extension
  6. | Tstr_exception of type_exception
  7. | Tstr_module of module_binding
  8. | Tstr_recmodule of module_binding list
  9. | Tstr_modtype of module_type_declaration
  10. | Tstr_open of open_declaration
  11. | Tstr_class of (class_declaration * string list) list
  12. | Tstr_class_type of (Ident.t * string Ocaml_parsing.Asttypes.loc * class_type_declaration) list
  13. | Tstr_include of include_declaration
  14. | Tstr_attribute of attribute
Sourceand module_binding = {
  1. mb_id : Ident.t option;
    (*

    None for module _ = struct ... end

    *)
  2. mb_name : string option Ocaml_parsing.Asttypes.loc;
  3. mb_uid : Uid.t;
  4. mb_presence : Types.module_presence;
  5. mb_expr : module_expr;
  6. mb_attributes : attributes;
  7. mb_loc : Ocaml_parsing.Location.t;
}
Sourceand value_binding = {
  1. vb_pat : pattern;
  2. vb_expr : expression;
  3. vb_rec_kind : Value_rec_types.recursive_binding_kind;
  4. vb_attributes : attributes;
  5. vb_loc : Ocaml_parsing.Location.t;
}
Sourceand module_coercion =
  1. | Tcoerce_none
  2. | Tcoerce_structure of (int * module_coercion) list * (Ident.t * int * module_coercion) list
  3. | Tcoerce_functor of module_coercion * module_coercion
  4. | Tcoerce_primitive of primitive_coercion
    (*

    External declaration coerced to a regular value.

      module M : sig val ext : a -> b end =
  struct external ext : a -> b = "my_c_function" end

    Only occurs inside a Tcoerce_structure coercion.

    *)
  5. | Tcoerce_alias of Env.t * Path.t * module_coercion
    (*

    Module alias coerced to a regular module.

      module M : sig module Sub : T end =
  struct module Sub = Some_alias end

    Only occurs inside a Tcoerce_structure coercion.

    *)
Sourceand module_type = {
  1. mty_desc : module_type_desc;
  2. mty_type : Types.module_type;
  3. mty_env : Env.t;
  4. mty_loc : Ocaml_parsing.Location.t;
  5. mty_attributes : attributes;
}
Sourceand primitive_coercion = {
  1. pc_desc : Primitive.description;
  2. pc_type : Types.type_expr;
  3. pc_env : Env.t;
  4. pc_loc : Ocaml_parsing.Location.t;
}
Sourceand signature = {
  1. sig_items : signature_item list;
  2. sig_type : Types.signature;
  3. sig_final_env : Env.t;
}
Sourceand signature_item = {
  1. sig_desc : signature_item_desc;
  2. sig_env : Env.t;
  3. sig_loc : Ocaml_parsing.Location.t;
}
Sourceand signature_item_desc =
  1. | Tsig_value of value_description
  2. | Tsig_type of Ocaml_parsing.Asttypes.rec_flag * type_declaration list
  3. | Tsig_typesubst of type_declaration list
  4. | Tsig_typext of type_extension
  5. | Tsig_exception of type_exception
  6. | Tsig_module of module_declaration
  7. | Tsig_modsubst of module_substitution
  8. | Tsig_recmodule of module_declaration list
  9. | Tsig_modtype of module_type_declaration
  10. | Tsig_modtypesubst of module_type_declaration
  11. | Tsig_open of open_description
  12. | Tsig_include of include_description
  13. | Tsig_class of class_description list
  14. | Tsig_class_type of class_type_declaration list
  15. | Tsig_attribute of attribute
Sourceand module_declaration = {
  1. md_id : Ident.t option;
  2. md_name : string option Ocaml_parsing.Asttypes.loc;
  3. md_uid : Uid.t;
  4. md_presence : Types.module_presence;
  5. md_type : module_type;
  6. md_attributes : attributes;
  7. md_loc : Ocaml_parsing.Location.t;
}
Sourceand module_substitution = {
  1. ms_id : Ident.t;
  2. ms_name : string Ocaml_parsing.Asttypes.loc;
  3. ms_uid : Uid.t;
  4. ms_manifest : Path.t;
  5. ms_txt : Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc;
  6. ms_attributes : attributes;
  7. ms_loc : Ocaml_parsing.Location.t;
}
Sourceand module_type_declaration = {
  1. mtd_id : Ident.t;
  2. mtd_name : string Ocaml_parsing.Asttypes.loc;
  3. mtd_uid : Uid.t;
  4. mtd_type : module_type option;
  5. mtd_attributes : attributes;
  6. mtd_loc : Ocaml_parsing.Location.t;
}
Sourceand 'a open_infos = {
  1. open_expr : 'a;
  2. open_bound_items : Types.signature;
  3. open_override : Ocaml_parsing.Asttypes.override_flag;
  4. open_env : Env.t;
  5. open_loc : Ocaml_parsing.Location.t;
  6. open_attributes : attribute list;
}
Sourceand open_declaration = module_expr open_infos
Sourceand 'a include_infos = {
  1. incl_mod : 'a;
  2. incl_type : Types.signature;
  3. incl_loc : Ocaml_parsing.Location.t;
  4. incl_attributes : attribute list;
}
Sourceand include_description = module_type include_infos
Sourceand include_declaration = module_expr include_infos
Sourceand with_constraint =
  1. | Twith_type of type_declaration
  2. | Twith_module of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc
  3. | Twith_modtype of module_type
  4. | Twith_typesubst of type_declaration
  5. | Twith_modsubst of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc
  6. | Twith_modtypesubst of module_type
Sourceand core_type = {
  1. mutable ctyp_desc : core_type_desc;
    (*

    mutable because of Typeclass.declare_method

    *)
  2. mutable ctyp_type : Types.type_expr;
    (*

    mutable because of Typeclass.declare_method

    *)
  3. ctyp_env : Env.t;
  4. ctyp_loc : Ocaml_parsing.Location.t;
  5. ctyp_attributes : attributes;
}
Sourceand core_type_desc =
  1. | Ttyp_any
  2. | Ttyp_var of string
  3. | Ttyp_arrow of Ocaml_parsing.Asttypes.arg_label * core_type * core_type
  4. | Ttyp_tuple of core_type list
  5. | Ttyp_constr of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * core_type list
  6. | Ttyp_object of object_field list * Ocaml_parsing.Asttypes.closed_flag
  7. | Ttyp_class of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * core_type list
  8. | Ttyp_alias of core_type * string Ocaml_parsing.Asttypes.loc
  9. | Ttyp_variant of row_field list * Ocaml_parsing.Asttypes.closed_flag * Ocaml_parsing.Asttypes.label list option
  10. | Ttyp_poly of string list * core_type
  11. | Ttyp_package of package_type
  12. | Ttyp_open of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * core_type
Sourceand row_field = {
  1. rf_desc : row_field_desc;
  2. rf_loc : Ocaml_parsing.Location.t;
  3. rf_attributes : attributes;
}
Sourceand row_field_desc =
  1. | Ttag of string Ocaml_parsing.Asttypes.loc * bool * core_type list
  2. | Tinherit of core_type
Sourceand object_field = {
  1. of_desc : object_field_desc;
  2. of_loc : Ocaml_parsing.Location.t;
  3. of_attributes : attributes;
}
Sourceand object_field_desc =
  1. | OTtag of string Ocaml_parsing.Asttypes.loc * core_type
  2. | OTinherit of core_type
Sourceand value_description = {
  1. val_id : Ident.t;
  2. val_name : string Ocaml_parsing.Asttypes.loc;
  3. val_desc : core_type;
  4. val_val : Types.value_description;
  5. val_prim : string list;
  6. val_loc : Ocaml_parsing.Location.t;
  7. val_attributes : attributes;
}
Sourceand type_declaration = {
  1. typ_id : Ident.t;
  2. typ_name : string Ocaml_parsing.Asttypes.loc;
  3. typ_params : (core_type * (Ocaml_parsing.Asttypes.variance * Ocaml_parsing.Asttypes.injectivity)) list;
  4. typ_type : Types.type_declaration;
  5. typ_cstrs : (core_type * core_type * Ocaml_parsing.Location.t) list;
  6. typ_kind : type_kind;
  7. typ_private : Ocaml_parsing.Asttypes.private_flag;
  8. typ_manifest : core_type option;
  9. typ_loc : Ocaml_parsing.Location.t;
  10. typ_attributes : attributes;
}
Sourceand type_kind =
  1. | Ttype_abstract
  2. | Ttype_variant of constructor_declaration list
  3. | Ttype_record of label_declaration list
  4. | Ttype_open
Sourceand label_declaration = {
  1. ld_id : Ident.t;
  2. ld_name : string Ocaml_parsing.Asttypes.loc;
  3. ld_uid : Uid.t;
  4. ld_mutable : Ocaml_parsing.Asttypes.mutable_flag;
  5. ld_type : core_type;
  6. ld_loc : Ocaml_parsing.Location.t;
  7. ld_attributes : attributes;
}
Sourceand constructor_declaration = {
  1. cd_id : Ident.t;
  2. cd_name : string Ocaml_parsing.Asttypes.loc;
  3. cd_uid : Uid.t;
  4. cd_vars : string Ocaml_parsing.Asttypes.loc list;
  5. cd_args : constructor_arguments;
  6. cd_res : core_type option;
  7. cd_loc : Ocaml_parsing.Location.t;
  8. cd_attributes : attributes;
}
Sourceand constructor_arguments =
  1. | Cstr_tuple of core_type list
  2. | Cstr_record of label_declaration list
Sourceand type_extension = {
  1. tyext_path : Path.t;
  2. tyext_txt : Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc;
  3. tyext_params : (core_type * (Ocaml_parsing.Asttypes.variance * Ocaml_parsing.Asttypes.injectivity)) list;
  4. tyext_constructors : extension_constructor list;
  5. tyext_private : Ocaml_parsing.Asttypes.private_flag;
  6. tyext_loc : Ocaml_parsing.Location.t;
  7. tyext_attributes : attributes;
}
Sourceand type_exception = {
  1. tyexn_constructor : extension_constructor;
  2. tyexn_loc : Ocaml_parsing.Location.t;
  3. tyexn_attributes : attribute list;
}
Sourceand extension_constructor = {
  1. ext_id : Ident.t;
  2. ext_name : string Ocaml_parsing.Asttypes.loc;
  3. ext_type : Types.extension_constructor;
  4. ext_kind : extension_constructor_kind;
  5. ext_loc : Ocaml_parsing.Location.t;
  6. ext_attributes : attributes;
}
Sourceand extension_constructor_kind =
  1. | Text_decl of string Ocaml_parsing.Asttypes.loc list * constructor_arguments * core_type option
  2. | Text_rebind of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc
Sourceand class_type = {
  1. cltyp_desc : class_type_desc;
  2. cltyp_type : Types.class_type;
  3. cltyp_env : Env.t;
  4. cltyp_loc : Ocaml_parsing.Location.t;
  5. cltyp_attributes : attributes;
}
Sourceand class_type_desc =
  1. | Tcty_constr of Path.t * Ocaml_parsing.Longident.t Ocaml_parsing.Asttypes.loc * core_type list
  2. | Tcty_signature of class_signature
  3. | Tcty_arrow of Ocaml_parsing.Asttypes.arg_label * core_type * class_type
  4. | Tcty_open of open_description * class_type
Sourceand class_signature = {
  1. csig_self : core_type;
  2. csig_fields : class_type_field list;
  3. csig_type : Types.class_signature;
}
Sourceand class_type_field = {
  1. ctf_desc : class_type_field_desc;
  2. ctf_loc : Ocaml_parsing.Location.t;
  3. ctf_attributes : attributes;
}
Sourceand class_type_field_desc =
  1. | Tctf_inherit of class_type
  2. | Tctf_val of string * Ocaml_parsing.Asttypes.mutable_flag * Ocaml_parsing.Asttypes.virtual_flag * core_type
  3. | Tctf_method of string * Ocaml_parsing.Asttypes.private_flag * Ocaml_parsing.Asttypes.virtual_flag * core_type
  4. | Tctf_constraint of core_type * core_type
  5. | Tctf_attribute of attribute
Sourceand class_declaration = class_expr class_infos
Sourceand class_description = class_type class_infos
Sourceand class_type_declaration = class_type class_infos
Sourceand 'a class_infos = {
  1. ci_virt : Ocaml_parsing.Asttypes.virtual_flag;
  2. ci_params : (core_type * (Ocaml_parsing.Asttypes.variance * Ocaml_parsing.Asttypes.injectivity)) list;
  3. ci_id_name : string Ocaml_parsing.Asttypes.loc;
  4. ci_id_class : Ident.t;
  5. ci_id_class_type : Ident.t;
  6. ci_id_object : Ident.t;
  7. ci_expr : 'a;
  8. ci_decl : Types.class_declaration;
  9. ci_type_decl : Types.class_type_declaration;
  10. ci_loc : Ocaml_parsing.Location.t;
  11. ci_attributes : attributes;
}
Sourcetype implementation = {
  1. structure : structure;
  2. coercion : module_coercion;
  3. signature : Types.signature;
  4. shape : Shape.t;
}

A typechecked implementation including its module structure, its exported signature, and a coercion of the module against that signature.

If an .mli file is present, the signature will come from that file and be the exported signature of the module.

If there isn't one, the signature will be inferred from the module structure.

Sourcetype item_declaration =
  1. | Value of value_description
  2. | Value_binding of value_binding
  3. | Type of type_declaration
  4. | Constructor of constructor_declaration
  5. | Extension_constructor of extension_constructor
  6. | Label of label_declaration
  7. | Module of module_declaration
  8. | Module_substitution of module_substitution
  9. | Module_binding of module_binding
  10. | Module_type of module_type_declaration
  11. | Class of class_declaration
  12. | Class_type of class_type_declaration
    (*

    item_declaration groups together items that correspond to the syntactic category of "declarations" which include types, values, modules, etc. declarations in signatures and their definitions in implementations.

    *)
Sourceval as_computation_pattern : pattern -> computation general_pattern

as_computation_pattern p is a computation pattern with description Tpat_value p, which enforces a correct placement of pat_attributes and pat_extra metadata (on the inner value pattern, rather than on the computation pattern).

Sourceval classify_pattern_desc : 'k pattern_desc -> 'k pattern_category
Sourceval classify_pattern : 'k general_pattern -> 'k pattern_category
Sourcetype pattern_action = {
  1. f : 'k. 'k general_pattern -> unit;
}
Sourceval shallow_iter_pattern_desc : pattern_action -> 'k pattern_desc -> unit
Sourcetype pattern_transformation = {
  1. f : 'k. 'k general_pattern -> 'k general_pattern;
}
Sourceval shallow_map_pattern_desc : pattern_transformation -> 'k pattern_desc -> 'k pattern_desc
Sourceval iter_general_pattern : pattern_action -> 'k general_pattern -> unit
Sourceval iter_pattern : (pattern -> unit) -> pattern -> unit
Sourcetype pattern_predicate = {
  1. f : 'k. 'k general_pattern -> bool;
}
Sourceval exists_general_pattern : pattern_predicate -> 'k general_pattern -> bool
Sourceval exists_pattern : (pattern -> bool) -> pattern -> bool
Sourceval let_bound_idents : value_binding list -> Ident.t list
Sourceval alpha_pat : (Ident.t * Ident.t) list -> 'k general_pattern -> 'k general_pattern

Alpha conversion of patterns

Sourceval mknoloc : 'a -> 'a Ocaml_parsing.Asttypes.loc
Sourceval pat_bound_idents : 'k general_pattern -> Ident.t list
Sourceval split_pattern : computation general_pattern -> pattern option * pattern option

Splits an or pattern into its value (left) and exception (right) parts.

Sourceval exp_is_nominal : expression -> bool

Whether an expression looks nice as the subject of a sentence in a error message.

Sourceval unpack_functor_me : module_expr -> functor_parameter * module_expr
Sourceval unpack_functor_mty : module_type -> functor_parameter * module_type