add take left operator, sizecoded wasm4 skip ahead to 512 bytes

src/ast.rs

@@ -141,6 +141,10 @@ pub enum Expr {
     Return {
         value: Option<Box<Expression>>,
     },
+    First {
+        value: Box<Expression>,
+        drop: Box<Expression>
+    },
     Error,
 }
 

src/constfold.rs

@@ -212,6 +212,10 @@ fn fold_expr(expr: &mut ast::Expression) {
         }
         ast::Expr::Return { value: Some(ref mut value) } => fold_expr(value),
         ast::Expr::Return { value: None } => (),
+        ast::Expr::First { ref mut value, ref mut drop } => {
+            fold_expr(value);
+            fold_expr(drop);
+        }
         ast::Expr::Error => unreachable!()
     }
 }

src/emit.rs

@@ -291,6 +291,10 @@ fn collect_locals_expr<'a>(expr: &ast::Expression, locals: &mut Vec<(String, ast
         }
         ast::Expr::Return { value: Some(value) } => collect_locals_expr(value, locals),
         ast::Expr::Return { value: None } => (),
+        ast::Expr::First { value, drop } => {
+            collect_locals_expr(value, locals);
+            collect_locals_expr(drop, locals);
+        }
         ast::Expr::Error => unreachable!(),
     }
 }
@@ -622,6 +626,13 @@ fn emit_expression<'a>(ctx: &mut FunctionContext<'a>, expr: &'a ast::Expression)
             }
             ctx.function.instruction(&Instruction::Return);
         }
+        ast::Expr::First { value, drop } => {
+            emit_expression(ctx, value);
+            emit_expression(ctx, drop);
+            if drop.type_.is_some() {
+                ctx.function.instruction(&Instruction::Drop);
+            }
+        }
         ast::Expr::Error => unreachable!(),
     }
 }

src/parser.rs

@@ -675,7 +675,14 @@ fn script_parser() -> impl Parser<Token, ast::Script, Error = Simple<Token>> + C
                 })
                 .boxed();
 
-            op_bit
+            let op_first = op_bit.clone().then(
+                just(Token::Op("<|".to_string())).ignore_then(op_bit).repeated()
+            ).foldl(|left, right| {
+                let span = left.span.start..right.span.end;
+                ast::Expr::First { value: Box::new(left), drop: Box::new(right) }.with_span(span)
+            }).boxed();
+
+            op_first
         });
 
         expression_out = Some(expression.clone());

src/typecheck.rs

@@ -687,6 +687,11 @@ fn tc_expression(context: &mut Context, expr: &mut ast::Expression) -> Result<()
             }
             None
         }
+        ast::Expr::First { ref mut value, ref mut drop } => {
+            tc_expression(context, value)?;
+            tc_expression(context, drop)?;
+            value.type_
+        }
         ast::Expr::Error => unreachable!(),
     };
     Ok(())