Module Liquidsoap_lang_types.Type

Types and their constructors.

val debug : bool Stdlib.ref
val debug_levels : bool Stdlib.ref
val debug_variance : bool Stdlib.ref

Types

type variance = [
  1. | `Covariant
  2. | `Invariant
]
type custom = Type_base.custom
type custom_handler = Type_base.custom_handler = {
  1. typ : custom;
  2. serialize : custom -> string;
  3. copy_with : (t -> t) -> custom -> custom;
  4. occur_check : (t -> unit) -> custom -> unit;
  5. filter_vars : (Type_base.var list -> t -> Type_base.var list) -> Type_base.var list -> custom -> Type_base.var list;
  6. repr : (Type_base.var list -> t -> Type_base.constr Type_base.R.t) -> Type_base.var list -> custom -> Type_base.constr Type_base.R.t;
  7. subtype : (t -> t -> unit) -> custom -> custom -> unit;
  8. sup : (t -> t -> t) -> custom -> custom -> custom;
}
type custom_handler_state = Type_base.custom_handler_state =
  1. | Resolved of custom_handler
  2. | Dumped of {
    1. payload_id : int;
    2. payload : string;
    3. types : t list;
    }
type custom_instance = Type_base.custom_instance = {
  1. custom_name : string;
  2. mutable handler_state : custom_handler_state;
}
val custom_handler : custom_instance -> custom_handler

What a custom type carries here. Raises Failure for one that a dump brought in, which carries nothing.

type invar = Type_base.invar =
  1. | Free of Type_base.var
type var_t = Type_base.var_t = {
  1. id : int;
  2. mutable contents : invar;
}
type descr = Type_base.descr =
  1. | String
  2. | Int
  3. | Float
  4. | Bool
  5. | Never
  6. | Custom of custom_instance
  7. | Constr of Type_base.constructed
  8. | Getter of t
    (*

    a getter: something that is either a t or () -> t

    *)
  9. | List of Type_base.repr_t
  10. | Tuple of t list
  11. | Nullable of t
    (*

    something that is either t or null

    *)
  12. | Meth of Type_base.meth * t
    (*

    t with a method added

    *)
  13. | Arrow of t Type_base.argument list * t
    (*

    a function

    *)
  14. | Var of var_t
    (*

    a type variable

    *)
type constr = private Type_base.constr = {
  1. constr_name : string;
  2. constr_descr : string;
  3. univ_descr : string option;
  4. satisfied : subtype:(t -> t -> unit) -> satisfies:(t -> unit) -> t -> unit;
}
module Constraints = Type_base.Constraints
type constructed = Type_base.constructed = {
  1. constructor : string;
  2. params : (variance * t) list;
}
type var = Type_base.var = {
  1. name : int;
  2. mutable level : int;
  3. mutable constraints : Constraints.t;
}
type scheme = var list * t
type meth_doc = Type_base.meth_doc = {
  1. meth_descr : string;
  2. category : [ `Method | `Callback | `Composition ];
}
type meth = Type_base.meth = {
  1. meth : string;
  2. optional : bool;
  3. scheme : scheme;
  4. doc : meth_doc;
  5. json_name : string option;
}
type repr_t = Type_base.repr_t = {
  1. t : t;
  2. json_repr : [ `Tuple | `Object ];
}
val constr : ?univ_descr:string -> name:string -> descr:string -> (subtype:(t -> t -> unit) -> satisfies:(t -> unit) -> t -> unit) -> constr

Builds a constraint and records it under name, which is how a dump carries it: a reader resolves that name to its own constraint, or, having none, to one that prints the same and accepts everything.

val registered_constraint : string -> constr option
val string_of_constr : constr -> string
val record_constr : constr
val num_constr : constr
val ord_constr : constr
module R = Type_base.R
type 'a argument = bool * string * 'a
exception Unsatisfied_constraint
val unit : descr
module Var = Type_base.Var
module Vars = Type_base.Vars
module Fresh : sig ... end

Generate fresh types from existing types.

val fresh : t -> t
val make : ?pos:Liquidsoap_lang_prelude.Pos.t -> descr -> t
val deref : t -> t
val demeth : t -> t
val remeth : t -> t -> t
val invoke : t -> string -> scheme
val has_meth : t -> string -> bool
val invokes : t -> string list -> var list * t
val meth : ?pos:Liquidsoap_lang_prelude.Pos.t -> ?json_name:string -> ?category:[ `Method | `Callback | `Composition ] -> ?optional:bool -> string -> scheme -> ?doc:string -> t -> t
val reference : ?pos:Liquidsoap_lang_prelude.Pos.t -> t -> t

Type of references on a given type.

val meths : ?invoke:(t -> string -> scheme) -> ?pos:Liquidsoap_lang_prelude.Pos.t -> string list -> scheme -> t -> t

invoke is used to raise proper exception in Typechecking.

val split_meths : t -> meth list * t
val hide_meth : string -> t -> t
val opt_meth : string -> t -> t
val get_meth : string -> t -> meth
val filter_meths : t -> (meth -> bool) -> t
val map_meths : t -> (meth -> meth) -> t
val var : ?constraints:constr list -> ?level:int -> ?pos:Liquidsoap_lang_prelude.Pos.t -> unit -> t
val mk_invariant : t -> unit
val to_string : ?generalized:var list -> t -> string
val string_of_scheme : scheme -> string
val is_fun : t -> bool
val is_source : t -> bool
module Custom = Type_custom
val register_type : string -> (unit -> t) -> unit
val find_opt_typ : string -> (unit -> t) option