Add operators, math, time, string, collection, and HOF builtins to El

engrams/el-parser/src/parser.rs

@@ -717,6 +717,48 @@ impl Parser {
         self.parse_pipe_expr()
     }
 
+    fn parse_bitwise_or_expr(&mut self) -> Result<Expr, ParseError> {
+        let mut left = self.parse_bitwise_xor_expr()?;
+        while self.eat(&Token::Pipe) {
+            let right = self.parse_bitwise_xor_expr()?;
+            left = Expr::BinOp { op: BinOp::BitOr, left: Box::new(left), right: Box::new(right) };
+        }
+        Ok(left)
+    }
+
+    fn parse_bitwise_xor_expr(&mut self) -> Result<Expr, ParseError> {
+        let mut left = self.parse_bitwise_and_expr()?;
+        while self.eat(&Token::Caret) {
+            let right = self.parse_bitwise_and_expr()?;
+            left = Expr::BinOp { op: BinOp::BitXor, left: Box::new(left), right: Box::new(right) };
+        }
+        Ok(left)
+    }
+
+    fn parse_bitwise_and_expr(&mut self) -> Result<Expr, ParseError> {
+        let mut left = self.parse_shift_expr()?;
+        while self.eat(&Token::Ampersand) {
+            let right = self.parse_shift_expr()?;
+            left = Expr::BinOp { op: BinOp::BitAnd, left: Box::new(left), right: Box::new(right) };
+        }
+        Ok(left)
+    }
+
+    fn parse_shift_expr(&mut self) -> Result<Expr, ParseError> {
+        let mut left = self.parse_additive()?;
+        loop {
+            let op = match self.peek() {
+                Token::Shl => BinOp::Shl,
+                Token::Shr => BinOp::Shr,
+                _ => break,
+            };
+            self.advance();
+            let right = self.parse_additive()?;
+            left = Expr::BinOp { op, left: Box::new(left), right: Box::new(right) };
+        }
+        Ok(left)
+    }
+
     /// pipe_expr = or_expr (|> ident)*
     /// `a |> f` desugars to `Call(f, [a])`
     fn parse_pipe_expr(&mut self) -> Result<Expr, ParseError> {
@@ -766,7 +808,7 @@ impl Parser {
     }
 
     fn parse_comparison(&mut self) -> Result<Expr, ParseError> {
-        let mut left = self.parse_additive()?;
+        let mut left = self.parse_bitwise_or_expr()?;
         loop {
             let op = match self.peek() {
                 Token::Lt => BinOp::Lt,
@@ -803,6 +845,7 @@ impl Parser {
             let op = match self.peek() {
                 Token::Star => BinOp::Mul,
                 Token::Slash => BinOp::Div,
+                Token::Percent => BinOp::Mod,
                 _ => break,
             };
             self.advance();
@@ -817,6 +860,10 @@ impl Parser {
             let inner = self.parse_unary()?;
             return Ok(Expr::UnaryNot(Box::new(inner)));
         }
+        if self.eat(&Token::Tilde) {
+            let inner = self.parse_unary()?;
+            return Ok(Expr::UnaryBitNot(Box::new(inner)));
+        }
         self.parse_postfix()
     }