minicaml 0.4 · OCaml Package

module T = ANSITerminal

module D = Util.Dict

type ide = string

A value identifier

val pp_ide : 
  Ppx_deriving_runtime.Format.formatter ->
  ide ->
  Ppx_deriving_runtime.unit

val show_ide : ide -> Ppx_deriving_runtime.string

val equal_ide : ide -> ide -> Ppx_deriving_runtime.bool

val compare_ide : ide -> ide -> Ppx_deriving_runtime.int

type complext = Complex.t

A type wrapper for complex numbers where equality, ordering and showing are defined

val pp_complext : 
  Ppx_deriving_runtime.Format.formatter ->
  complext ->
  Ppx_deriving_runtime.unit

val show_complext : complext -> Ppx_deriving_runtime.string

val equal_complext : complext -> complext -> Ppx_deriving_runtime.bool

val compare_complext : complext -> complext -> Ppx_deriving_runtime.int

type puret =

| Impure
| Uncertain
| Pure
| Numerical

A type representing if a computation is pure or not

val pp_puret : 
  Ppx_deriving_runtime.Format.formatter ->
  puret ->
  Ppx_deriving_runtime.unit

val show_puret : puret -> Ppx_deriving_runtime.string

val equal_puret : puret -> puret -> Ppx_deriving_runtime.bool

val compare_puret : puret -> puret -> Ppx_deriving_runtime.int

val isuncertain : puret -> bool

val isnumerical : puret -> bool

val isstrictlypure : puret -> bool

val isimpure : puret -> bool

val ispure : puret -> bool

type primitiveinfo = ide * int * puret

Contains a primitive's name, number of arguments and pureness

val pp_primitiveinfo : 
  Ppx_deriving_runtime.Format.formatter ->
  primitiveinfo ->
  Ppx_deriving_runtime.unit

val show_primitiveinfo : primitiveinfo -> Ppx_deriving_runtime.string

val equal_primitiveinfo : 
  primitiveinfo ->
  primitiveinfo ->
  Ppx_deriving_runtime.bool

val compare_primitiveinfo : 
  primitiveinfo ->
  primitiveinfo ->
  Ppx_deriving_runtime.int

type expr =

| Unit
| Purity of puret * expr
| NumInt of int
| NumFloat of float
| NumComplex of complext
| Boolean of bool
| String of string
| Symbol of ide
| List of expr list
| Cons of expr * expr
| Concat of expr * expr
| Dict of (ide * expr) list
| Plus of expr * expr
| Sub of expr * expr
| Div of expr * expr
| Mult of expr * expr
| Eq of expr * expr
| Gt of expr * expr
| Lt of expr * expr
| Ge of expr * expr
| Le of expr * expr
| And of expr * expr
| Or of expr * expr
| Not of expr
| IfThenElse of expr * expr * expr
| Let of assignment_type list * expr
| Lambda of ide * expr
| Apply of expr * expr
| ApplyPrimitive of primitiveinfo * expr list
| Compose of expr * expr
| Sequence of expr list

The type representing Abstract Syntax Tree expressions

and assignment_type = bool * ide * expr

val pp_expr : 
  Ppx_deriving_runtime.Format.formatter ->
  expr ->
  Ppx_deriving_runtime.unit

val show_expr : expr -> Ppx_deriving_runtime.string

val pp_assignment_type : 
  Ppx_deriving_runtime.Format.formatter ->
  assignment_type ->
  Ppx_deriving_runtime.unit

val show_assignment_type : assignment_type -> Ppx_deriving_runtime.string

val equal_expr : expr -> expr -> Ppx_deriving_runtime.bool

val equal_assignment_type : 
  assignment_type ->
  assignment_type ->
  Ppx_deriving_runtime.bool

val compare_expr : expr -> expr -> Ppx_deriving_runtime.int

val compare_assignment_type : 
  assignment_type ->
  assignment_type ->
  Ppx_deriving_runtime.int

