package camlp4

  1. Overview
  2. Docs
package camlp4
Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

Signature

module Loc : sig ... end
module Ast : sig ... end
module Token : sig ... end
module Gram : sig ... end
module Quotation : sig ... end
module AntiquotSyntax : sig ... end
type warning = Loc.t -> string -> unit
val default_warning : warning
val current_warning : warning Pervasives.ref
val print_warning : warning
val parse_implem : ?directive_handler:(Ast.str_item -> Ast.str_item option) -> Ast.loc -> char Stream.t -> Ast.str_item
val parse_interf : ?directive_handler:(Ast.sig_item -> Ast.sig_item option) -> Ast.loc -> char Stream.t -> Ast.sig_item
val print_interf : ?input_file:string -> ?output_file:string -> Ast.sig_item -> unit
val print_implem : ?input_file:string -> ?output_file:string -> Ast.str_item -> unit
val interf : (Ast.sig_item list * Loc.t option) Gram.Entry.t
val implem : (Ast.str_item list * Loc.t option) Gram.Entry.t
val top_phrase : Ast.str_item option Gram.Entry.t
val use_file : (Ast.str_item list * Loc.t option) Gram.Entry.t
val a_CHAR : string Gram.Entry.t
val a_FLOAT : string Gram.Entry.t
val a_INT : string Gram.Entry.t
val a_INT32 : string Gram.Entry.t
val a_INT64 : string Gram.Entry.t
val a_LABEL : string Gram.Entry.t
val a_LIDENT : string Gram.Entry.t
val a_NATIVEINT : string Gram.Entry.t
val a_OPTLABEL : string Gram.Entry.t
val a_STRING : string Gram.Entry.t
val a_UIDENT : string Gram.Entry.t
val a_ident : string Gram.Entry.t
val amp_ctyp : Ast.ctyp Gram.Entry.t
val and_ctyp : Ast.ctyp Gram.Entry.t
val match_case : Ast.match_case Gram.Entry.t
val match_case0 : Ast.match_case Gram.Entry.t
val match_case_quot : Ast.match_case Gram.Entry.t
val binding_quot : Ast.binding Gram.Entry.t
val rec_binding_quot : Ast.rec_binding Gram.Entry.t
val class_declaration : Ast.class_expr Gram.Entry.t
val class_description : Ast.class_type Gram.Entry.t
val class_expr : Ast.class_expr Gram.Entry.t
val class_expr_quot : Ast.class_expr Gram.Entry.t
val class_fun_binding : Ast.class_expr Gram.Entry.t
val class_fun_def : Ast.class_expr Gram.Entry.t
val class_info_for_class_expr : Ast.class_expr Gram.Entry.t
val class_info_for_class_type : Ast.class_type Gram.Entry.t
val class_longident : Ast.ident Gram.Entry.t
val class_longident_and_param : Ast.class_expr Gram.Entry.t
val class_name_and_param : (string * Ast.ctyp) Gram.Entry.t
val class_sig_item : Ast.class_sig_item Gram.Entry.t
val class_sig_item_quot : Ast.class_sig_item Gram.Entry.t
val class_signature : Ast.class_sig_item Gram.Entry.t
val class_str_item : Ast.class_str_item Gram.Entry.t
val class_str_item_quot : Ast.class_str_item Gram.Entry.t
val class_structure : Ast.class_str_item Gram.Entry.t
val class_type : Ast.class_type Gram.Entry.t
val class_type_declaration : Ast.class_type Gram.Entry.t
val class_type_longident : Ast.ident Gram.Entry.t
val class_type_longident_and_param : Ast.class_type Gram.Entry.t
val class_type_plus : Ast.class_type Gram.Entry.t
val class_type_quot : Ast.class_type Gram.Entry.t
val comma_ctyp : Ast.ctyp Gram.Entry.t
val comma_expr : Ast.expr Gram.Entry.t
val comma_ipatt : Ast.patt Gram.Entry.t
val comma_patt : Ast.patt Gram.Entry.t
val comma_type_parameter : Ast.ctyp Gram.Entry.t
val constrain : (Ast.ctyp * Ast.ctyp) Gram.Entry.t
val constructor_arg_list : Ast.ctyp Gram.Entry.t
val constructor_declaration : Ast.ctyp Gram.Entry.t
val constructor_declarations : Ast.ctyp Gram.Entry.t
val ctyp_quot : Ast.ctyp Gram.Entry.t
val cvalue_binding : Ast.expr Gram.Entry.t
val direction_flag : Ast.direction_flag Gram.Entry.t
val direction_flag_quot : Ast.direction_flag Gram.Entry.t
val dummy : unit Gram.Entry.t
val eq_expr : (string -> Ast.patt -> Ast.patt) Gram.Entry.t
val expr_eoi : Ast.expr Gram.Entry.t
val expr_quot : Ast.expr Gram.Entry.t
val field_expr : Ast.rec_binding Gram.Entry.t
val field_expr_list : Ast.rec_binding Gram.Entry.t
val fun_binding : Ast.expr Gram.Entry.t
val fun_def : Ast.expr Gram.Entry.t
val ident_quot : Ast.ident Gram.Entry.t
val ipatt_tcon : Ast.patt Gram.Entry.t
val label : string Gram.Entry.t
val label_declaration : Ast.ctyp Gram.Entry.t
val label_declaration_list : Ast.ctyp Gram.Entry.t
val label_expr : Ast.rec_binding Gram.Entry.t
val label_expr_list : Ast.rec_binding Gram.Entry.t
val label_ipatt : Ast.patt Gram.Entry.t
val label_ipatt_list : Ast.patt Gram.Entry.t
val label_longident : Ast.ident Gram.Entry.t
val label_patt : Ast.patt Gram.Entry.t
val label_patt_list : Ast.patt Gram.Entry.t
val labeled_ipatt : Ast.patt Gram.Entry.t
val let_binding : Ast.binding Gram.Entry.t
val meth_decl : Ast.ctyp Gram.Entry.t
val module_binding : Ast.module_binding Gram.Entry.t
val module_binding0 : Ast.module_expr Gram.Entry.t
val module_binding_quot : Ast.module_binding Gram.Entry.t
val module_declaration : Ast.module_type Gram.Entry.t
val module_expr : Ast.module_expr Gram.Entry.t
val module_expr_quot : Ast.module_expr Gram.Entry.t
val module_longident : Ast.ident Gram.Entry.t
val module_longident_with_app : Ast.ident Gram.Entry.t
val module_rec_declaration : Ast.module_binding Gram.Entry.t
val module_type : Ast.module_type Gram.Entry.t
val package_type : Ast.module_type Gram.Entry.t
val module_type_quot : Ast.module_type Gram.Entry.t
val more_ctyp : Ast.ctyp Gram.Entry.t
val name_tags : Ast.ctyp Gram.Entry.t
val opt_as_lident : string Gram.Entry.t
val opt_class_self_patt : Ast.patt Gram.Entry.t
val opt_class_self_type : Ast.ctyp Gram.Entry.t
val opt_comma_ctyp : Ast.ctyp Gram.Entry.t
val opt_dot_dot : Ast.row_var_flag Gram.Entry.t
val row_var_flag_quot : Ast.row_var_flag Gram.Entry.t
val opt_eq_ctyp : Ast.ctyp Gram.Entry.t
val opt_expr : Ast.expr Gram.Entry.t
val opt_meth_list : Ast.ctyp Gram.Entry.t
val opt_mutable : Ast.mutable_flag Gram.Entry.t
val mutable_flag_quot : Ast.mutable_flag Gram.Entry.t
val opt_override : Ast.override_flag Gram.Entry.t
val override_flag_quot : Ast.override_flag Gram.Entry.t
val opt_polyt : Ast.ctyp Gram.Entry.t
val opt_private : Ast.private_flag Gram.Entry.t
val private_flag_quot : Ast.private_flag Gram.Entry.t
val opt_nonrec : Ast.rec_flag Gram.Entry.t
val rec_flag_quot : Ast.rec_flag Gram.Entry.t
val opt_virtual : Ast.virtual_flag Gram.Entry.t
val virtual_flag_quot : Ast.virtual_flag Gram.Entry.t
val opt_when_expr : Ast.expr Gram.Entry.t
val patt_as_patt_opt : Ast.patt Gram.Entry.t
val patt_eoi : Ast.patt Gram.Entry.t
val patt_quot : Ast.patt Gram.Entry.t
val patt_tcon : Ast.patt Gram.Entry.t
val poly_type : Ast.ctyp Gram.Entry.t
val row_field : Ast.ctyp Gram.Entry.t
val sem_expr : Ast.expr Gram.Entry.t
val sem_expr_for_list : (Ast.expr -> Ast.expr) Gram.Entry.t
val sem_patt : Ast.patt Gram.Entry.t
val sem_patt_for_list : (Ast.patt -> Ast.patt) Gram.Entry.t
val semi : unit Gram.Entry.t
val sequence : Ast.expr Gram.Entry.t
val do_sequence : Ast.expr Gram.Entry.t
val sig_item : Ast.sig_item Gram.Entry.t
val sig_item_quot : Ast.sig_item Gram.Entry.t
val sig_items : Ast.sig_item Gram.Entry.t
val star_ctyp : Ast.ctyp Gram.Entry.t
val str_item : Ast.str_item Gram.Entry.t
val str_item_quot : Ast.str_item Gram.Entry.t
val str_items : Ast.str_item Gram.Entry.t
val type_constraint : unit Gram.Entry.t
val type_declaration : Ast.ctyp Gram.Entry.t
val type_ident_and_parameters : (Ast.ident * Ast.ctyp list) Gram.Entry.t
val type_kind : Ast.ctyp Gram.Entry.t
val type_longident : Ast.ident Gram.Entry.t
val type_longident_and_parameters : Ast.ctyp Gram.Entry.t
val type_parameter : Ast.ctyp Gram.Entry.t
val type_parameters : (Ast.ctyp -> Ast.ctyp) Gram.Entry.t
val typevars : Ast.ctyp Gram.Entry.t
val val_longident : Ast.ident Gram.Entry.t
val value_let : unit Gram.Entry.t
val value_val : unit Gram.Entry.t
val with_constr : Ast.with_constr Gram.Entry.t
val with_constr_quot : Ast.with_constr Gram.Entry.t
val prefixop : Ast.expr Gram.Entry.t
val infixop0 : Ast.expr Gram.Entry.t
val infixop1 : Ast.expr Gram.Entry.t
val infixop2 : Ast.expr Gram.Entry.t
val infixop3 : Ast.expr Gram.Entry.t
val infixop4 : Ast.expr Gram.Entry.t
module MetaLoc = Ast.Meta.MetaGhostLoc
module MetaAst : sig ... end
module PP : sig ... end
val pp : PP.printer
val string_of_patt : PP.Ast.patt -> string
val split_ext : bool Pervasives.ref
type loc = Loc.t
type !'e name = {
  1. expr : 'e;
  2. tvar : string;
  3. loc : loc;
}
type styp =
  1. | STlid of loc * string
  2. | STapp of loc * styp * styp
  3. | STquo of loc * string
  4. | STself of loc * string
  5. | STtok of loc
  6. | STstring_tok of loc
  7. | STtyp of Ast.ctyp
