Up

module Pa_type_conv

: sig

Pa_type_conv: Preprocessing Module for Registering Type Conversions

Generator registration
#
val set_conv_path_if_not_set : Camlp4.PreCast.Ast.Loc.t -> unit

set_conv_path_if_not_set loc sets the path to the file/module being converted for improved error messages.

#
val get_conv_path : unit -> string

get_conv_path ()

Returns the name to module containing a type as required for error messages.
#
val add_generator : ?is_exn:bool -> string -> (bool -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.str_item) -> unit

add_generator ?is_exn name gen adds the code generator gen, which maps type or exception declarations to structure items, where is_exn specifies whether the declaration is an exception. Note that the original type/exception declarations get added automatically in any case.

is_exn = false
#
val add_generator_with_arg : ?is_exn:bool -> string -> 'a Camlp4.PreCast.Gram.Entry.t -> ('a option -> bool -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.str_item) -> unit

add_generator_with_arg ?is_exn name entry generator same as add_generator, but the generator may accept an argument, which is parsed with entry.

#
val rm_generator : ?is_exn:bool -> string -> unit

rm_generator ?is_exn name removes the code generator named name for types if is_exn is false, or exceptions otherwise.

is_exn = false
#
val add_sig_generator : ?delayed:bool -> ?is_exn:bool -> string -> (bool -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.sig_item) -> unit

add_sig_generator ?delayed ?is_exn name gen adds the code generator gen, which maps type or exception declarations to signature items, where is_exn specifies whether the declaration is an exception. Note that the original type/exception declarations get added automatically in any case. If delayed is set to true, the output of this generator is appended to the signature in which it's defined

delayed = false
is_exn = false
#
val add_sig_generator_with_arg : ?delayed:bool -> ?is_exn:bool -> string -> 'a Camlp4.PreCast.Gram.Entry.t -> ('a option -> bool -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.sig_item) -> unit

add_sig_generator_with_arg ?delayed ?is_exn name entry generator same as add_sig_generator, but the generator may accept an argument, which is parsed with entry.

#
val rm_sig_generator : ?is_exn:bool -> string -> unit

rm_sig_generator ?is_exn name removes the signature code generator named name for types if is_exn is false, or exceptions otherwise.

is_exn = false
#
type record_field_generator = Camlp4.PreCast.Ast.ctyp -> unit

Type of record field code generators

#
val add_record_field_generator : string -> record_field_generator -> unit

add_record_field_generator gen_name gen adds the record field code generator gen with name gen_name, which acts on the location identifying the record field.

#
val add_record_field_generator_with_arg : string -> 'a Camlp4.PreCast.Gram.Entry.t -> ('a option -> record_field_generator) -> unit

add_record_field_generator_with_arg name entry generator same as add_record_field_generator, but the generator takes an argument, which is parsed with entry. If None is passed to the generator, parsing of the argument failed, otherwise Some arg will be passed, where arg is the successfully parsed argument.

#
val rm_record_field_generator : string -> unit

rm_record_field_generator name removes the record field code generator named name.

Generator sets registration
#
val add_sig_set : ?is_exn:bool -> string -> set:string list -> unit

add_sig_set ?is_exn id ~set adds the generator id to the list of generators for signatures. This generator will behave as if is all the generators from set had been given instead. Any duplicate arising from repeatedly expanding such generators are removed. If is_exn, then it is a generator for exception declaration, or else it is a generator for type declaration.

#
val add_str_set : ?is_exn:bool -> string -> set:string list -> unit

add_str_set ?is_exn id ~set behaves exactly like add_sig_set ?is_exn id ~set but for structure items instead of signatures items.

#
val add_set : kind:[
| `Str
| `Sig
| `Both
] -> is_exn:[
| `Yes
| `No
| `Both
] -> string -> set:string list -> unit

add_set ~kind ~is_exn id ~set is a shorthand for doing multiple calls to add_str_set and add_sig_set

Utility functions
#
val get_loc_err : Camlp4.PreCast.Ast.Loc.t -> string -> string

get_loc_err loc msg generates a compile-time error message.

#
val hash_variant : string -> int

hash_variant str

Returns the integer encoding a variant tag with name str.
General purpose code generation module
#
module Gen : sig
#
val regular_constr_of_revised_constr : string -> string
#
val exApp_of_list : Camlp4.PreCast.Ast.expr list -> Camlp4.PreCast.Ast.expr

expr_app_of_list l takes list l of expressions e1; e2; e3; ... and returns the expression e1 e2 e3. C.f.: Ast.exSem_of_list.

#
val tyArr_of_list : Camlp4.PreCast.Ast.ctyp list -> Camlp4.PreCast.Ast.ctyp

tyArr_of_list l takes list l of types e1; e2; e3; ... and returns the type e1 -> e2 -> e3. C.f.: Ast.exSem_of_list.

#
val paOr_of_list : Camlp4.PreCast.Ast.patt list -> Camlp4.PreCast.Ast.patt

