zelus 2.1 · OCaml Package

val make : 'a -> 'b Deftypes.loc

val product : Deftypes.typ list -> Deftypes.typ_desc Deftypes.loc

val vec : Deftypes.typ -> Deftypes.size -> Deftypes.typ_desc Deftypes.loc

val funtype : 
  Deftypes.kind ->
  Ident.t option ->
  Deftypes.typ ->
  Deftypes.typ ->
  Deftypes.typ_desc Deftypes.loc

val funtype_list : 
  Deftypes.kind ->
  (Ident.t option * Deftypes.typ) list ->
  Deftypes.typ ->
  Deftypes.typ

val plus : Deftypes.size -> Deftypes.size -> Deftypes.size

Make size expressions. Apply simple simplification rules

val minus : Deftypes.size -> Deftypes.size -> Deftypes.size

val const : int -> Deftypes.size

val global : Lident.qualident -> Deftypes.size

val name : Ident.t -> Deftypes.size

val constr : 
  Lident.qualident ->
  Deftypes.typ list ->
  Deftypes.abbrev ref ->
  Deftypes.typ_desc Deftypes.loc

val nconstr : 
  Lident.qualident ->
  Deftypes.typ list ->
  Deftypes.typ_desc Deftypes.loc

val new_discrete_var : unit -> Deftypes.typ_desc Deftypes.loc

val new_var : unit -> Deftypes.typ_desc Deftypes.loc

val new_generic_var : unit -> Deftypes.typ_desc Deftypes.loc

val new_var_list : int -> Deftypes.typ_desc Deftypes.loc list

val forall : Deftypes.typ list -> Deftypes.typ -> Deftypes.typ_scheme

val fv : Ident.S.t -> Deftypes.typ -> Ident.S.t

Set of free size variables in a type

val fv_size : Ident.S.t -> Deftypes.size -> Ident.S.t

val subst_in_type : Deftypes.size Ident.Env.t -> Deftypes.typ -> Deftypes.typ

val subst_in_size : Deftypes.size Ident.Env.t -> Deftypes.size -> Deftypes.size

val remove_dependences : Deftypes.typ -> Deftypes.typ

Remove dependences from a type

exception Unify

val less_than : Deftypes.kind -> Deftypes.kind -> unit

val lift : Deftypes.kind -> Deftypes.kind -> Deftypes.kind

val intro : Deftypes.kind -> Deftypes.kind

val run_type : Deftypes.kind -> Deftypes.typ_desc Deftypes.loc

val kind : 'a -> Deftypes.typ -> unit

val fully_applied : Deftypes.typ -> bool

val zero_type : Deftypes.kind -> Deftypes.typ_desc Deftypes.loc

context. bool otherwise.

val on_type : Deftypes.kind -> Deftypes.kind

val is_combinatorial_kind : Deftypes.kind -> bool

val is_discrete_kind : Deftypes.kind -> bool

val is_continuous_kind : Deftypes.kind -> bool

val is_statefull_kind : Deftypes.kind -> bool

val lift_to_discrete : Deftypes.kind -> Deftypes.kind

Make a discrete sort.

val typ_repr : Deftypes.typ -> Deftypes.typ

val occur_check : int -> Deftypes.typ -> Deftypes.typ -> unit

val clear : Ident.S.t -> Deftypes.typ -> Deftypes.typ * Ident.S.t

val list_of_typ_vars : Deftypes.typ list ref

val gen_ty : bool -> Deftypes.typ -> int

val gen : bool -> Deftypes.typ -> Deftypes.typ_scheme

val s : Deftypes.typ list ref

val save : Deftypes.typ -> unit

val cleanup : unit -> unit

val copy : Deftypes.typ -> Deftypes.typ

val size_of : Deftypes.typ -> Deftypes.size list

Compute the size of an array type t.

val instance_of_type : Deftypes.typ_scheme -> Deftypes.typ

val instance_and_vars_of_type : 
  Deftypes.typ_scheme ->
  Deftypes.typ_instance * Deftypes.typ

val constr_instance : Global.constr_desc -> Global.constr_desc

val label_instance : Global.label_desc -> Global.label_desc

val subst : Deftypes.typ_desc Deftypes.loc -> Deftypes.typ -> unit

val abbreviation : 
  Lident.qualident ->
  Deftypes.abbrev ref ->
  Deftypes.typ list ->
  Deftypes.typ

val same_types : 'a -> 'b -> bool

val unify : Deftypes.typ -> Deftypes.typ -> unit

val equal_sizes : Deftypes.size -> Deftypes.size -> unit

val filter_product : int -> Deftypes.typ -> Deftypes.typ list

val filter_signal : Deftypes.typ -> Deftypes.typ_desc Deftypes.loc

val filter_arrow : 
  Deftypes.kind ->
  Deftypes.typ ->
  Deftypes.kind * Ident.t option * Deftypes.typ * Deftypes.typ

val filter_actual_arrow : 
  Deftypes.typ ->
  Deftypes.kind * Ident.t option * Deftypes.typ * Deftypes.typ

val split_arguments : 
  Deftypes.typ ->
  'a list ->
  'b list * 'a list * Deftypes.typ

val filter_vec : Deftypes.typ -> Deftypes.typ * Deftypes.size

val type_of_combine : unit -> Deftypes.typ_desc Deftypes.loc

All the function below are pure. They do not modify the internal

representation of types. This is mandatory for them to be used once

static typing is performed

val is_a_signal : Deftypes.typ -> Deftypes.typ option

or nothing.

val is_combinatorial : int -> Deftypes.typ -> bool

Is-it a combinatorial function?

val res_type : int -> Deftypes.typ -> Deftypes.typ

val is_hybrid : int -> Deftypes.typ -> bool

val is_probabilistic : int -> Deftypes.typ -> bool

val is_a_node_name : Lident.t -> bool

Is-it a node ?

val is_a_function_name : Lident.t -> bool

Is-it a function?

val is_a_hybrid_node_name : Lident.t -> bool

Is-it a hybrid function?

val kind_of_funtype : Deftypes.typ -> Deftypes.kind

val kind_of_node_name : Lident.t -> Deftypes.kind

val noparameters : Deftypes.typ_scheme -> bool

val nopolymorphism : Deftypes.typ_scheme -> bool

package zelus