val findbody : expr -> expr

Function that finds a nested lambda body

Function that finds and replaces a (nested) lambda body

val replacebody : expr -> expr -> expr

Function that finds and replaces a (nested) lambda body

Function that creates a list with the params of a nested lambda

val findparams : expr -> ide list

Function that creates a list with the params of a nested lambda

val simple_show_expr : expr -> Ppx_deriving_runtime.string

Show a short representation of an expression (useful for stack traces)

val lambda_from_paramlist : ide list -> expr -> expr

Creates a nested Lambda from a list of params

val apply_from_exprlist : expr list -> expr -> expr

Creates a nested Apply from a list of expressions

val symbols_from_strings : ide list -> expr list

Creates a list of Symbol from a list of string

type directive =

| Dumpenv
| Dumppurityenv
| Includefile of string
| Includefileasmodule of string * ide option
| Setpurity of puret
| Setverbose of int

A type containing directives information

val pp_directive : 
  Ppx_deriving_runtime.Format.formatter ->
  directive ->
  Ppx_deriving_runtime.unit

val show_directive : directive -> Ppx_deriving_runtime.string

val equal_directive : directive -> directive -> Ppx_deriving_runtime.bool

val compare_directive : directive -> directive -> Ppx_deriving_runtime.int

type command =

| Directive of directive
| Expr of expr
| Def of assignment_type list

A type useful for evaluating files, stating if a command is an expression or simply a "global" declaration (appended to environment)

val pp_command : 
  Ppx_deriving_runtime.Format.formatter ->
  command ->
  Ppx_deriving_runtime.unit

val show_command : command -> Ppx_deriving_runtime.string

val equal_command : command -> command -> Ppx_deriving_runtime.bool

val compare_command : command -> command -> Ppx_deriving_runtime.int

type evt =

| EvtUnit
| EvtInt of int
| EvtFloat of float
| EvtComplex of complext
| EvtBool of bool
| EvtString of string
| EvtList of evt list
| EvtDict of (ide * evt) list
(*
Recursion is achieved by keeping an optional function name in the constructor
*)
| Closure of ide option * ide * expr * env_type
(*
Abstraction that permits treating primitives as closures
*)

A type that represents an evaluated (reduced) value

and type_wrapper =

| LazyExpression of expr
| AlreadyEvaluated of evt

and env_type = (ide, type_wrapper) D.t

and typeinfo =

| TUnit
| TBool
| TNumber
| TInt
| TFloat
| TComplex
| TString
| TList
| TDict
| TLambda

A type containing information about types

val pp_evt : 
  Ppx_deriving_runtime.Format.formatter ->
  evt ->
  Ppx_deriving_runtime.unit

val show_evt : evt -> Ppx_deriving_runtime.string

val pp_type_wrapper : 
  Ppx_deriving_runtime.Format.formatter ->
  type_wrapper ->
  Ppx_deriving_runtime.unit

val show_type_wrapper : type_wrapper -> Ppx_deriving_runtime.string

val pp_env_type : 
  Ppx_deriving_runtime.Format.formatter ->
  env_type ->
  Ppx_deriving_runtime.unit

val show_env_type : env_type -> Ppx_deriving_runtime.string

val pp_typeinfo : 
  Ppx_deriving_runtime.Format.formatter ->
  typeinfo ->
  Ppx_deriving_runtime.unit

val show_typeinfo : typeinfo -> Ppx_deriving_runtime.string

val equal_evt : evt -> evt -> Ppx_deriving_runtime.bool

val equal_type_wrapper : 
  type_wrapper ->
  type_wrapper ->
  Ppx_deriving_runtime.bool

val equal_env_type : env_type -> env_type -> Ppx_deriving_runtime.bool

val equal_typeinfo : typeinfo -> typeinfo -> Ppx_deriving_runtime.bool

val compare_evt : evt -> evt -> Ppx_deriving_runtime.int

