lalrpop error

src/ast.rs

@@ -66,6 +66,7 @@ pub enum Expr {
     Record(Option<Box<Expr>>, Vec<(Spanned<String>, Box<Expr>)>, Span),
     RefGet(Spanned<Box<Expr>>),
     RefSet(Spanned<Box<Expr>>, Box<Expr>),
+    Seq(Box<Expr>, Box<Expr>),
     Typed(Box<Expr>, TypeExpr),
     Variable(Spanned<String>),
 }

src/codegen.rs

@@ -238,6 +238,11 @@ fn compile(ctx: &mut ModuleBuilder, expr: &ast::Expr) -> js::Expr {
             let rhs = compile(ctx, rhs_expr);
             js::assign(js::field(lhs, "$p".to_string()), rhs)
         }
+        ast::Expr::Seq(lhs_expr, rhs_expr) => {
+            let lhs = compile(ctx, lhs_expr);
+            let rhs = compile(ctx, rhs_expr);
+            js::comma_pair(lhs, rhs)
+        }
         ast::Expr::Typed(expr, _) => compile(ctx, expr),
         ast::Expr::Variable((name, _)) => ctx.bindings.get(name).unwrap().clone(),
     }

src/grammar.lalr

@@ -222,9 +222,9 @@ NewRef: ast::Expr = {
 
 CallExpr = {
     RefExpr,
-    Call,
-    Case,
-    NewRef,
+    //Call,
+    //Case,
+    //NewRef,
 }
 //////////////////////////////////////////////////////////////////////
 
@@ -275,15 +275,15 @@ CmpOp: ast::Expr = {
 
 MultExpr = {
     CallExpr,
-    MultOp,
+    //MultOp,
 }
 AddExpr = {
     MultExpr,
-    AddOp,
+    //AddOp,
 }
 CompareExpr = {
     AddExpr,
-    CmpOp,
+    //CmpOp,
 }
 //////////////////////////////////////////////////////////////////////
 
@@ -296,22 +296,22 @@ LetPattern: ast::LetPattern = {
     <Ident> => ast::LetPattern::Var(<>),
     "{" <SepList<KeyPairPattern, ";">> "}" => ast::LetPattern::Record(<>),
 }
-FuncSub = "fun" <LetPattern> "->" <Box<Expr>>;
+FuncSub = "fun" <LetPattern> "->" <Box<NoSemiExpr>>;
 FuncDef: ast::Expr = {
     Spanned<FuncSub> => ast::Expr::FuncDef(<>),
 }
 
 
 If: ast::Expr = {
-    "if" <Spanned<Box<Expr>>> "then" <Box<Expr>> "else" <Box<Expr>> => ast::Expr::If(<>),
+    "if" <Spanned<Box<Expr>>> "then" <Box<Expr>> "else" <Box<NoSemiExpr>> => ast::Expr::If(<>),
 }
 
 
 LetLHS = {
-    "let" <Ident> "=" <Box<Expr>>,
+    "let" <Ident> "=" <Box<NoSemiExpr>>,
 }
 LetRHS = {
-    "in" <Box<Expr>>,
+    "in" <Box<NoSemiExpr>>,
 }
 Let: ast::Expr = {
     <LetLHS> <LetRHS> => ast::Expr::Let(<>),
@@ -346,12 +346,12 @@ Match: ast::Expr = {
 
 
 RefSet: ast::Expr = {
-    <Spanned<Box<CallExpr>>> ":=" <Box<Expr>> => ast::Expr::RefSet(<>)
+    <Spanned<Box<CallExpr>>> ":=" <Box<NoSemiExpr>> => ast::Expr::RefSet(<>)
 }
 
 
 
-Expr = {
+NoSemiExpr = {
     CompareExpr,
     FuncDef,
     If,
@@ -360,14 +360,18 @@ Expr = {
     Match,
     RefSet,
 }
+Expr = {
+    <Box<NoSemiExpr>> ";" <Box<NoSemiExpr>> => ast::Expr::Seq(<>),
+    <NoSemiExpr>,
+}
 //////////////////////////////////////////////////////////////////////
 
 
 
 TopLevelItem: ast::TopLevel = {
     <LetLHS> => ast::TopLevel::LetDef(<>),
     <LetRecLHS> => ast::TopLevel::LetRecDef(<>),
-    <Expr> => ast::TopLevel::Expr(<>),
+    <NoSemiExpr> => ast::TopLevel::Expr(<>),
 }
 
 pub Script = {

src/typeck.rs

@@ -532,6 +532,11 @@ fn check_expr(engine: &mut TypeCheckerCore, bindings: &mut Bindings, expr: &ast:
             engine.flow(lhs_type, bound)?;
             Ok(rhs_type)
         }
+        Seq(lhs_expr, rhs_expr) => {
+            let _lhs_type = check_expr(engine, bindings, lhs_expr)?;
+            let rhs_type = check_expr(engine, bindings, rhs_expr)?;
+            Ok(rhs_type)
+        }
         Typed(expr, sig) => {
             let expr_type = check_expr(engine, bindings, expr)?;
             let sig_type = parse_type_signature(engine, sig)?;