balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Renamed the extensibility type parameter to 'x so that it can easily be grepped for.

Browse Source 
Review this commit with:

    git diff --color-words=.
This commit is contained in:
Your Name 2019-03-05 18:16:21 +01:00
parent 40377a80df
commit fb85ea1f18
3 changed files with 523 additions and 523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

450
AST.ml
View File

@ -113,12 +113,12 @@ type eof = Region.t
(* Literals *)
type 'a variable = string reg
type 'a fun_name = string reg
type 'a type_name = string reg
type 'a field_name = string reg
type 'a map_name = string reg
type 'a constr = string reg
type 'x variable = string reg
type 'x fun_name = string reg
type 'x type_name = string reg
type 'x field_name = string reg
type 'x map_name = string reg
type 'x constr = string reg
(* Comma-separated non-empty lists *)
@ -144,227 +144,227 @@ type 'a braces = (lbrace * 'a * rbrace) reg
type t = < ty: unit > ast
and 'a ast = {
types : 'a type_decl reg list;
constants : 'a const_decl reg list;
parameter : 'a parameter_decl reg;
storage : 'a storage_decl reg;
operations : 'a operations_decl reg;
lambdas : 'a lambda_decl list;
block : 'a block reg;
and 'x ast = {
types : 'x type_decl reg list;
constants : 'x const_decl reg list;
parameter : 'x parameter_decl reg;
storage : 'x storage_decl reg;
operations : 'x operations_decl reg;
lambdas : 'x lambda_decl list;
block : 'x block reg;
eof : eof
}
and 'a parameter_decl = {
and 'x parameter_decl = {
kwd_parameter : kwd_parameter;
name : 'a variable;
name : 'x variable;
colon : colon;
param_type : 'a type_expr;
param_type : 'x type_expr;
terminator : semi option
}
and 'a storage_decl = {
and 'x storage_decl = {
kwd_storage : kwd_storage;
store_type : 'a type_expr;
store_type : 'x type_expr;
terminator : semi option
}
and 'a operations_decl = {
and 'x operations_decl = {
kwd_operations : kwd_operations;
op_type : 'a type_expr;
op_type : 'x type_expr;
terminator : semi option
}
(* Type declarations *)
and 'a type_decl = {
and 'x type_decl = {
kwd_type : kwd_type;
name : 'a type_name;
name : 'x type_name;
kwd_is : kwd_is;
type_expr : 'a type_expr;
type_expr : 'x type_expr;
terminator : semi option
}
and 'a type_expr =
Prod of 'a cartesian
| Sum of ('a variant, vbar) nsepseq reg
| Record of 'a record_type
| TypeApp of ('a type_name * 'a type_tuple) reg
| ParType of 'a type_expr par
| TAlias of 'a variable
and 'x type_expr =
Prod of 'x cartesian
| Sum of ('x variant, vbar) nsepseq reg
| Record of 'x record_type
| TypeApp of ('x type_name * 'x type_tuple) reg
| ParType of 'x type_expr par
| TAlias of 'x variable
and 'a cartesian = ('a type_expr, times) nsepseq reg
and 'x cartesian = ('x type_expr, times) nsepseq reg
and 'a variant = ('a constr * kwd_of * 'a cartesian) reg
and 'x variant = ('x constr * kwd_of * 'x cartesian) reg
and 'a record_type = (kwd_record * 'a field_decls * kwd_end) reg
and 'x record_type = (kwd_record * 'x field_decls * kwd_end) reg
and 'a field_decls = ('a field_decl, semi) nsepseq
and 'x field_decls = ('x field_decl, semi) nsepseq
and 'a field_decl = ('a variable * colon * 'a type_expr) reg
and 'x field_decl = ('x variable * colon * 'x type_expr) reg
and 'a type_tuple = ('a type_name, comma) nsepseq par
and 'x type_tuple = ('x type_name, comma) nsepseq par
(* Function and procedure declarations *)
and 'a lambda_decl =
FunDecl of 'a fun_decl reg
| ProcDecl of 'a proc_decl reg
and 'x lambda_decl =
FunDecl of 'x fun_decl reg
| ProcDecl of 'x proc_decl reg
and 'a fun_decl = {
and 'x fun_decl = {
kwd_function : kwd_function;
name : 'a variable;
param : 'a parameters;
name : 'x variable;
param : 'x parameters;
colon : colon;
ret_type : 'a type_expr;
ret_type : 'x type_expr;
kwd_is : kwd_is;
local_decls : 'a local_decl list;
block : 'a block reg;
local_decls : 'x local_decl list;
block : 'x block reg;
kwd_with : kwd_with;
return : 'a expr;
return : 'x expr;
terminator : semi option
}
and 'a proc_decl = {
and 'x proc_decl = {
kwd_procedure : kwd_procedure;
name : 'a variable;
param : 'a parameters;
name : 'x variable;
param : 'x parameters;
kwd_is : kwd_is;
local_decls : 'a local_decl list;
block : 'a block reg;
local_decls : 'x local_decl list;
block : 'x block reg;
terminator : semi option
}
and 'a parameters = ('a param_decl, semi) nsepseq par
and 'x parameters = ('x param_decl, semi) nsepseq par
and 'a param_decl =
ParamConst of 'a param_const
| ParamVar of 'a param_var
and 'x param_decl =
ParamConst of 'x param_const
| ParamVar of 'x param_var
and 'a param_const = (kwd_const * 'a variable * colon * 'a type_expr) reg
and 'x param_const = (kwd_const * 'x variable * colon * 'x type_expr) reg
and 'a param_var = (kwd_var * 'a variable * colon * 'a type_expr) reg
and 'x param_var = (kwd_var * 'x variable * colon * 'x type_expr) reg
and 'a block = {
and 'x block = {
opening : kwd_begin;
instr : 'a instructions;
instr : 'x instructions;
terminator : semi option;
close : kwd_end
}
and 'a local_decl =
LocalLam of 'a lambda_decl
| LocalConst of 'a const_decl reg
| LocalVar of 'a var_decl reg
and 'x local_decl =
LocalLam of 'x lambda_decl
| LocalConst of 'x const_decl reg
| LocalVar of 'x var_decl reg
and 'a const_decl = {
and 'x const_decl = {
kwd_const : kwd_const;
name : 'a variable;
name : 'x variable;
colon : colon;
vtype : 'a type_expr;
vtype : 'x type_expr;
equal : equal;
init : 'a expr;
init : 'x expr;
terminator : semi option
}
and 'a var_decl = {
and 'x var_decl = {
kwd_var : kwd_var;
name : 'a variable;
name : 'x variable;
colon : colon;
vtype : 'a type_expr;
vtype : 'x type_expr;
ass : ass;
init : 'a expr;
init : 'x expr;
terminator : semi option
}
and 'a instructions = ('a instruction, semi) nsepseq reg
and 'x instructions = ('x instruction, semi) nsepseq reg
and 'a instruction =
Single of 'a single_instr
| Block of 'a block reg
and 'x instruction =
Single of 'x single_instr
| Block of 'x block reg
and 'a single_instr =
Cond of 'a conditional reg
| Match of 'a match_instr reg
| Ass of 'a ass_instr
| Loop of 'a loop
| ProcCall of 'a fun_call
and 'x single_instr =
Cond of 'x conditional reg
| Match of 'x match_instr reg
| Ass of 'x ass_instr
| Loop of 'x loop
| ProcCall of 'x fun_call
| Null of kwd_null
| Fail of (kwd_fail * 'a expr) reg
| Fail of (kwd_fail * 'x expr) reg
and 'a conditional = {
and 'x conditional = {
kwd_if : kwd_if;
test : 'a expr;
test : 'x expr;
kwd_then : kwd_then;
ifso : 'a instruction;
ifso : 'x instruction;
kwd_else : kwd_else;
ifnot : 'a instruction
ifnot : 'x instruction
}
and 'a match_instr = {
and 'x match_instr = {
kwd_match : kwd_match;
expr : 'a expr;
expr : 'x expr;
kwd_with : kwd_with;
lead_vbar : vbar option;
cases : 'a cases;
cases : 'x cases;
kwd_end : kwd_end
}
and 'a cases = ('a case, vbar) nsepseq reg
and 'x cases = ('x case, vbar) nsepseq reg
and 'a case = ('a pattern * arrow * 'a instruction) reg
and 'x case = ('x pattern * arrow * 'x instruction) reg
and 'a ass_instr = ('a variable * ass * 'a expr) reg
and 'x ass_instr = ('x variable * ass * 'x expr) reg
and 'a loop =
While of 'a while_loop
| For of 'a for_loop
and 'x loop =
While of 'x while_loop
| For of 'x for_loop
and 'a while_loop = (kwd_while * 'a expr * 'a block reg) reg
and 'x while_loop = (kwd_while * 'x expr * 'x block reg) reg
and 'a for_loop =
ForInt of 'a for_int reg
| ForCollect of 'a for_collect reg
and 'x for_loop =
ForInt of 'x for_int reg
| ForCollect of 'x for_collect reg
and 'a for_int = {
and 'x for_int = {
kwd_for : kwd_for;
ass : 'a ass_instr;
ass : 'x ass_instr;
down : kwd_down option;
kwd_to : kwd_to;
bound : 'a expr;
step : (kwd_step * 'a expr) option;
block : 'a block reg
bound : 'x expr;
step : (kwd_step * 'x expr) option;
block : 'x block reg
}
and 'a for_collect = {
and 'x for_collect = {
kwd_for : kwd_for;
var : 'a variable;
bind_to : (arrow * 'a variable) option;
var : 'x variable;
bind_to : (arrow * 'x variable) option;
kwd_in : kwd_in;
expr : 'a expr;
block : 'a block reg
expr : 'x expr;
block : 'x block reg
}
(* Expressions *)
and 'a expr =
Or of ('a expr * bool_or * 'a expr) reg
| And of ('a expr * bool_and * 'a expr) reg
| Lt of ('a expr * lt * 'a expr) reg
| Leq of ('a expr * leq * 'a expr) reg
| Gt of ('a expr * gt * 'a expr) reg
| Geq of ('a expr * geq * 'a expr) reg
| Equal of ('a expr * equal * 'a expr) reg
| Neq of ('a expr * neq * 'a expr) reg
| Cat of ('a expr * cat * 'a expr) reg
| Cons of ('a expr * cons * 'a expr) reg
| Add of ('a expr * plus * 'a expr) reg
| Sub of ('a expr * minus * 'a expr) reg
| Mult of ('a expr * times * 'a expr) reg
| Div of ('a expr * slash * 'a expr) reg
| Mod of ('a expr * kwd_mod * 'a expr) reg
| Neg of (minus * 'a expr) reg
| Not of (kwd_not * 'a expr) reg
and 'x expr =
Or of ('x expr * bool_or * 'x expr) reg
| And of ('x expr * bool_and * 'x expr) reg
| Lt of ('x expr * lt * 'x expr) reg
| Leq of ('x expr * leq * 'x expr) reg
| Gt of ('x expr * gt * 'x expr) reg
| Geq of ('x expr * geq * 'x expr) reg
| Equal of ('x expr * equal * 'x expr) reg
| Neq of ('x expr * neq * 'x expr) reg
| Cat of ('x expr * cat * 'x expr) reg
| Cons of ('x expr * cons * 'x expr) reg
| Add of ('x expr * plus * 'x expr) reg
| Sub of ('x expr * minus * 'x expr) reg
| Mult of ('x expr * times * 'x expr) reg
| Div of ('x expr * slash * 'x expr) reg
| Mod of ('x expr * kwd_mod * 'x expr) reg
| Neg of (minus * 'x expr) reg
| Not of (kwd_not * 'x expr) reg
| Int of (Lexer.lexeme * Z.t) reg
| Var of Lexer.lexeme reg
| String of Lexer.lexeme reg
@ -372,46 +372,46 @@ and 'a expr =
| False of c_False
| True of c_True
| Unit of c_Unit
| Tuple of 'a tuple
| List of ('a expr, comma) nsepseq brackets
| EmptyList of 'a empty_list
| Set of ('a expr, comma) nsepseq braces
| EmptySet of 'a empty_set
| NoneExpr of 'a none_expr
| FunCall of 'a fun_call
| ConstrApp of 'a constr_app
| SomeApp of (c_Some * 'a arguments) reg
| MapLookUp of 'a map_lookup reg
| ParExpr of 'a expr par
| Tuple of 'x tuple
| List of ('x expr, comma) nsepseq brackets
| EmptyList of 'x empty_list
| Set of ('x expr, comma) nsepseq braces
| EmptySet of 'x empty_set
| NoneExpr of 'x none_expr
| FunCall of 'x fun_call
| ConstrApp of 'x constr_app
| SomeApp of (c_Some * 'x arguments) reg
| MapLookUp of 'x map_lookup reg
| ParExpr of 'x expr par
and 'a tuple = ('a expr, comma) nsepseq par
and 'x tuple = ('x expr, comma) nsepseq par
and 'a empty_list =
(lbracket * rbracket * colon * 'a type_expr) par
and 'x empty_list =
(lbracket * rbracket * colon * 'x type_expr) par
and 'a empty_set =
(lbrace * rbrace * colon * 'a type_expr) par
and 'x empty_set =
(lbrace * rbrace * colon * 'x type_expr) par
and 'a none_expr =
(c_None * colon * 'a type_expr) par
and 'x none_expr =
(c_None * colon * 'x type_expr) par
and 'a fun_call = ('a fun_name * 'a arguments) reg
and 'x fun_call = ('x fun_name * 'x arguments) reg
and 'a arguments = 'a tuple
and 'x arguments = 'x tuple
and 'a constr_app = ('a constr * 'a arguments) reg
and 'x constr_app = ('x constr * 'x arguments) reg
and 'a map_lookup = {
map_name : 'a variable;
and 'x map_lookup = {
map_name : 'x variable;
selector : dot;
index : 'a expr brackets
index : 'x expr brackets
}
(* Patterns *)
and 'a pattern = ('a core_pattern, cons) nsepseq reg
and 'x pattern = ('x core_pattern, cons) nsepseq reg
and 'a core_pattern =
and 'x core_pattern =
PVar of Lexer.lexeme reg
| PWild of wild
| PInt of (Lexer.lexeme * Z.t) reg
@ -421,13 +421,13 @@ and 'a core_pattern =
| PFalse of c_False
| PTrue of c_True
| PNone of c_None
| PSome of (c_Some * 'a core_pattern par) reg
| PList of 'a list_pattern
| PTuple of ('a core_pattern, comma) nsepseq par
| PSome of (c_Some * 'x core_pattern par) reg
| PList of 'x list_pattern
| PTuple of ('x core_pattern, comma) nsepseq par
and 'a list_pattern =
Sugar of ('a core_pattern, comma) sepseq brackets
| Raw of ('a core_pattern * cons * 'a pattern) par
and 'x list_pattern =
Sugar of ('x core_pattern, comma) sepseq brackets
| Raw of ('x core_pattern * cons * 'x pattern) par
(* Projecting regions *)
@ -513,77 +513,77 @@ let local_decl_to_region = function
(* Printing the tokens with their source regions *)
type 'a visitor = {
ass_instr : 'a ass_instr -> unit;
bind_to : (region * 'a variable) option -> unit;
block : 'a block reg -> unit;
type 'x visitor = {
ass_instr : 'x ass_instr -> unit;
bind_to : (region * 'x variable) option -> unit;
block : 'x block reg -> unit;
bytes : (string * MBytes.t) reg -> unit;
cartesian : 'a cartesian -> unit;
case : 'a case -> unit;
cases : 'a cases -> unit;
conditional : 'a conditional -> unit;
const_decl : 'a const_decl reg -> unit;
constr : 'a constr -> unit;
constr_app : 'a constr_app -> unit;
core_pattern : 'a core_pattern -> unit;
cartesian : 'x cartesian -> unit;
case : 'x case -> unit;
cases : 'x cases -> unit;
conditional : 'x conditional -> unit;
const_decl : 'x const_decl reg -> unit;
constr : 'x constr -> unit;
constr_app : 'x constr_app -> unit;
core_pattern : 'x core_pattern -> unit;
down : region option -> unit;
empty_list : 'a empty_list -> unit;
empty_set : 'a empty_set -> unit;
expr : 'a expr -> unit;
fail : (kwd_fail * 'a expr) -> unit;
field_decl : 'a field_decl -> unit;
field_decls : 'a field_decls -> unit;
for_collect : 'a for_collect reg -> unit;
for_int : 'a for_int reg -> unit;
for_loop : 'a for_loop -> unit;
fun_call : 'a fun_call -> unit;
fun_decl : 'a fun_decl reg -> unit;
instruction : 'a instruction -> unit;
instructions : 'a instructions -> unit;
empty_list : 'x empty_list -> unit;
empty_set : 'x empty_set -> unit;
expr : 'x expr -> unit;
fail : (kwd_fail * 'x expr) -> unit;
field_decl : 'x field_decl -> unit;
field_decls : 'x field_decls -> unit;
for_collect : 'x for_collect reg -> unit;
for_int : 'x for_int reg -> unit;
for_loop : 'x for_loop -> unit;
fun_call : 'x fun_call -> unit;
fun_decl : 'x fun_decl reg -> unit;
instruction : 'x instruction -> unit;
instructions : 'x instructions -> unit;
int : (string * Z.t) reg -> unit;
lambda_decl : 'a lambda_decl -> unit;
list : ('a expr, region) nsepseq brackets -> unit;
list_pattern : 'a list_pattern -> unit;
loop : 'a loop -> unit;
map_lookup : 'a map_lookup reg -> unit;
match_instr : 'a match_instr -> unit;
none_expr : 'a none_expr -> unit;
lambda_decl : 'x lambda_decl -> unit;
list : ('x expr, region) nsepseq brackets -> unit;
list_pattern : 'x list_pattern -> unit;
loop : 'x loop -> unit;
map_lookup : 'x map_lookup reg -> unit;
match_instr : 'x match_instr -> unit;
none_expr : 'x none_expr -> unit;
nsepseq : 'a.string -> ('a -> unit) -> ('a, region) nsepseq -> unit;
operations_decl : 'a operations_decl reg -> unit;
par_expr : 'a expr par -> unit;
par_type : 'a type_expr par -> unit;
param_decl : 'a param_decl -> unit;
parameter_decl : 'a parameter_decl reg -> unit;
parameters : 'a parameters -> unit;
param_const : 'a param_const -> unit;
param_var : 'a param_var -> unit;
pattern : 'a pattern -> unit;
patterns : 'a core_pattern par -> unit;
proc_decl : 'a proc_decl reg -> unit;
psome : (region * 'a core_pattern par) reg -> unit;
ptuple : ('a core_pattern, region) nsepseq par -> unit;
raw : ('a core_pattern * region * 'a pattern) par -> unit;
record_type : 'a record_type -> unit;
operations_decl : 'x operations_decl reg -> unit;
par_expr : 'x expr par -> unit;
par_type : 'x type_expr par -> unit;
param_decl : 'x param_decl -> unit;
parameter_decl : 'x parameter_decl reg -> unit;
parameters : 'x parameters -> unit;
param_const : 'x param_const -> unit;
param_var : 'x param_var -> unit;
pattern : 'x pattern -> unit;
patterns : 'x core_pattern par -> unit;
proc_decl : 'x proc_decl reg -> unit;
psome : (region * 'x core_pattern par) reg -> unit;
ptuple : ('x core_pattern, region) nsepseq par -> unit;
raw : ('x core_pattern * region * 'x pattern) par -> unit;
record_type : 'x record_type -> unit;
sepseq : 'a.string -> ('a -> unit) -> ('a, region) sepseq -> unit;
set : ('a expr, region) nsepseq braces -> unit;
single_instr : 'a single_instr -> unit;
some_app : (region * 'a arguments) reg -> unit;
step : (region * 'a expr) option -> unit;
storage_decl : 'a storage_decl reg -> unit;
set : ('x expr, region) nsepseq braces -> unit;
single_instr : 'x single_instr -> unit;
some_app : (region * 'x arguments) reg -> unit;
step : (region * 'x expr) option -> unit;
storage_decl : 'x storage_decl reg -> unit;
string : string reg -> unit;
sugar : ('a core_pattern, region) sepseq brackets -> unit;
sum_type : ('a variant, region) nsepseq reg -> unit;
sugar : ('x core_pattern, region) sepseq brackets -> unit;
sum_type : ('x variant, region) nsepseq reg -> unit;
terminator : semi option -> unit;
token : region -> string -> unit;
tuple : 'a arguments -> unit;
type_app : ('a type_name * 'a type_tuple) reg -> unit;
type_decl : 'a type_decl reg -> unit;
type_expr : 'a type_expr -> unit;
type_tuple : 'a type_tuple -> unit;
local_decl : 'a local_decl -> unit;
local_decls : 'a local_decl list -> unit;
var : 'a variable -> unit;
var_decl : 'a var_decl reg -> unit;
variant : 'a variant -> unit;
while_loop : 'a while_loop -> unit
tuple : 'x arguments -> unit;
type_app : ('x type_name * 'x type_tuple) reg -> unit;
type_decl : 'x type_decl reg -> unit;
type_expr : 'x type_expr -> unit;
type_tuple : 'x type_tuple -> unit;
local_decl : 'x local_decl -> unit;
local_decls : 'x local_decl list -> unit;
var : 'x variable -> unit;
var_decl : 'x var_decl reg -> unit;
variant : 'x variant -> unit;
while_loop : 'x while_loop -> unit
}

464
AST.mli
View File

@ -97,12 +97,12 @@ type eof = Region.t
(* Literals *)
type 'a variable = string reg
type 'a fun_name = string reg
type 'a type_name = string reg
type 'a field_name = string reg
type 'a map_name = string reg
type 'a constr = string reg
type 'x variable = string reg
type 'x fun_name = string reg
type 'x type_name = string reg
type 'x field_name = string reg
type 'x map_name = string reg
type 'x constr = string reg
(* Comma-separated non-empty lists *)
@ -128,227 +128,227 @@ type 'a braces = (lbrace * 'a * rbrace) reg
type t = < ty:unit > ast
and 'a ast = {
types : 'a type_decl reg list;
constants : 'a const_decl reg list;
parameter : 'a parameter_decl reg;
storage : 'a storage_decl reg;
operations : 'a operations_decl reg;
lambdas : 'a lambda_decl list;
block : 'a block reg;
and 'x ast = {
types : 'x type_decl reg list;
constants : 'x const_decl reg list;
parameter : 'x parameter_decl reg;
storage : 'x storage_decl reg;
operations : 'x operations_decl reg;
lambdas : 'x lambda_decl list;
block : 'x block reg;
eof : eof
}
and 'a parameter_decl = {
and 'x parameter_decl = {
kwd_parameter : kwd_parameter;
name : 'a variable;
name : 'x variable;
colon : colon;
param_type : 'a type_expr;
param_type : 'x type_expr;
terminator : semi option
}
and 'a storage_decl = {
and 'x storage_decl = {
kwd_storage : kwd_storage;
store_type : 'a type_expr;
store_type : 'x type_expr;
terminator : semi option
}
and 'a operations_decl = {
and 'x operations_decl = {
kwd_operations : kwd_operations;
op_type : 'a type_expr;
op_type : 'x type_expr;
terminator : semi option
}
(* Type declarations *)
and 'a type_decl = {
and 'x type_decl = {
kwd_type : kwd_type;
name : 'a type_name;
name : 'x type_name;
kwd_is : kwd_is;
type_expr : 'a type_expr;
type_expr : 'x type_expr;
terminator : semi option
}
and 'a type_expr =
Prod of 'a cartesian
| Sum of ('a variant, vbar) nsepseq reg
| Record of 'a record_type
| TypeApp of ('a type_name * 'a type_tuple) reg
| ParType of 'a type_expr par
| TAlias of 'a variable
and 'x type_expr =
Prod of 'x cartesian
| Sum of ('x variant, vbar) nsepseq reg
| Record of 'x record_type
| TypeApp of ('x type_name * 'x type_tuple) reg
| ParType of 'x type_expr par
| TAlias of 'x variable
and 'a cartesian = ('a type_expr, times) nsepseq reg
and 'x cartesian = ('x type_expr, times) nsepseq reg
and 'a variant = ('a constr * kwd_of * 'a cartesian) reg
and 'x variant = ('x constr * kwd_of * 'x cartesian) reg
and 'a record_type = (kwd_record * 'a field_decls * kwd_end) reg
and 'x record_type = (kwd_record * 'x field_decls * kwd_end) reg
and 'a field_decls = ('a field_decl, semi) nsepseq
and 'x field_decls = ('x field_decl, semi) nsepseq
and 'a field_decl = ('a variable * colon * 'a type_expr) reg
and 'x field_decl = ('x variable * colon * 'x type_expr) reg
and 'a type_tuple = ('a type_name, comma) nsepseq par
and 'x type_tuple = ('x type_name, comma) nsepseq par
(* Function and procedure declarations *)
and 'a lambda_decl =
FunDecl of 'a fun_decl reg
| ProcDecl of 'a proc_decl reg
and 'x lambda_decl =
FunDecl of 'x fun_decl reg
| ProcDecl of 'x proc_decl reg
and 'a fun_decl = {
and 'x fun_decl = {
kwd_function : kwd_function;
name : 'a variable;
param : 'a parameters;
name : 'x variable;
param : 'x parameters;
colon : colon;
ret_type : 'a type_expr;
ret_type : 'x type_expr;
kwd_is : kwd_is;
local_decls : 'a local_decl list;
block : 'a block reg;
local_decls : 'x local_decl list;
block : 'x block reg;
kwd_with : kwd_with;
return : 'a expr;
return : 'x expr;
terminator : semi option
}
and 'a proc_decl = {
and 'x proc_decl = {
kwd_procedure : kwd_procedure;
name : 'a variable;
param : 'a parameters;
name : 'x variable;
param : 'x parameters;
kwd_is : kwd_is;
local_decls : 'a local_decl list;
block : 'a block reg;
local_decls : 'x local_decl list;
block : 'x block reg;
terminator : semi option
}
and 'a parameters = ('a param_decl, semi) nsepseq par
and 'x parameters = ('x param_decl, semi) nsepseq par
and 'a param_decl =
ParamConst of 'a param_const
| ParamVar of 'a param_var
and 'x param_decl =
ParamConst of 'x param_const
| ParamVar of 'x param_var
and 'a param_const = (kwd_const * 'a variable * colon * 'a type_expr) reg
and 'x param_const = (kwd_const * 'x variable * colon * 'x type_expr) reg
and 'a param_var = (kwd_var * 'a variable * colon * 'a type_expr) reg
and 'x param_var = (kwd_var * 'x variable * colon * 'x type_expr) reg
and 'a block = {
and 'x block = {
opening : kwd_begin;
instr : 'a instructions;
instr : 'x instructions;
terminator : semi option;
close : kwd_end
}
and 'a local_decl =
LocalLam of 'a lambda_decl
| LocalConst of 'a const_decl reg
| LocalVar of 'a var_decl reg
and 'x local_decl =
LocalLam of 'x lambda_decl
| LocalConst of 'x const_decl reg
| LocalVar of 'x var_decl reg
and 'a const_decl = {
and 'x const_decl = {
kwd_const : kwd_const;
name : 'a variable;
name : 'x variable;
colon : colon;
vtype : 'a type_expr;
vtype : 'x type_expr;
equal : equal;
init : 'a expr;
init : 'x expr;
terminator : semi option
}
and 'a var_decl = {
and 'x var_decl = {
kwd_var : kwd_var;
name : 'a variable;
name : 'x variable;
colon : colon;
vtype : 'a type_expr;
vtype : 'x type_expr;
ass : ass;
init : 'a expr;
init : 'x expr;
terminator : semi option
}
and 'a instructions = ('a instruction, semi) nsepseq reg
and 'x instructions = ('x instruction, semi) nsepseq reg
and 'a instruction =
Single of 'a single_instr
| Block of 'a block reg
and 'x instruction =
Single of 'x single_instr
| Block of 'x block reg
and 'a single_instr =
Cond of 'a conditional reg
| Match of 'a match_instr reg
| Ass of 'a ass_instr
| Loop of 'a loop
| ProcCall of 'a fun_call
and 'x single_instr =
Cond of 'x conditional reg
| Match of 'x match_instr reg
| Ass of 'x ass_instr
| Loop of 'x loop
| ProcCall of 'x fun_call
| Null of kwd_null
| Fail of (kwd_fail * 'a expr) reg
| Fail of (kwd_fail * 'x expr) reg
and 'a conditional = {
and 'x conditional = {
kwd_if : kwd_if;
test : 'a expr;
test : 'x expr;
kwd_then : kwd_then;
ifso : 'a instruction;
ifso : 'x instruction;
kwd_else : kwd_else;
ifnot : 'a instruction
ifnot : 'x instruction
}
and 'a match_instr = {
and 'x match_instr = {
kwd_match : kwd_match;
expr : 'a expr;
expr : 'x expr;
kwd_with : kwd_with;
lead_vbar : vbar option;
cases : 'a cases;
cases : 'x cases;
kwd_end : kwd_end
}
and 'a cases = ('a case, vbar) nsepseq reg
and 'x cases = ('x case, vbar) nsepseq reg
and 'a case = ('a pattern * arrow * 'a instruction) reg
and 'x case = ('x pattern * arrow * 'x instruction) reg
and 'a ass_instr = ('a variable * ass * 'a expr) reg
and 'x ass_instr = ('x variable * ass * 'x expr) reg
and 'a loop =
While of 'a while_loop
| For of 'a for_loop
and 'x loop =
While of 'x while_loop
| For of 'x for_loop
and 'a while_loop = (kwd_while * 'a expr * 'a block reg) reg
and 'x while_loop = (kwd_while * 'x expr * 'x block reg) reg
and 'a for_loop =
ForInt of 'a for_int reg
| ForCollect of 'a for_collect reg
and 'x for_loop =
ForInt of 'x for_int reg
| ForCollect of 'x for_collect reg
and 'a for_int = {
and 'x for_int = {
kwd_for : kwd_for;
ass : 'a ass_instr;
ass : 'x ass_instr;
down : kwd_down option;
kwd_to : kwd_to;
bound : 'a expr;
step : (kwd_step * 'a expr) option;
block : 'a block reg
bound : 'x expr;
step : (kwd_step * 'x expr) option;
block : 'x block reg
}
and 'a for_collect = {
and 'x for_collect = {
kwd_for : kwd_for;
var : 'a variable;
bind_to : (arrow * 'a variable) option;
var : 'x variable;
bind_to : (arrow * 'x variable) option;
kwd_in : kwd_in;
expr : 'a expr;
block : 'a block reg
expr : 'x expr;
block : 'x block reg
}
(* Expressions *)
and 'a expr =
Or of ('a expr * bool_or * 'a expr) reg
| And of ('a expr * bool_and * 'a expr) reg
| Lt of ('a expr * lt * 'a expr) reg
| Leq of ('a expr * leq * 'a expr) reg
| Gt of ('a expr * gt * 'a expr) reg
| Geq of ('a expr * geq * 'a expr) reg
| Equal of ('a expr * equal * 'a expr) reg
| Neq of ('a expr * neq * 'a expr) reg
| Cat of ('a expr * cat * 'a expr) reg
| Cons of ('a expr * cons * 'a expr) reg
| Add of ('a expr * plus * 'a expr) reg
| Sub of ('a expr * minus * 'a expr) reg
| Mult of ('a expr * times * 'a expr) reg
| Div of ('a expr * slash * 'a expr) reg
| Mod of ('a expr * kwd_mod * 'a expr) reg
| Neg of (minus * 'a expr) reg
| Not of (kwd_not * 'a expr) reg
and 'x expr =
Or of ('x expr * bool_or * 'x expr) reg
| And of ('x expr * bool_and * 'x expr) reg
| Lt of ('x expr * lt * 'x expr) reg
| Leq of ('x expr * leq * 'x expr) reg
| Gt of ('x expr * gt * 'x expr) reg
| Geq of ('x expr * geq * 'x expr) reg
| Equal of ('x expr * equal * 'x expr) reg
| Neq of ('x expr * neq * 'x expr) reg
| Cat of ('x expr * cat * 'x expr) reg
| Cons of ('x expr * cons * 'x expr) reg
| Add of ('x expr * plus * 'x expr) reg
| Sub of ('x expr * minus * 'x expr) reg
| Mult of ('x expr * times * 'x expr) reg
| Div of ('x expr * slash * 'x expr) reg
| Mod of ('x expr * kwd_mod * 'x expr) reg
| Neg of (minus * 'x expr) reg
| Not of (kwd_not * 'x expr) reg
| Int of (Lexer.lexeme * Z.t) reg
| Var of Lexer.lexeme reg
| String of Lexer.lexeme reg
@ -356,46 +356,46 @@ and 'a expr =
| False of c_False
| True of c_True
| Unit of c_Unit
| Tuple of 'a tuple
| List of ('a expr, comma) nsepseq brackets
| EmptyList of 'a empty_list
| Set of ('a expr, comma) nsepseq braces
| EmptySet of 'a empty_set
| NoneExpr of 'a none_expr
| FunCall of 'a fun_call
| ConstrApp of 'a constr_app
| SomeApp of (c_Some * 'a arguments) reg
| MapLookUp of 'a map_lookup reg
| ParExpr of 'a expr par
| Tuple of 'x tuple
| List of ('x expr, comma) nsepseq brackets
| EmptyList of 'x empty_list
| Set of ('x expr, comma) nsepseq braces
| EmptySet of 'x empty_set
| NoneExpr of 'x none_expr
| FunCall of 'x fun_call
| ConstrApp of 'x constr_app
| SomeApp of (c_Some * 'x arguments) reg
| MapLookUp of 'x map_lookup reg
| ParExpr of 'x expr par
and 'a tuple = ('a expr, comma) nsepseq par
and 'x tuple = ('x expr, comma) nsepseq par
and 'a empty_list =
(lbracket * rbracket * colon * 'a type_expr) par
and 'x empty_list =
(lbracket * rbracket * colon * 'x type_expr) par
and 'a empty_set =
(lbrace * rbrace * colon * 'a type_expr) par
and 'x empty_set =
(lbrace * rbrace * colon * 'x type_expr) par
and 'a none_expr =
(c_None * colon * 'a type_expr) par
and 'x none_expr =
(c_None * colon * 'x type_expr) par
and 'a fun_call = ('a fun_name * 'a arguments) reg
and 'x fun_call = ('x fun_name * 'x arguments) reg
and 'a arguments = 'a tuple
and 'x arguments = 'x tuple
and 'a constr_app = ('a constr * 'a arguments) reg
and 'x constr_app = ('x constr * 'x arguments) reg
and 'a map_lookup = {
map_name : 'a variable;
and 'x map_lookup = {
map_name : 'x variable;
selector : dot;
index : 'a expr brackets
index : 'x expr brackets
}
(* Patterns *)
and 'a pattern = ('a core_pattern, cons) nsepseq reg
and 'x pattern = ('x core_pattern, cons) nsepseq reg
and 'a core_pattern =
and 'x core_pattern =
PVar of Lexer.lexeme reg
| PWild of wild
| PInt of (Lexer.lexeme * Z.t) reg
@ -405,97 +405,97 @@ and 'a core_pattern =
| PFalse of c_False
| PTrue of c_True
| PNone of c_None
| PSome of (c_Some * 'a core_pattern par) reg
| PList of 'a list_pattern
| PTuple of ('a core_pattern, comma) nsepseq par
| PSome of (c_Some * 'x core_pattern par) reg
| PList of 'x list_pattern
| PTuple of ('x core_pattern, comma) nsepseq par
and 'a list_pattern =
Sugar of ('a core_pattern, comma) sepseq brackets
| Raw of ('a core_pattern * cons * 'a pattern) par
and 'x list_pattern =
Sugar of ('x core_pattern, comma) sepseq brackets
| Raw of ('x core_pattern * cons * 'x pattern) par
(* Projecting regions *)
val type_expr_to_region : 'a type_expr -> Region.t
val type_expr_to_region : 'x type_expr -> Region.t
val expr_to_region : 'a expr -> Region.t
val expr_to_region : 'x expr -> Region.t
val instr_to_region : 'a instruction -> Region.t
val instr_to_region : 'x instruction -> Region.t
val core_pattern_to_region : 'a core_pattern -> Region.t
val core_pattern_to_region : 'x core_pattern -> Region.t
val local_decl_to_region : 'a local_decl -> Region.t
val local_decl_to_region : 'x local_decl -> Region.t
type 'a visitor = {
ass_instr : 'a ass_instr -> unit;
bind_to : (Region.t * 'a variable) option -> unit;
block : 'a block reg -> unit;
type 'x visitor = {
ass_instr : 'x ass_instr -> unit;
bind_to : (Region.t * 'x variable) option -> unit;
block : 'x block reg -> unit;
bytes : (string * MBytes.t) reg -> unit;
cartesian : 'a cartesian -> unit;
case : 'a case -> unit;
cases : 'a cases -> unit;
conditional : 'a conditional -> unit;
const_decl : 'a const_decl reg -> unit;
constr : 'a constr -> unit;
constr_app : 'a constr_app -> unit;
core_pattern : 'a core_pattern -> unit;
cartesian : 'x cartesian -> unit;
case : 'x case -> unit;
cases : 'x cases -> unit;
conditional : 'x conditional -> unit;
const_decl : 'x const_decl reg -> unit;
constr : 'x constr -> unit;
constr_app : 'x constr_app -> unit;
core_pattern : 'x core_pattern -> unit;
down : Region.t option -> unit;
empty_list : 'a empty_list -> unit;
empty_set : 'a empty_set -> unit;
expr : 'a expr -> unit;
fail : (kwd_fail * 'a expr) -> unit;
field_decl : 'a field_decl -> unit;
field_decls : 'a field_decls -> unit;
for_collect : 'a for_collect reg -> unit;
for_int : 'a for_int reg -> unit;
for_loop : 'a for_loop -> unit;
fun_call : 'a fun_call -> unit;
fun_decl : 'a fun_decl reg -> unit;
instruction : 'a instruction -> unit;
instructions : 'a instructions -> unit;
empty_list : 'x empty_list -> unit;
empty_set : 'x empty_set -> unit;
expr : 'x expr -> unit;
fail : (kwd_fail * 'x expr) -> unit;
field_decl : 'x field_decl -> unit;
field_decls : 'x field_decls -> unit;
for_collect : 'x for_collect reg -> unit;
for_int : 'x for_int reg -> unit;
for_loop : 'x for_loop -> unit;
fun_call : 'x fun_call -> unit;
fun_decl : 'x fun_decl reg -> unit;
instruction : 'x instruction -> unit;
instructions : 'x instructions -> unit;
int : (string * Z.t) reg -> unit;
lambda_decl : 'a lambda_decl -> unit;
list : ('a expr, Region.t) nsepseq brackets -> unit;
list_pattern : 'a list_pattern -> unit;
loop : 'a loop -> unit;
map_lookup : 'a map_lookup reg -> unit;
match_instr : 'a match_instr -> unit;
none_expr : 'a none_expr -> unit;
nsepseq : 'a.string -> ('a -> unit) -> ('a, Region.t) nsepseq -> unit;
operations_decl : 'a operations_decl reg -> unit;
par_expr : 'a expr par -> unit;
par_type : 'a type_expr par -> unit;
param_decl : 'a param_decl -> unit;
parameter_decl : 'a parameter_decl reg -> unit;
parameters : 'a parameters -> unit;
param_const : 'a param_const -> unit;
param_var : 'a param_var -> unit;
pattern : 'a pattern -> unit;
patterns : 'a core_pattern par -> unit;
proc_decl : 'a proc_decl reg -> unit;
psome : (Region.t * 'a core_pattern par) reg -> unit;
ptuple : ('a core_pattern, Region.t) nsepseq par -> unit;
raw : ('a core_pattern * Region.t * 'a pattern) par -> unit;
record_type : 'a record_type -> unit;
sepseq : 'a.string -> ('a -> unit) -> ('a, Region.t) sepseq -> unit;
set : ('a expr, Region.t) nsepseq braces -> unit;
single_instr : 'a single_instr -> unit;
some_app : (Region.t * 'a arguments) reg -> unit;
step : (Region.t * 'a expr) option -> unit;
storage_decl : 'a storage_decl reg -> unit;
lambda_decl : 'x lambda_decl -> unit;
list : ('x expr, Region.t) nsepseq brackets -> unit;
list_pattern : 'x list_pattern -> unit;
loop : 'x loop -> unit;
map_lookup : 'x map_lookup reg -> unit;
match_instr : 'x match_instr -> unit;
none_expr : 'x none_expr -> unit;
nsepseq : 'x.string -> ('x -> unit) -> ('x, Region.t) nsepseq -> unit;
operations_decl : 'x operations_decl reg -> unit;
par_expr : 'x expr par -> unit;
par_type : 'x type_expr par -> unit;
param_decl : 'x param_decl -> unit;
parameter_decl : 'x parameter_decl reg -> unit;
parameters : 'x parameters -> unit;
param_const : 'x param_const -> unit;
param_var : 'x param_var -> unit;
pattern : 'x pattern -> unit;
patterns : 'x core_pattern par -> unit;
proc_decl : 'x proc_decl reg -> unit;
psome : (Region.t * 'x core_pattern par) reg -> unit;
ptuple : ('x core_pattern, Region.t) nsepseq par -> unit;
raw : ('x core_pattern * Region.t * 'x pattern) par -> unit;
record_type : 'x record_type -> unit;
sepseq : 'x.string -> ('x -> unit) -> ('x, Region.t) sepseq -> unit;
set : ('x expr, Region.t) nsepseq braces -> unit;
single_instr : 'x single_instr -> unit;
some_app : (Region.t * 'x arguments) reg -> unit;
step : (Region.t * 'x expr) option -> unit;
storage_decl : 'x storage_decl reg -> unit;
string : string reg -> unit;
sugar : ('a core_pattern, Region.t) sepseq brackets -> unit;
sum_type : ('a variant, Region.t) nsepseq reg -> unit;
sugar : ('x core_pattern, Region.t) sepseq brackets -> unit;
sum_type : ('x variant, Region.t) nsepseq reg -> unit;
terminator : semi option -> unit;
token : Region.t -> string -> unit;
tuple : 'a arguments -> unit;
type_app : ('a type_name * 'a type_tuple) reg -> unit;
type_decl : 'a type_decl reg -> unit;
type_expr : 'a type_expr -> unit;
type_tuple : 'a type_tuple -> unit;
local_decl : 'a local_decl -> unit;
local_decls : 'a local_decl list -> unit;
var : 'a variable -> unit;
var_decl : 'a var_decl reg -> unit;
variant : 'a variant -> unit;
while_loop : 'a while_loop -> unit
tuple : 'x arguments -> unit;
type_app : ('x type_name * 'x type_tuple) reg -> unit;
type_decl : 'x type_decl reg -> unit;
type_expr : 'x type_expr -> unit;
type_tuple : 'x type_tuple -> unit;
local_decl : 'x local_decl -> unit;
local_decls : 'x local_decl list -> unit;
var : 'x variable -> unit;
var_decl : 'x var_decl reg -> unit;
variant : 'x variant -> unit;
while_loop : 'x while_loop -> unit
}

132
Print.ml
View File

@ -47,7 +47,7 @@ and print_int _visitor {region; value = lexeme, abstract} =
(* Main printing function *)
and print_tokens (v: 'a visitor) ast =
and print_tokens (v: 'x visitor) ast =
List.iter v.type_decl ast.types;
v.parameter_decl ast.parameter;
v.storage_decl ast.storage;
@ -56,31 +56,31 @@ and print_tokens (v: 'a visitor) ast =
v.block ast.block;
v.token ast.eof "EOF"
and print_parameter_decl (v: 'a visitor) {value=node; _} =
and print_parameter_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_parameter "parameter";
v.var node.name;
v.token node.colon ":";
v.type_expr node.param_type;
v.terminator node.terminator
and print_storage_decl (v: 'a visitor) {value=node; _} =
and print_storage_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_storage "storage";
v.type_expr node.store_type;
v.terminator node.terminator
and print_operations_decl (v: 'a visitor) {value=node; _} =
and print_operations_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_operations "operations";
v.type_expr node.op_type;
v.terminator node.terminator
and print_type_decl (v: 'a visitor) {value=node; _} =
and print_type_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_type "type";
v.var node.name;
v.token node.kwd_is "is";
v.type_expr node.type_expr;
v.terminator node.terminator
and print_type_expr (v: 'a visitor) = function
and print_type_expr (v: 'x visitor) = function
Prod cartesian -> v.cartesian cartesian
| Sum sum_type -> v.sum_type sum_type
| Record record_type -> v.record_type record_type
@ -88,55 +88,55 @@ and print_type_expr (v: 'a visitor) = function
| ParType par_type -> v.par_type par_type
| TAlias type_alias -> v.var type_alias
and print_cartesian (v: 'a visitor) {value=sequence; _} =
and print_cartesian (v: 'x visitor) {value=sequence; _} =
v.nsepseq "*" v.type_expr sequence
and print_variant (v: 'a visitor) {value=node; _} =
and print_variant (v: 'x visitor) {value=node; _} =
let constr, kwd_of, cartesian = node in
v.constr constr;
v.token kwd_of "of";
v.cartesian cartesian
and print_sum_type (v: 'a visitor) {value=sequence; _} =
and print_sum_type (v: 'x visitor) {value=sequence; _} =
v.nsepseq "|" v.variant sequence
and print_record_type (v: 'a visitor) {value=node; _} =
and print_record_type (v: 'x visitor) {value=node; _} =
let kwd_record, field_decls, kwd_end = node in
v.token kwd_record "record";
v.field_decls field_decls;
v.token kwd_end "end"
and print_type_app (v: 'a visitor) {value=node; _} =
and print_type_app (v: 'x visitor) {value=node; _} =
let type_name, type_tuple = node in
v.var type_name;
v.type_tuple type_tuple
and print_par_type (v: 'a visitor) {value=node; _} =
and print_par_type (v: 'x visitor) {value=node; _} =
let lpar, type_expr, rpar = node in
v.token lpar "(";
v.type_expr type_expr;
v.token rpar ")"
and print_field_decls (v: 'a visitor) sequence =
and print_field_decls (v: 'x visitor) sequence =
v.nsepseq ";" v.field_decl sequence
and print_field_decl (v: 'a visitor) {value=node; _} =
and print_field_decl (v: 'x visitor) {value=node; _} =
let var, colon, type_expr = node in
v.var var;
v.token colon ":";
v.type_expr type_expr
and print_type_tuple (v: 'a visitor) {value=node; _} =
and print_type_tuple (v: 'x visitor) {value=node; _} =
let lpar, sequence, rpar = node in
v.token lpar "(";
v.nsepseq "," v.var sequence;
v.token rpar ")"
and print_lambda_decl (v: 'a visitor) = function
and print_lambda_decl (v: 'x visitor) = function
FunDecl fun_decl -> v.fun_decl fun_decl
| ProcDecl proc_decl -> v.proc_decl proc_decl
and print_fun_decl (v: 'a visitor) {value=node; _} =
and print_fun_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_function "function";
v.var node.name;
v.parameters node.param;
@ -149,7 +149,7 @@ and print_fun_decl (v: 'a visitor) {value=node; _} =
v.expr node.return;
v.terminator node.terminator
and print_proc_decl (v: 'a visitor) {value=node; _} =
and print_proc_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_procedure "procedure";
v.var node.name;
v.parameters node.param;
@ -158,45 +158,45 @@ and print_proc_decl (v: 'a visitor) {value=node; _} =
v.block node.block;
v.terminator node.terminator
and print_parameters (v: 'a visitor) {value=node; _} =
and print_parameters (v: 'x visitor) {value=node; _} =
let lpar, sequence, rpar = node in
v.token lpar "(";
v.nsepseq ";" v.param_decl sequence;
v.token rpar ")"
and print_param_decl (v: 'a visitor) = function
and print_param_decl (v: 'x visitor) = function
ParamConst param_const -> v.param_const param_const
| ParamVar param_var -> v.param_var param_var
and print_param_const (v: 'a visitor) {value=node; _} =
and print_param_const (v: 'x visitor) {value=node; _} =
let kwd_const, variable, colon, type_expr = node in
v.token kwd_const "const";
v.var variable;
v.token colon ":";
v.type_expr type_expr
and print_param_var (v: 'a visitor) {value=node; _} =
and print_param_var (v: 'x visitor) {value=node; _} =
let kwd_var, variable, colon, type_expr = node in
v.token kwd_var "var";
v.var variable;
v.token colon ":";
v.type_expr type_expr
and print_block (v: 'a visitor) {value=node; _} =
and print_block (v: 'x visitor) {value=node; _} =
v.token node.opening "begin";
v.instructions node.instr;
v.terminator node.terminator;
v.token node.close "end"
and print_local_decls (v: 'a visitor) sequence =
and print_local_decls (v: 'x visitor) sequence =
List.iter v.local_decl sequence
and print_local_decl (v: 'a visitor) = function
and print_local_decl (v: 'x visitor) = function
LocalLam decl -> v.lambda_decl decl
| LocalConst decl -> v.const_decl decl
| LocalVar decl -> v.var_decl decl
and print_const_decl (v: 'a visitor) {value=node; _} =
and print_const_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_const "const";
v.var node.name;
v.token node.colon ":";
@ -205,7 +205,7 @@ and print_const_decl (v: 'a visitor) {value=node; _} =
v.expr node.init;
v.terminator node.terminator
and print_var_decl (v: 'a visitor) {value=node; _} =
and print_var_decl (v: 'x visitor) {value=node; _} =
v.token node.kwd_var "var";
v.var node.name;
v.token node.colon ":";
@ -214,14 +214,14 @@ and print_var_decl (v: 'a visitor) {value=node; _} =
v.expr node.init;
v.terminator node.terminator
and print_instructions (v: 'a visitor) {value=sequence; _} =
and print_instructions (v: 'x visitor) {value=sequence; _} =
v.nsepseq ";" v.instruction sequence
and print_instruction (v: 'a visitor) = function
and print_instruction (v: 'x visitor) = function
Single instr -> v.single_instr instr
| Block block -> v.block block
and print_single_instr (v: 'a visitor) = function
and print_single_instr (v: 'x visitor) = function
Cond {value; _} -> v.conditional value
| Match {value; _} -> v.match_instr value
| Ass instr -> v.ass_instr instr
@ -230,11 +230,11 @@ and print_single_instr (v: 'a visitor) = function
| Null kwd_null -> v.token kwd_null "null"
| Fail {value; _} -> v.fail value
and print_fail (v: 'a visitor) (kwd_fail, expr) =
and print_fail (v: 'x visitor) (kwd_fail, expr) =
v.token kwd_fail "fail";
v.expr expr
and print_conditional (v: 'a visitor) node =
and print_conditional (v: 'x visitor) node =
v.token node.kwd_if "if";
v.expr node.test;
v.token node.kwd_then "then";
@ -242,43 +242,43 @@ and print_conditional (v: 'a visitor) node =
v.token node.kwd_else "else";
v.instruction node.ifnot
and print_match_instr (v: 'a visitor) node =
and print_match_instr (v: 'x visitor) node =
v.token node.kwd_match "match";
v.expr node.expr;
v.token node.kwd_with "with";
v.cases node.cases;
v.token node.kwd_end "end"
and print_cases (v: 'a visitor) {value=sequence; _} =
and print_cases (v: 'x visitor) {value=sequence; _} =
v.nsepseq "|" v.case sequence
and print_case (v: 'a visitor) {value=node; _} =
and print_case (v: 'x visitor) {value=node; _} =
let pattern, arrow, instruction = node in
v.pattern pattern;
v.token arrow "->";
v.instruction instruction
and print_ass_instr (v: 'a visitor) {value=node; _} =
and print_ass_instr (v: 'x visitor) {value=node; _} =
let variable, ass, expr = node in
v.var variable;
v.token ass ":=";
v.expr expr
and print_loop (v: 'a visitor) = function
and print_loop (v: 'x visitor) = function
While while_loop -> v.while_loop while_loop
| For for_loop -> v.for_loop for_loop
and print_while_loop (v: 'a visitor) {value=node; _} =
and print_while_loop (v: 'x visitor) {value=node; _} =
let kwd_while, expr, block = node in
v.token kwd_while "while";
v.expr expr;
v.block block
and print_for_loop (v: 'a visitor) = function
and print_for_loop (v: 'x visitor) = function
ForInt for_int -> v.for_int for_int
| ForCollect for_collect -> v.for_collect for_collect
and print_for_int (v: 'a visitor) ({value=node; _} : 'a for_int reg) =
and print_for_int (v: 'x visitor) ({value=node; _} : 'x for_int reg) =
v.token node.kwd_for "for";
v.ass_instr node.ass;
v.down node.down;
@ -287,17 +287,17 @@ and print_for_int (v: 'a visitor) ({value=node; _} : 'a for_int reg) =
v.step node.step;
v.block node.block
and print_down (v: 'a visitor) = function
and print_down (v: 'x visitor) = function
Some kwd_down -> v.token kwd_down "down"
| None -> ()
and print_step (v: 'a visitor) = function
and print_step (v: 'x visitor) = function
Some (kwd_step, expr) ->
v.token kwd_step "step";
v.expr expr
| None -> ()
and print_for_collect (v: 'a visitor) ({value=node; _} : 'a for_collect reg) =
and print_for_collect (v: 'x visitor) ({value=node; _} : 'x for_collect reg) =
v.token node.kwd_for "for";
v.var node.var;
v.bind_to node.bind_to;
@ -305,13 +305,13 @@ and print_for_collect (v: 'a visitor) ({value=node; _} : 'a for_collect reg) =
v.expr node.expr;
v.block node.block
and print_bind_to (v: 'a visitor) = function
and print_bind_to (v: 'x visitor) = function
Some (arrow, variable) ->
v.token arrow "->";
v.var variable
| None -> ()
and print_expr (v: 'a visitor) = function
and print_expr (v: 'x visitor) = function
Or {value = expr1, bool_or, expr2; _} ->
v.expr expr1; v.token bool_or "||"; v.expr expr2
| And {value = expr1, bool_and, expr2; _} ->
@ -365,19 +365,19 @@ and print_expr (v: 'a visitor) = function
| MapLookUp lookup -> v.map_lookup lookup
| ParExpr pexpr -> v.par_expr pexpr
and print_tuple (v: 'a visitor) {value=node; _} =
and print_tuple (v: 'x visitor) {value=node; _} =
let lpar, sequence, rpar = node in
v.token lpar "(";
v.nsepseq "," v.expr sequence;
v.token rpar ")"
and print_list (v: 'a visitor) {value=node; _} =
and print_list (v: 'x visitor) {value=node; _} =
let lbra, sequence, rbra = node in
v.token lbra "[";
v.nsepseq "," v.expr sequence;
v.token rbra "]"
and print_empty_list (v: 'a visitor) {value=node; _} =
and print_empty_list (v: 'x visitor) {value=node; _} =
let lpar, (lbracket, rbracket, colon, type_expr), rpar = node in
v.token lpar "(";
v.token lbracket "[";
@ -386,13 +386,13 @@ and print_empty_list (v: 'a visitor) {value=node; _} =
v.type_expr type_expr;
v.token rpar ")"
and print_set (v: 'a visitor) {value=node; _} =
and print_set (v: 'x visitor) {value=node; _} =
let lbrace, sequence, rbrace = node in
v.token lbrace "{";
v.nsepseq "," v.expr sequence;
v.token rbrace "}"
and print_empty_set (v: 'a visitor) {value=node; _} =
and print_empty_set (v: 'x visitor) {value=node; _} =
let lpar, (lbrace, rbrace, colon, type_expr), rpar = node in
v.token lpar "(";
v.token lbrace "{";
@ -401,7 +401,7 @@ and print_empty_set (v: 'a visitor) {value=node; _} =
v.type_expr type_expr;
v.token rpar ")"
and print_none_expr (v: 'a visitor) {value=node; _} =
and print_none_expr (v: 'x visitor) {value=node; _} =
let lpar, (c_None, colon, type_expr), rpar = node in
v.token lpar "(";
v.token c_None "None";
@ -409,22 +409,22 @@ and print_none_expr (v: 'a visitor) {value=node; _} =
v.type_expr type_expr;
v.token rpar ")"
and print_fun_call (v: 'a visitor) {value=node; _} =
and print_fun_call (v: 'x visitor) {value=node; _} =
let fun_name, arguments = node in
v.var fun_name;
v.tuple arguments
and print_constr_app (v: 'a visitor) {value=node; _} =
and print_constr_app (v: 'x visitor) {value=node; _} =
let constr, arguments = node in
v.constr constr;
v.tuple arguments
and print_some_app (v: 'a visitor) {value=node; _} =
and print_some_app (v: 'x visitor) {value=node; _} =
let c_Some, arguments = node in
v.token c_Some "Some";
v.tuple arguments
and print_map_lookup (v: 'a visitor) {value=node; _} =
and print_map_lookup (v: 'x visitor) {value=node; _} =
let {value = lbracket, expr, rbracket; _} = node.index in
v.var node.map_name;
v.token node.selector ".";
@ -432,16 +432,16 @@ and print_map_lookup (v: 'a visitor) {value=node; _} =
v.expr expr;
v.token rbracket "]"
and print_par_expr (v: 'a visitor) {value=node; _} =
and print_par_expr (v: 'x visitor) {value=node; _} =
let lpar, expr, rpar = node in
v.token lpar "(";
v.expr expr;
v.token rpar ")"
and print_pattern (v: 'a visitor) {value=sequence; _} =
and print_pattern (v: 'x visitor) {value=sequence; _} =
v.nsepseq "<:" v.core_pattern sequence
and print_core_pattern (v: 'a visitor) = function
and print_core_pattern (v: 'x visitor) = function
PVar var -> v.var var
| PWild wild -> v.token wild "_"
| PInt i -> v.int i
@ -455,28 +455,28 @@ and print_core_pattern (v: 'a visitor) = function
| PList pattern -> v.list_pattern pattern
| PTuple ptuple -> v.ptuple ptuple
and print_psome (v: 'a visitor) {value=node; _} =
and print_psome (v: 'x visitor) {value=node; _} =
let c_Some, patterns = node in
v.token c_Some "Some";
v.patterns patterns
and print_patterns (v: 'a visitor) {value=node; _} =
and print_patterns (v: 'x visitor) {value=node; _} =
let lpar, core_pattern, rpar = node in
v.token lpar "(";
v.core_pattern core_pattern;
v.token rpar ")"
and print_list_pattern (v: 'a visitor) = function
and print_list_pattern (v: 'x visitor) = function
Sugar sugar -> v.sugar sugar
| Raw raw -> v.raw raw
and print_sugar (v: 'a visitor) {value=node; _} =
and print_sugar (v: 'x visitor) {value=node; _} =
let lbracket, sequence, rbracket = node in
v.token lbracket "[";
v.sepseq "," v.core_pattern sequence;
v.token rbracket "]"
and print_raw (v: 'a visitor) {value=node; _} =
and print_raw (v: 'x visitor) {value=node; _} =
let lpar, (core_pattern, cons, pattern), rpar = node in
v.token lpar "(";
v.core_pattern core_pattern;
@ -484,17 +484,17 @@ and print_raw (v: 'a visitor) {value=node; _} =
v.pattern pattern;
v.token rpar ")"
and print_ptuple (v: 'a visitor) {value=node; _} =
and print_ptuple (v: 'x visitor) {value=node; _} =
let lpar, sequence, rpar = node in
v.token lpar "(";
v.nsepseq "," v.core_pattern sequence;
v.token rpar ")"
and print_terminator (v: 'a visitor) = function
and print_terminator (v: 'x visitor) = function
Some semi -> v.token semi ";"
| None -> ()
let rec visitor () : 'a visitor = {
let rec visitor () : 'x visitor = {
nsepseq = print_nsepseq;
sepseq = print_sepseq;
token = print_token (visitor ());