codeBits.mli 2 KB
Newer Older
1 2 3 4 5
(* This module provides a number of tiny functions that help produce
   [IL] code. *)

open IL

6 7
(* A list subject to a condition. (Be careful, though: the list is
   of course constructed even if the condition is false.) *)
8 9 10 11

val listif: bool -> 'a list -> 'a list
val elementif: bool -> 'a -> 'a list

12 13 14 15 16
(* A lazy version of [listif], where the list is constructed only
   if the condition is true. *)

val listiflazy: bool -> (unit -> 'a list) -> 'a list

17 18 19
(* Standard types. *)

val tunit: typ
20
val tbool: typ
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
val tint: typ
val tstring: typ
val texn: typ
val tposition: typ
val tlexbuf: typ
val tobj : typ

(* Building a type variable. *)

val tvar: string -> typ

(* Building a type scheme. *)

val scheme: string list -> typ -> typescheme
val type2scheme: typ -> typescheme

(* Projecting out of a [PVar] pattern. *)

val pat2var: pattern -> string

(* Building a [let] construct, with on-the-fly simplification. *)

val blet: (pattern * expr) list * expr -> expr
val mlet: pattern list -> expr list -> expr -> expr

(* [bottom] is an expression that has every type. Its semantics is
   irrelevant. *)

val bottom: expr

(* Boolean constants. *)

val etrue: expr
val efalse: expr
val eboolconst: bool -> expr

57 58 59 60 61 62 63 64 65
(* Option constructors. *)

val enone: expr
val esome: expr -> expr

(* List constructors. *)

val elist: expr list -> expr

66 67 68 69
(* Integer constants as patterns. *)

val pint: int -> pattern

70 71 72 73 74 75 76 77 78 79
(* These help build function types. *)

val arrow: typ -> typ -> typ
val arrowif: bool -> typ -> typ -> typ
val marrow: typ list -> typ -> typ

(* These functions are used to generate names in menhir's namespace. *)
val prefix: string -> string
val dataprefix: string -> string
val tvprefix: string -> string
80

81 82 83
(* Converting an interface to a structure. Only exception and type definitions
   go through. *)
val interface_to_structure: interface -> structure
84

85 86
(* Constructing a named module type together with a list of "with type"
   constraints. *)
87
val with_types: IL.with_kind -> string -> (string list * string * IL.typ) list -> IL.module_type
88