val compare_type_wrapper : 
  type_wrapper ->
  type_wrapper ->
  Ppx_deriving_runtime.int

val compare_env_type : env_type -> env_type -> Ppx_deriving_runtime.int

val compare_typeinfo : typeinfo -> typeinfo -> Ppx_deriving_runtime.int

val show_tinfo : typeinfo -> string

val generate_prim_params : int -> string list

val show_unpacked_evt : evt -> Ppx_deriving_runtime.string

val findevtparams : evt -> ide list

Function that creates a list with the params of a nested lambda in a Closure

type primitive =

| Primitive of evt list -> evt * primitiveinfo

A type representing a primitive

val get_primitive_purity : primitive -> puret

Get the purity of a primitive

val get_primitive_function : primitive -> evt list -> evt

Get the actual function from a primitive type

val get_primitive_info : primitive -> primitiveinfo

Get the information from a primitive type

val lambda_from_primitive : primitive -> expr

Generate a lambda from a primitive

type purityenv_type = (ide, puret) Util.Dict.t

An environment type containing identifier - purity couples

val pp_purityenv_type : 
  Ppx_deriving_runtime.Format.formatter ->
  purityenv_type ->
  Ppx_deriving_runtime.unit

val show_purityenv_type : purityenv_type -> Ppx_deriving_runtime.string

type stackframe =

| StackValue of int * expr * stackframe
| EmptyStack

A recursive type representing a stacktrace frame

val pp_stackframe : 
  Ppx_deriving_runtime.Format.formatter ->
  stackframe ->
  Ppx_deriving_runtime.unit

val show_stackframe : stackframe -> Ppx_deriving_runtime.string

val push_stack : stackframe -> expr -> stackframe

Push an AST expression into a stack

parameter s
The stack where to push the expression

parameter e
The expression to push

val pop_stack : stackframe -> stackframe

Pop an AST expression from a stack

val depth_of_stack : stackframe -> int

val string_of_stack : int -> stackframe -> string

type evalstate = {

env : env_type;
purityenv : purityenv_type;
verbosity : int;
stack : stackframe;
mutable printresult : bool;
purity : puret;

}

Options for the eval function

type location =

| Location of Lexing.position * Lexing.position
(*
delimited location
*)
| Nowhere
(*
no location
*)

The location of a lexeme in code

val location_of_lex : Lexing.lexbuf -> location

Get the location of a lexeme

type internalerrort =

| Fatal of string
| InternalFailure of string
| WrongPrimitiveArgs
| IndexOutOfBounds
| TypeError of string
| UnboundVariable of string
| ListError of string
| DictError of string
| FileNotFoundError of string
| PurityError of string
| SyntaxError of string

Exceptions

val pp_internalerrort : 
  Ppx_deriving_runtime.Format.formatter ->
  internalerrort ->
  Ppx_deriving_runtime.unit

val show_internalerrort : internalerrort -> Ppx_deriving_runtime.string

exception InternalError of location * internalerrort * stackframe

Exception Error (loc, err, msg) indicates an error of type err with error message msg, occurring at location loc.

val sraises : Lexing.lexbuf -> string -> stackframe -> 'a

Utility function to raise a syntax error quickly

val sraise : Lexing.lexbuf -> string -> 'a

val iraises : internalerrort -> stackframe -> 'a

Utility function to raise an internal error without a location

val iraise : internalerrort -> 'a

val traises : string -> stackframe -> 'a

Utility function to raise a type error without a location

val traise : string -> 'a

val print_location : location -> string

Print the location of a lexeme

val print_message : ?color:T.color -> ?loc:location -> string -> string -> unit

Print a message at a given location loc of message type msg_type.

val print_error : (location * internalerrort * 'a) -> unit

Print the caught error

val print_stacktrace : ('a * 'b * stackframe) -> int -> unit

val read_file : (Lexing.lexbuf -> 'a) -> string -> 'a

Parse the contents from a file, using a given parser.

package minicaml