paOr_of_list l takes list l of patterns p1; p2; p3; ... and returns the pattern p1 | p2 | p3 | ...

#
val gensym : ?prefix:string -> unit -> string

gensym ?prefix () generates a fresh variable name with prefix. When used with the default parameters, it will return: _x__001, _x__002, _x__003, ...

prefix default = "_x"
#
val error : Camlp4.PreCast.Ast.ctyp -> fn:string -> msg:string -> _

error tp ~fn ~msg raises an error with msg on type tp occuring in function fn.

#
val unknown_type : Camlp4.PreCast.Ast.ctyp -> string -> _

unknown_type tp fn type tp cannot be handled by function fn.

#
val ty_var_list_of_ctyp : Camlp4.PreCast.Ast.ctyp -> string list -> string list

ty_var_list_of_ctyp tp acc accumulates a list of type parameters contained in tp into acc as strings.

#
val get_rev_id_path : Camlp4.PreCast.Ast.ident -> string list -> string list

get_rev_id_path id acc takes an identifier.

Returns a reversed module path (list of strings) denoting this identifier, appending it to acc.
#
val ident_of_rev_path : Camlp4.PreCast.Ast.Loc.t -> string list -> Camlp4.PreCast.Ast.ident

ident_of_rev_path loc path takes a location loc and a reversed path rev_path to an identifier.

Returns identifier denoting the bound value.
#
val get_appl_path : Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.ident

get_appl_path loc tp

Returns the identifier path associated with a polymorphic type.
#
val abstract : Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.patt list -> Camlp4.PreCast.Ast.expr -> Camlp4.PreCast.Ast.expr

abstract loc patts body takes a location loc, a pattern list patts, and an expression body.

Returns a function expression that takes the patterns as arguments, and binds them in body.
#
val apply : Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.expr -> Camlp4.PreCast.Ast.expr list -> Camlp4.PreCast.Ast.expr

apply loc f_expr arg_exprs takes a location loc, an expression f_expr representing a function, and a list of argument expressions arg_exprs.

Returns an expression in which the function is applied to its arguments.
#
val switch_tp_def : alias:(Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.ctyp -> 'a) -> sum:(Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.ctyp -> 'a) -> record:(Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.ctyp -> 'a) -> variants:(Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.ctyp -> 'a) -> mani:(Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.ctyp -> 'a) -> nil:(Camlp4.PreCast.Ast.Loc.t -> 'a) -> Camlp4.PreCast.Ast.ctyp -> 'a

switch_tp_def ~alias ~sum ~record ~variants ~mani tp_def takes a handler function for each kind of type definition and applies the appropriate handler when tp_def matches.

#
val mk_expr_lst : Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.expr list -> Camlp4.PreCast.Ast.expr

mk_expr_lst loc expr_list takes a list of expressions.

Returns an expression representing a list of expressions.
#
val mk_patt_lst : Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.patt list -> Camlp4.PreCast.Ast.patt

mk_patt_lst _loc patt_list takes a list of patterns.

Returns a pattern representing a list of patterns.
#
val get_tparam_id : Camlp4.PreCast.Ast.ctyp -> string

get_tparam_id tp

Returns the string identifier associated with tp if it is a type parameter.
Raises Failure otherwise.
#
val type_is_recursive : ?stop_on_functions:bool -> ?short_circuit:(Camlp4.PreCast.Ast.ctyp -> bool option) -> string -> Camlp4.PreCast.Ast.ctyp -> bool

type_is_recursive ?short_circuit id tp

Returns whether the type tp with name id refers to itself, assuming that it is not mutually recursive with another type.
short_circuit allows you to override the search for certain type expressions.
stop_on_functions allows to disregard the recursive occurences appearing in arrow types. The default is to disregard them.
#
val drop_variance_annotations : Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.ctyp

drop_variance_annotations tp

Returns the type resulting from dropping all variance annotations in tp.
#
val find_record_default : Camlp4.PreCast.Ast.Loc.t -> Camlp4.PreCast.Ast.expr option

find_record_default loc

Returns the optional default expression associated with the record field at source location loc if defined.
#
val delay_sig_item : Camlp4.PreCast.Ast.sig_item -> unit

delay_sig_item item places item at the end of the current signature

end
Utility functions to rewrite type definitions
#
module Rewrite_tds : sig
#
val sig_ : Camlp4.PreCast.Ast.Loc.t -> bool -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.sig_item

sig_ loc rec_ typedefs rewrites the given type definition to make it either recursive or non recursive. For instance, the parser calls sig_ loc false (TyDcl (_, t, [], t, [])) when it encouters type t = t and calls sig_ loc true (TyDcl (_, t, [], t, [])) when it encouters type nonrec t = t in signatures.

#
val str_ : Camlp4.PreCast.Ast.Loc.t -> bool -> Camlp4.PreCast.Ast.ctyp -> Camlp4.PreCast.Ast.str_item

str_ loc rec_ typedefs does the same thing as sig_ loc rec_ typedefs, except that it returns a structure item instead of a signature item.

end
end