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

Further reducing the distance from Ligodity AST to Pascaligo AST.

Browse Source
This commit is contained in:
Christian Rinderknecht 2019-05-13 12:28:10 +02:00 committed by Georges Dupéron
parent dcbfbf781d
commit 0796567aee
10 changed files with 172 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/parser/dune
View File

@ -6,6 +6,7 @@
tezos-utils
parser_pascaligo
parser_camligo
parser_ligodity
)
(preprocess
(pps simple-utils.ppx_let_generalized)

200
src/parser/ligodity/AST.ml
View File

@ -76,6 +76,10 @@ type colon = Region.t (* ":" *)
type wild = Region.t (* "_" *)
(* Virtual tokens *)
type eof = Region.t
(* Literals *)
type variable = string reg
@ -98,9 +102,9 @@ type the_unit = lpar * rpar
(* Brackets compounds *)
type 'a brackets = {
lbracket : lbracket;
inside : 'a;
rbracket : rbracket
lbracket : lbracket;
inside : 'a;
rbracket : rbracket
}
(* The Abstract Syntax Tree *)
@ -112,8 +116,6 @@ type t = {
and ast = t
and eof = Region.t
and declaration =
Let of (kwd_let * let_bindings) reg
| LetEntry of (kwd_let_entry * let_binding) reg
@ -130,7 +132,7 @@ and let_binding = {
let_rhs : expr
}
(* Recursive types *)
(* Type declarations *)
and type_decl = {
kwd_type : kwd_type;
@ -165,24 +167,9 @@ and field_decl = {
and type_tuple = (type_expr, comma) Utils.nsepseq par
and 'a injection = {
opening : opening;
elements : ('a, semi) Utils.sepseq;
terminator : semi option;
closing : closing
}
and opening =
Begin of kwd_begin
| LBrace of lbrace
and closing =
End of kwd_end
| RBrace of rbrace
and pattern =
PTuple of (pattern, comma) Utils.nsepseq reg
| PList of (pattern, semi) Utils.sepseq brackets reg
| PList of list_pattern
| PVar of variable
| PUnit of the_unit reg
| PInt of (string * Z.t) reg
@ -190,12 +177,15 @@ and pattern =
| PFalse of kwd_false
| PString of string reg
| PWild of wild
| PCons of (pattern * cons * pattern) reg
| PPar of pattern par reg
| PConstr of (constr * pattern option) reg
| PRecord of record_pattern
| PTyped of typed_pattern reg
and list_pattern =
Sugar of pattern injection reg
| PCons of (pattern * cons * pattern) reg
and typed_pattern = {
pattern : pattern;
colon : colon;
@ -211,28 +201,45 @@ and field_pattern = {
}
and expr =
LetIn of let_in reg
| Fun of fun_expr
| If of conditional
ELetIn of let_in reg
| EFun of fun_expr
| ECond of conditional
| ETuple of (expr, comma) Utils.nsepseq reg
| Match of match_expr reg
| Seq of sequence
| EMatch of match_expr reg
| ESeq of sequence
| ERecord of record_expr
| Append of (expr * append * expr) reg
| Cons of (expr * cons * expr) reg
| ELogic of logic_expr
| EArith of arith_expr
| EString of string_expr
| Call of (expr * expr) reg
| ECall of (expr * expr) reg
| Path of path reg
| Unit of the_unit reg
| Par of expr par reg
| EList of (expr, semi) Utils.sepseq brackets reg
| EUnit of the_unit reg
| EPar of expr par reg
| EList of list_expr
| EConstr of constr
and 'a injection = {
opening : opening;
elements : ('a, semi) Utils.sepseq;
terminator : semi option;
closing : closing
}
and opening =
Begin of kwd_begin
| LBrace of lbrace
| LBracket of lbracket
and closing =
End of kwd_end
| RBrace of rbrace
| RBracket of rbracket
and list_expr =
Cons of cons bin_op reg
| List of expr injection reg
| Append of (expr * append * expr) reg
and string_expr =
Cat of cat bin_op reg
| String of string reg
@ -314,10 +321,14 @@ and conditional =
let sprintf = Printf.sprintf
let region_of_list_pattern = function
Sugar {region; _} | PCons {region; _} -> region
let region_of_pattern = function
PList {region;_} | PTuple {region;_} | PVar {region;_}
PList p -> region_of_list_pattern p
| PTuple {region;_} | PVar {region;_}
| PUnit {region;_} | PInt {region;_} | PTrue region | PFalse region
| PString {region;_} | PWild region | PCons {region;_}
| PString {region;_} | PWild region
| PConstr {region; _} | PPar {region;_} | PRecord {region; _}
| PTyped {region; _} -> region
@ -344,39 +355,21 @@ let region_of_arith_expr = function
let region_of_string_expr = function
String {region;_} | Cat {region;_} -> region
let region_of_list_expr = function
Cons {region; _} | List {region; _} | Append {region; _} -> region
let region_of_expr = function
ELogic e -> region_of_logic_expr e
| EArith e -> region_of_arith_expr e
| EString e -> region_of_string_expr e
| LetIn {region;_} | Fun {region;_}
| If IfThen {region;_} | If IfThenElse {region; _}
| ETuple {region;_} | Match {region;_} | Cons {region;_}
| Call {region;_} | Path {region;_}
| Unit {region;_} | Par {region;_} | EList {region;_}
| Seq {region; _} | ERecord {region; _}
| Append {region; _} | EConstr {region; _} -> region
(* Predicates *)
let rec is_var = function
Par {value={inside=e;_};_} -> is_var e
| Path _ -> true
| _ -> false
let rec is_call = function
Par {value={inside=e;_};_} -> is_call e
| Call _ -> true
| _ -> false
let rec is_fun = function
Par {value={inside=e;_};_} -> is_fun e
| Fun _ -> true
| _ -> false
let rec rm_par = function
Par {value={inside=e;_};_} -> rm_par e
| e -> e
| EList e -> region_of_list_expr e
| ELetIn {region;_} | EFun {region;_}
| ECond IfThen {region;_} | ECond IfThenElse {region; _}
| ETuple {region;_} | EMatch {region;_}
| ECall {region;_} | Path {region;_}
| EUnit {region;_} | EPar {region;_}
| ESeq {region; _} | ERecord {region; _}
| EConstr {region; _} -> region
(* Rewriting let-expressions and fun-expressions, with some optimisations *)
@ -397,7 +390,7 @@ let norm_fun region kwd_fun pattern eq expr =
let bindings = {pattern; eq;
lhs_type=None; let_rhs = Path path}, [] in
let let_in = ghost_let, bindings, ghost_in, expr in
let expr = LetIn {value=let_in; region=Region.ghost}
let expr = ELetIn {value=let_in; region=Region.ghost}
in kwd_fun, fresh, ghost_arrow, expr
in Region.{region; value}
@ -407,7 +400,7 @@ let norm ?reg (pattern, patterns) sep expr =
None -> Region.ghost, ghost_fun
| Some p -> p in
let apply pattern (sep, expr) =
ghost_eq, Fun (norm_fun Region.ghost ghost_fun pattern sep expr) in
ghost_eq, EFun (norm_fun Region.ghost ghost_fun pattern sep expr) in
let sep, expr = List.fold_right apply patterns (sep, expr)
in norm_fun reg fun_reg pattern sep expr
@ -425,10 +418,10 @@ type unparsed = [
sign or "->". *)
let rec unparse' = function
Fun {value=_,var,arrow,expr; _} ->
EFun {value=_,var,arrow,expr; _} ->
if var.region#is_ghost then
match expr with
LetIn {value = _,({pattern;eq;_},[]),_,expr; _} ->
ELetIn {value = _,({pattern;eq;_},[]),_,expr; _} ->
if eq#is_ghost then
let patterns, sep, e = unparse' expr
in Utils.nseq_cons pattern patterns, sep, e
@ -441,7 +434,7 @@ let rec unparse' = function
| _ -> assert false
let unparse = function
Fun {value=kwd_fun,_,_,_; _} as e ->
EFun {value=kwd_fun,_,_,_; _} as e ->
let binding = unparse' e in
if kwd_fun#is_ghost then `Let binding else `Fun (kwd_fun, binding)
| e -> `Idem e
@ -460,7 +453,6 @@ let print_sepseq sep print = function
let print_csv print = print_nsepseq "," print
let print_bsv print = print_nsepseq "|" print
let print_ssv print = print_sepseq ";" print
let print_token (reg: Region.t) conc =
Printf.printf "%s: %s\n" (reg#compact `Byte) conc
@ -570,12 +562,14 @@ and print_injection :
print_closing closing
and print_opening = function
Begin region -> print_token region "begin"
| LBrace region -> print_token region "{"
Begin region -> print_token region "begin"
| LBrace region -> print_token region "{"
| LBracket region -> print_token region "["
and print_closing = function
End region -> print_token region "end"
| RBrace region -> print_token region "}"
End region -> print_token region "end"
| RBrace region -> print_token region "}"
| RBracket region -> print_token region "]"
and print_terminator = function
Some semi -> print_token semi ";"
@ -608,10 +602,7 @@ and print_let_binding undo {pattern; lhs_type; eq; let_rhs} =
and print_pattern = function
PTuple {value=patterns;_} -> print_csv print_pattern patterns
| PList {value={lbracket; inside=patterns; rbracket}; _} ->
print_token lbracket "[";
print_ssv print_pattern patterns;
print_token rbracket "]"
| PList p -> print_list_pattern p
| PVar {region; value} ->
Printf.printf "%s: PVar %s\n" (region#compact `Byte) value
| PUnit {value=lpar,rpar; _} ->
@ -622,14 +613,19 @@ and print_pattern = function
| PFalse kwd_false -> print_token kwd_false "false"
| PString s -> print_str s
| PWild wild -> print_token wild "_"
| PCons {value=p1,c,p2; _} ->
print_pattern p1; print_token c "::"; print_pattern p2
| PPar {value={lpar;inside=p;rpar}; _} ->
print_token lpar "("; print_pattern p; print_token rpar ")"
| PConstr p -> print_constr_pattern p
| PRecord r -> print_record_pattern r
| PTyped t -> print_typed_pattern t
and print_list_pattern = function
Sugar p -> print_injection print_pattern p
| PCons p -> print_raw p
and print_raw {value=p1,c,p2; _} =
print_pattern p1; print_token c "::"; print_pattern p2
and print_typed_pattern {value; _} =
let {pattern; colon; type_expr} = value in
print_pattern pattern;
@ -652,11 +648,11 @@ and print_constr_pattern {value=constr, p_opt; _} =
| Some pattern -> print_pattern pattern
and print_expr undo = function
LetIn {value;_} -> print_let_in undo value
| If cond -> print_conditional undo cond
| ETuple {value;_} -> print_csv (print_expr undo) value
| Match {value;_} -> print_match_expr undo value
| Fun {value=(kwd_fun,_,_,_) as f; _} as e ->
ELetIn {value;_} -> print_let_in undo value
| ECond cond -> print_conditional undo cond
| ETuple {value;_} -> print_csv (print_expr undo) value
| EMatch {value;_} -> print_match_expr undo value
| EFun {value=(kwd_fun,_,_,_) as f; _} as e ->
if undo then
let patterns, arrow, expr = unparse' e in
print_token kwd_fun "fun";
@ -665,26 +661,32 @@ and print_expr undo = function
print_expr undo expr
else print_fun_expr undo f
| Cons {value=e1,cons,e2; _} ->
print_expr undo e1; print_token cons "::"; print_expr undo e2
| ELogic e -> print_logic_expr undo e
| EArith e -> print_arith_expr undo e
| EString e -> print_string_expr undo e
| Call {value=e1,e2; _} -> print_expr undo e1; print_expr undo e2
| ECall {value=e1,e2; _} -> print_expr undo e1; print_expr undo e2
| Path p -> print_path p
| Unit {value=lpar,rpar; _} ->
| EUnit {value=lpar,rpar; _} ->
print_token lpar "("; print_token rpar ")"
| Par {value={lpar;inside=e;rpar}; _} ->
| EPar {value={lpar;inside=e;rpar}; _} ->
print_token lpar "("; print_expr undo e; print_token rpar ")"
| EList {value={lbracket; inside=ssv; rbracket}; _} ->
print_token lbracket "["; print_ssv (print_expr undo) ssv; print_token rbracket "]"
| Seq seq -> print_sequence undo seq
| EList e -> print_list_expr undo e
| ESeq seq -> print_sequence undo seq
| ERecord e -> print_record_expr undo e
| Append {value=e1,append,e2; _} ->
print_expr undo e1; print_token append "@"; print_expr undo e2
| EConstr constr -> print_uident constr
and print_list_expr undo = function
Cons {value={arg1;op;arg2}; _} ->
print_expr undo arg1;
print_token op "::";
print_expr undo arg2
| List e -> print_injection (print_expr undo) e
| Append {value=e1,append,e2; _} ->
print_expr undo e1;
print_token append "@";
print_expr undo e2
and print_arith_expr undo = function
Add {value={arg1;op;arg2}; _} ->
print_expr undo arg1; print_token op "+"; print_expr undo arg2

104
src/parser/ligodity/AST.mli
View File

@ -185,16 +185,18 @@ and 'a injection = {
}
and opening =
Begin of kwd_begin
| LBrace of lbrace
Begin of kwd_begin
| LBrace of lbrace
| LBracket of lbracket
and closing =
End of kwd_end
| RBrace of rbrace
End of kwd_end
| RBrace of rbrace
| RBracket of rbracket
and pattern =
PTuple of (pattern, comma) Utils.nsepseq reg (* p1, p2, ... *)
| PList of (pattern, semi) Utils.sepseq brackets reg (* [p1; p2; ...] *)
| PList of list_pattern
| PVar of variable (* x *)
| PUnit of the_unit reg (* () *)
| PInt of (string * Z.t) reg (* 7 *)
@ -202,12 +204,15 @@ and pattern =
| PFalse of kwd_false (* false *)
| PString of string reg (* "foo" *)
| PWild of wild (* _ *)
| PCons of (pattern * cons * pattern) reg (* p1 :: p2 *)
| PPar of pattern par reg (* (p) *)
| PConstr of (constr * pattern option) reg (* A B(3,"") *)
| PRecord of record_pattern (* {a=...; ...} *)
| PTyped of typed_pattern reg (* (x : int) *)
and list_pattern =
Sugar of pattern injection reg (* [p1; p2; ...] *)
| PCons of (pattern * cons * pattern) reg (* p1 :: p2 *)
and typed_pattern = {
pattern : pattern;
colon : colon;
@ -223,35 +228,34 @@ and field_pattern = {
}
and expr =
LetIn of let_in reg (* let p1 = e1 and p2 = e2 and ... in e *)
| Fun of fun_expr (* fun x -> e *)
| If of conditional (* if e1 then e2 else e3 *)
| ETuple of (expr, comma) Utils.nsepseq reg (* e1, e2, ... *)
| Match of match_expr reg (* p1 -> e1 | p2 -> e2 | ... *)
| Seq of sequence (* begin e1; e2; ... ; en end *)
ELetIn of let_in reg (* let p1 = e1 and p2 = e2 and ... in e *)
| EFun of fun_expr (* fun x -> e *)
| ECond of conditional (* if e1 then e2 else e3 *)
| ETuple of (expr, comma) Utils.nsepseq reg (* e1, e2, ... *)
| EMatch of match_expr reg (* p1 -> e1 | p2 -> e2 | ... *)
| ESeq of sequence (* begin e1; e2; ... ; en end *)
| ERecord of record_expr (* {f1=e1; ... } *)
| Append of (expr * append * expr) reg (* e1 @ e2 *)
| Cons of (expr * cons * expr) reg (* e1 :: e2 *)
| ELogic of logic_expr
| EArith of arith_expr
| EString of string_expr
| Call of (expr * expr) reg (* f e *)
| ECall of (expr * expr) reg (* f e *)
| Path of path reg (* x x.y.z *)
| Unit of the_unit reg (* () *)
| Par of expr par reg (* (e) *)
| EList of (expr, semi) Utils.sepseq brackets reg (* [e1; e2; ...] *)
| EUnit of the_unit reg (* () *)
| EPar of expr par reg (* (e) *)
| EList of list_expr
| EConstr of constr
(*| Extern of extern*)
and list_expr =
Cons of cat bin_op reg (* e1 :: e3 *)
| List of expr injection reg (* [e1; e2; ...] *)
| Append of (expr * append * expr) reg (* e1 @ e2 *)
and string_expr =
Cat of cat bin_op reg (* e1 ^ e2 *)
Cat of cat bin_op reg (* e1 ^ e2 *)
| String of string reg (* "foo" *)
and arith_expr =
Add of plus bin_op reg (* e1 + e2 *)
| Sub of minus bin_op reg (* e1 - e2 *)
@ -333,27 +337,6 @@ and conditional =
IfThen of (kwd_if * expr * kwd_then * expr) reg
| IfThenElse of (kwd_if * expr * kwd_then * expr * kwd_else * expr) reg
(*
and extern =
Cast of cast_expr
| Print of print_expr
| Scanf of scanf_expr
| PolyEq of (variable * variable) (* polymorphic equality *)
and cast_expr =
StringOfInt of variable (* string_of_int x *)
| StringOfBool of variable (* string_of_bool x *)
and print_expr =
PrintString of variable (* print_string x *)
| PrintInt of variable (* print_int x *)
and scanf_expr =
ScanfString of variable (* scanf_string x *)
| ScanfInt of variable (* scanf_int x *)
| ScanfBool of variable (* scanf_bool x *)
*)
(* Normalising nodes of the AST so the interpreter is more uniform and
no source regions are lost in order to enable all manner of
source-to-source transformations from the rewritten AST and the
@ -490,36 +473,3 @@ val print_tokens : ?undo:bool -> ast -> unit
val region_of_pattern : pattern -> Region.t
val region_of_expr : expr -> Region.t
(* Removing all outermost parentheses from a given expression *)
val rm_par : expr -> expr
(* Predicates on expressions *)
val is_var : expr -> bool
val is_call : expr -> bool
val is_fun : expr -> bool
(* Variables *)
(*
module Vars : Set.S with type elt = string
module FreeVars : Set.S with type elt = variable
(* The value of the call [vars t] is a pair of sets: the first is the
set of variables whose definitions are in the scope at the end of
the program corresponding to the AST [t], the second is the set of
free variables in that same AST.
Computing free variables is useful because we do not want to
escape a variable that is a predefined variable in OCaml, when we
translate the program to OCaml: this way, we make sure that an
unbound variable is caught before the translation (where it would
be wrongly captured by the OCaml compiler).
Dually, computing bound variables is useful when compiling to
OCaml.
*)
val vars : t -> Vars.t * FreeVars.t
*)

4
src/parser/ligodity/Lexer.mll
View File

@ -239,8 +239,8 @@ rule scan = parse
| "(" { Token.LPAR }
| ")" { Token.RPAR }
| "[" { Token.LBRACK }
| "]" { Token.RBRACK }
| "[" { Token.LBRACKET }
| "]" { Token.RBRACKET }
| "{" { Token.LBRACE }
| "}" { Token.RBRACE }

4
src/parser/ligodity/ParToken.mly
View File

@ -10,8 +10,8 @@
%token LPAR
%token RPAR
%token LBRACK
%token RBRACK
%token LBRACKET
%token RBRACKET
%token LBRACE
%token RBRACE

59
src/parser/ligodity/Parser.mly
View File

@ -68,7 +68,7 @@ sep_or_term_list(item,sep):
par(X): sym(LPAR) X sym(RPAR) { {lpar=$1; inside=$2; rpar=$3} }
brackets(X): sym(LBRACK) X sym(RBRACK) {
brackets(X): sym(LBRACKET) X sym(RBRACKET) {
{lbracket=$1; inside=$2; rbracket=$3} }
(* Sequences
@ -125,12 +125,16 @@ tuple(item):
(* Possibly empty semicolon-separated values between brackets *)
list_of(item):
reg(brackets(sepseq(item,sym(SEMI)))) { $1 }
sym(LBRACKET) sepseq(item,sym(SEMI)) sym(RBRACKET) {
{opening = LBracket $1;
elements = $2;
terminator = None;
closing = RBracket $3} }
(* Main *)
program:
nseq(declaration) eof { {decl=$1; eof=$2} }
nseq(declaration) eof { {decl=$1; eof=$2} }
declaration:
reg(kwd(Let) let_bindings {$1,$2}) { Let $1 }
@ -226,7 +230,7 @@ let_bindings:
let_binding:
ident nseq(sub_irrefutable) option(type_annotation) sym(EQ) expr {
let let_rhs = Fun (norm $2 $4 $5) in
let let_rhs = EFun (norm $2 $4 $5) in
{pattern = PVar $1; lhs_type=$3; eq = Region.ghost; let_rhs}
}
| irrefutable option(type_annotation) sym(EQ) expr {
@ -258,7 +262,7 @@ typed_pattern:
{pattern=$1; colon=$2; type_expr=$3} }
pattern:
reg(sub_pattern sym(CONS) tail {$1,$2,$3}) { PCons $1 }
reg(sub_pattern sym(CONS) tail {$1,$2,$3}) { PList (PCons $1) }
| reg(tuple(sub_pattern)) { PTuple $1 }
| core_pattern { $1 }
@ -275,7 +279,7 @@ core_pattern:
| kwd(False) { PFalse $1 }
| string { PString $1 }
| reg(par(ptuple)) { PPar $1 }
| list_of(tail) { PList $1 }
| reg(list_of(tail)) { PList (Sugar $1) }
| reg(constr_pattern) { PConstr $1 }
| reg(record_pattern) { PRecord $1 }
@ -304,14 +308,14 @@ unit:
reg(sym(LPAR) sym(RPAR) {$1,$2}) { $1 }
tail:
reg(sub_pattern sym(CONS) tail {$1,$2,$3}) { PCons $1 }
| sub_pattern { $1 }
reg(sub_pattern sym(CONS) tail {$1,$2,$3}) { PList (PCons $1) }
| sub_pattern { $1 }
(* Expressions *)
expr:
base_cond__open(expr) { $1 }
| match_expr(base_cond) { Match $1 }
base_cond__open(expr) { $1 }
| match_expr(base_cond) { EMatch $1 }
base_cond__open(x):
base_expr(x)
@ -328,7 +332,7 @@ base_expr(right_expr):
conditional(right_expr):
if_then_else(right_expr)
| if_then(right_expr) { If $1 }
| if_then(right_expr) { ECond $1 }
if_then(right_expr):
reg(kwd(If) expr kwd(Then) right_expr {$1,$2,$3,$4}) { IfThen $1 }
@ -339,14 +343,14 @@ if_then_else(right_expr):
base_if_then_else__open(x):
base_expr(x) { $1 }
| if_then_else(x) { If $1 }
| if_then_else(x) { ECond $1 }
base_if_then_else:
base_if_then_else__open(base_if_then_else) { $1 }
closed_if:
base_if_then_else__open(closed_if) { $1 }
| match_expr(base_if_then_else) { Match $1 }
| match_expr(base_if_then_else) { EMatch $1 }
match_expr(right_expr):
reg(kwd(Match) expr kwd(With)
@ -361,7 +365,7 @@ match_nat(right_expr):
let cast_name = Name {region=ghost; value="assert_pos"} in
let cast_path = {module_proj=None; value_proj=cast_name,[]} in
let cast_fun = Path {region=ghost; value=cast_path} in
let cast = Call {region=ghost; value=cast_fun,$2}
let cast = ECall {region=ghost; value=cast_fun,$2}
in $1, cast, $3, ($4, Utils.nsepseq_rev $5) }
cases(right_expr):
@ -374,13 +378,12 @@ case(right_expr):
let_expr(right_expr):
reg(kwd(Let) let_bindings kwd(In) right_expr {$1,$2,$3,$4}) {
LetIn $1
}
ELetIn $1 }
fun_expr(right_expr):
reg(kwd(Fun) nseq(irrefutable) sym(ARROW) right_expr {$1,$2,$3,$4}) {
let Region.{region; value = kwd_fun, patterns, arrow, expr} = $1
in Fun (norm ~reg:(region, kwd_fun) patterns arrow expr) }
in EFun (norm ~reg:(region, kwd_fun) patterns arrow expr) }
disj_expr_level:
reg(disj_expr) { ELogic (BoolExpr (Or $1)) }
@ -431,9 +434,9 @@ ne_expr:
bin_op(comp_expr_level, sym(NE), cat_expr_level) { $1 }
cat_expr_level:
reg(cat_expr) { EString (Cat $1) }
| reg(append_expr) { Append $1 }
| cons_expr_level { $1 }
reg(cat_expr) { EString (Cat $1) }
| reg(append_expr) { EList (Append $1) }
| cons_expr_level { $1 }
cat_expr:
bin_op(cons_expr_level, sym(CAT), cat_expr_level) { $1 }
@ -442,11 +445,11 @@ append_expr:
cons_expr_level sym(APPEND) cat_expr_level { $1,$2,$3 }
cons_expr_level:
reg(cons_expr) { Cons $1 }
| add_expr_level { $1 }
reg(cons_expr) { EList (Cons $1) }
| add_expr_level { $1 }
cons_expr:
add_expr_level sym(CONS) cons_expr_level { $1,$2,$3 }
bin_op(add_expr_level, sym(CONS), cons_expr_level) { $1 }
add_expr_level:
reg(plus_expr) { EArith (Add $1) }
@ -486,7 +489,7 @@ not_expr:
un_op(kwd(Not), core_expr) { $1 }
call_expr_level:
reg(call_expr) { Call $1 }
reg(call_expr) { ECall $1 }
| core_expr { $1 }
call_expr:
@ -498,13 +501,13 @@ core_expr:
| reg(Nat) { EArith (Nat $1) }
| reg(path) { Path $1 }
| string { EString (String $1) }
| unit { Unit $1 }
| unit { EUnit $1 }
| kwd(False) { ELogic (BoolExpr (False $1)) }
| kwd(True) { ELogic (BoolExpr ( True $1)) }
| list_of(expr) { EList $1 }
| reg(par(expr)) { Par $1 }
| reg(list_of(expr)) { EList (List $1) }
| reg(par(expr)) { EPar $1 }
| constr { EConstr $1 }
| reg(sequence) { Seq $1 }
| reg(sequence) { ESeq $1 }
| reg(record_expr) { ERecord $1 }
path:

8
src/parser/ligodity/Token.ml
View File

@ -13,8 +13,8 @@ type t =
| TIMES
| LPAR
| RPAR
| LBRACK
| RBRACK
| LBRACKET
| RBRACKET
| LBRACE
| RBRACE
| COMMA
@ -91,8 +91,8 @@ let to_string = function
| TIMES -> "*"
| LPAR -> "("
| RPAR -> ")"
| LBRACK -> "["
| RBRACK -> "]"
| LBRACKET -> "["
| RBRACKET -> "]"
| LBRACE -> "{"
| RBRACE -> "}"
| COMMA -> ","

4
src/parser/ligodity/Token.mli
View File

@ -19,8 +19,8 @@ type t =
| LPAR (* "(" *)
| RPAR (* ")" *)
| LBRACK (* "[" *)
| RBRACK (* "]" *)
| LBRACKET (* "[" *)
| RBRACKET (* "]" *)
| LBRACE (* "{" *)
| RBRACE (* "}" *)

2
src/parser/pascaligo/AST.ml
View File

@ -199,7 +199,7 @@ and type_expr =
and cartesian = (type_expr, times) nsepseq reg
and variant = {
and variant = { (* TODO: Constant constructors *)
constr : constr;
kwd_of : kwd_of;
product : cartesian

1
src/simplify/simplify.ml
View File

@ -1,2 +1,3 @@
module Pascaligo = Pascaligo
module Camligo = Camligo
module Ligodity = Ligodity