type (!'e, !'p) text =
  1. | TXmeta of loc * string * ('e, 'p) text list * 'e * styp
  2. | TXlist of loc * bool * ('e, 'p) symbol * ('e, 'p) symbol option
  3. | TXnext of loc
  4. | TXnterm of loc * 'e name * string option
  5. | TXopt of loc * ('e, 'p) text
  6. | TXtry of loc * ('e, 'p) text
  7. | TXrules of loc * (('e, 'p) text list * 'e) list
  8. | TXself of loc
  9. | TXkwd of loc * string
  10. | TXtok of loc * 'e * string
and (!'e, !'p) entry = {
  1. name : 'e name;
  2. pos : 'e option;
  3. levels : ('e, 'p) level list;
}
and (!'e, !'p) level = {
  1. label : string option;
  2. assoc : 'e option;
  3. rules : ('e, 'p) rule list;
}
and (!'e, !'p) rule = {
  1. prod : ('e, 'p) symbol list;
  2. action : 'e option;
}
and (!'e, !'p) symbol = {
  1. used : string list;
  2. text : ('e, 'p) text;
  3. styp : styp;
  4. pattern : 'p option;
}
type used =
  1. | Unused
  2. | UsedScanned
  3. | UsedNotScanned
val _loc : Loc.t
val gm : string
val mark_used : bool Pervasives.ref -> ('a, used Pervasives.ref * 'b) Hashtbl.t -> 'a -> unit
val mark_symbol : bool Pervasives.ref -> (string, used Pervasives.ref * 'a) Hashtbl.t -> ('b, 'c) symbol -> unit
val check_use : 'a name list -> (Ast.expr, 'b) entry list -> unit
val new_type_var : unit -> string
val used_of_rule_list : ('a, 'b) rule list -> string list
val retype_rule_list_without_patterns : Ast.loc -> (Ast.expr, Ast.patt) rule list -> (Ast.expr, Ast.patt) rule list
val meta_action : bool Pervasives.ref
val mklistexp : Ast.loc -> Ast.expr list -> Ast.expr
val mklistpat : Ast.loc -> Ast.patt list -> Ast.patt
val expr_fa : Ast.expr list -> Ast.expr -> Ast.expr * Ast.expr list
val make_ctyp : styp -> string -> Ast.ctyp
val make_ctyp_patt : styp -> string -> Ast.patt -> Ast.patt
val make_ctyp_expr : styp -> string -> Ast.expr -> Ast.expr
val text_of_action : Ast.loc -> ('a, Ast.patt) symbol list -> string -> Ast.expr option -> string -> Ast.expr
val srules : Ast.loc -> string -> (Ast.expr, Ast.patt) rule list -> string -> ((Ast.expr, Ast.patt) text list * Ast.expr) list
val make_expr : Ast.expr name -> string -> (Ast.expr, 'a) text -> Ast.expr
val make_expr_rules : loc -> Ast.expr name -> ((Ast.expr, 'a) text list * Ast.expr) list -> string -> Ast.expr
val expr_of_delete_rule : Ast.loc -> Ast.expr name -> (Ast.expr, 'a) symbol list -> Ast.expr * Ast.expr
val tvar_of_ident : Ast.ident -> string
val mk_name : Ast.loc -> Ast.ident -> Ast.expr name
val slist : loc -> bool -> ('a, 'b) symbol option -> ('a, 'b) symbol -> ('a, 'b) text
val text_of_entry : Ast.loc -> (Ast.expr, Ast.patt) entry -> Ast.expr * Ast.expr * Ast.expr
val let_in_of_extend : Ast.loc -> Ast.ident option -> Ast.expr name list option -> (Ast.expr, 'a) entry list -> Ast.expr -> Ast.expr
class subst : Ast.ident -> object ... end
val subst_gmod : Ast.expr -> Ast.ident -> Ast.expr
val text_of_functorial_extend : Ast.loc -> Ast.ident -> Ast.ident option -> Ast.expr name list option -> (Ast.expr, Ast.patt) entry list -> Ast.expr
val wildcarder : Ast.map
val mk_tok : Ast.loc -> Ast.patt -> styp -> (Ast.expr, Ast.patt) symbol
val check_not_tok : ('a, 'b) symbol -> unit
val sfold : loc -> string -> string -> Ast.expr -> Ast.expr -> (Ast.expr, 'a) symbol -> (Ast.expr, 'a) symbol
val sfoldsep : loc -> string -> string -> Ast.expr -> Ast.expr -> (Ast.expr, 'a) symbol -> (Ast.expr, 'a) symbol -> (Ast.expr, 'a) symbol
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct