Parameter Make.I

Define the semantics of our abstract language.

Statements and expressions.

type 'a stm

A statement, generally some side-effecting code.

type 'a obs

The final evaluation result.

val observe : 'a stm -> 'a obs

Observe the evaluation result after all transformations have applied.

type 'a exp

An expression.

val return : 'a exp -> 'a stm

Return value 'a from a function.

val stm : unit exp -> unit stm
type 'a ref

A mutable reference variable. This is not compatible with expressions.

val ignore : unit stm -> (unit -> 'a stm) -> 'a stm

Evaluate a unit statement.

val let_ : string -> 'a exp -> ('a exp -> 'b stm) -> 'b stm

Define an immutable binding. The string is used for pretty-printing.

val ref : string -> 'a exp -> ('a ref -> 'b stm) -> 'b stm

Define a reference variable. The string is used for pretty-printing.

val (!) : 'a ref -> 'a exp
val (:=) : 'a ref -> 'a exp -> unit stm
val incr : int ref -> unit stm

Functions.

val lambda : ('a exp -> 'b stm) -> ('a -> 'b) exp
val (@@) : ('a -> 'b) exp -> 'a exp -> 'b exp

Control flow.

val if_else : bool exp -> then_:(unit -> 'a stm) -> else_:(unit -> 'a stm) -> 'a stm
val while_ : ('a exp -> bool exp) -> 'a ref -> (unit -> unit stm) -> unit stm

Standard values.

val unit : unit stm
val not : bool exp -> bool exp
val int : int -> int exp
val float : float -> float exp
val string : string -> string exp
val bool : bool -> bool exp
val (=) : 'a exp -> 'a exp -> bool exp
val pair : ('a exp * 'b exp) -> ('a * 'b) exp
val unpair : ('a * 'b) exp -> 'a exp * 'b exp
val string_of_int : int exp -> string exp
val string_of_float : float exp -> string exp
val string_of_bool : bool exp -> string exp

Sequences.

val uncons : 'a Stdlib.Seq.t exp -> nil:(unit -> 'b stm) -> cons:('a exp -> 'a Stdlib.Seq.t exp -> 'b stm) -> 'b stm
val generator : (('a exp -> unit stm) -> unit stm) -> 'a Stdlib.Seq.t exp

Create an ephemeral sequence from a function.

val iter : 'a Stdlib.Seq.t exp -> ('a exp -> unit stm) -> unit stm

Strings and characters.

val string_to_seq : string exp -> char Stdlib.Seq.t exp
val escape : char exp -> (string exp -> unit stm) -> (char exp -> unit stm) -> unit stm

For a given character, call a function with its replacement string or character. The replacement can be the same character.

Arrays.

val array : 'a exp array -> 'a array exp
val array_make : int -> 'a exp -> 'a array exp
val (.%()) : 'a array exp -> int exp -> 'a exp
val (.%()<-) : 'a array exp -> int exp -> 'a exp -> unit stm

Hash tables.

type 'a hashtbl := 'a Stdlib.Hashtbl.MakeSeeded(Stdlib.String).t
val hashtbl : (string exp * 'a exp) Stdlib.Seq.t -> 'a hashtbl exp
val hashtbl_create : unit -> 'a hashtbl exp
val (.%{}) : 'a hashtbl exp -> string exp -> 'a exp
val (.%{}<-) : 'a hashtbl exp -> string exp -> 'a exp -> unit stm
val hashtbl_mem : 'a hashtbl exp -> string exp -> bool exp
val hashtbl_to_seq : 'a hashtbl exp -> (string * 'a) Stdlib.Seq.t exp

Mutable string buffers.

val buffer_create : unit -> Stdlib.Buffer.t exp
val buffer_add_string : Stdlib.Buffer.t exp -> string exp -> unit stm
val buffer_add_char : Stdlib.Buffer.t exp -> char exp -> unit stm
val buffer_add_fmt : Stdlib.Buffer.t exp -> (Stdlib.Format.formatter -> unit) exp -> unit stm
val buffer_contents : Stdlib.Buffer.t exp -> string exp
val buffer_length : Stdlib.Buffer.t exp -> int exp
val dfmt : (Stdlib.Format.formatter -> unit) -> (Stdlib.Format.formatter -> unit) exp

Promises.

type 'a promise

An asynchronous computation.

val await : 'a promise exp -> 'a exp
val async_lambda : ('a exp -> 'b stm) -> ('a -> 'b promise) exp

This is necessary for JavaScript async/await syntax compatibility.

Results.

val errors_of_seq : string Stdlib.Seq.t exp -> Error.t list exp
val errors_is_empty : Error.t list exp -> bool exp
val ok : 'a exp -> ('a, 'e) Stdlib.result exp
val error : 'e exp -> ('a, 'e) Stdlib.result exp

Data.

type untyped
module type UNTYPED = sig ... end
val untyped : string -> ((module UNTYPED with type t = 'a) -> 'b stm) -> 'b stm

Make a new untyped wrapper. The string is used for pretty-printing.

module External : sig ... end

Data from the outside world that we need to decode.

Importing and exporting.

type import

Information to import a function from external code.

val import : import -> ((External.t -> string promise) exp -> 'a stm) -> 'a stm
val export : 'a exp -> 'a stm