Builtin operators

examples/arithmetic.no

@@ -19,4 +19,7 @@ fn main(pub public_input: Field, private_input: Field) {
     let div_var_res = xx / private_input;
     assert_eq(div_res, 2);
 
+    // left shift
+    let lf_res = xx << 2;
+    assert_eq(lf_res, 16);
 }

src/circuit_writer/writer.rs

@@ -626,6 +626,7 @@ impl<B: Backend> CircuitWriter<B> {
                     // todo: refactor the input vars from Var to VarInfo, 
                     // which contain the type to provide the info about the bit length
                     Op2::LessThan => field::less_than(self, None, &lhs[0], &rhs[0], expr.span),
+                    Op2::LeftShift => field::left_shift(self, &lhs[0], &rhs[0], expr.span),
                     Op2::BoolAnd => boolean::and(self, &lhs[0], &rhs[0], expr.span),
                     Op2::BoolOr => boolean::or(self, &lhs[0], &rhs[0], expr.span),
                 };

src/constraints/field.rs

@@ -239,6 +239,33 @@ pub fn modulus<B: Backend>(
     }
 }
 
+/// Left shift operation
+pub fn left_shift<B: Backend>(
+    compiler: &mut CircuitWriter<B>,
+    lhs: &ConstOrCell<B::Field, B::Var>,
+    rhs: &ConstOrCell<B::Field, B::Var>,
+    span: Span,
+) -> Var<B::Field, B::Var> {
+    // to constrain lhs * (1 << rhs) = res
+
+    match (lhs, rhs) {
+        (ConstOrCell::Const(lhs), ConstOrCell::Const(rhs)) => {
+            // convert to bigint
+            let pow2 = B::Field::from(2u32).pow(rhs.into_repr());
+            let res = *lhs * pow2;
+            Var::new_constant(res, span)
+        }
+        (ConstOrCell::Cell(lhs_), ConstOrCell::Const(rhs_)) => {
+            let pow2 = B::Field::from(2u32).pow(rhs_.into_repr());
+            let res = compiler.backend.mul_const(lhs_, &pow2, span);
+            Var::new_var(res, span)
+        }
+        // todo: wrap rhs in a symbolic value
+        (ConstOrCell::Const(_), ConstOrCell::Cell(_)) => todo!(),
+        (ConstOrCell::Cell(_), ConstOrCell::Cell(_)) => todo!(),
+    }
+}
+
 /// This takes variables that can be anything, and returns a boolean
 // TODO: so perhaps it's not really relevant in this file?
 pub fn equal<B: Backend>(

src/lexer/mod.rs

@@ -148,6 +148,8 @@ pub enum TokenKind {
     DoubleAmpersand,    // &&
     Pipe,               // |
     DoublePipe,         // ||
+    LeftShift,          // <<
+    RightShift,         // >>
     Exclamation,        // !
     Question,           // ?
                         //    Literal,               // "thing"
@@ -192,6 +194,8 @@ impl Display for TokenKind {
             DoublePipe => "`||`",
             Exclamation => "`!`",
             Question => "`?`",
+            LeftShift => "`<<`",
+            RightShift => "`>>`",
             //            TokenType::Literal => "`\"something\"",
         };
 
@@ -365,10 +369,22 @@ impl Token {
                     }
                 }
                 '>' => {
-                    tokens.push(TokenKind::Greater.new_token(ctx, 1));
+                    let next_c = chars.peek();
+                    if matches!(next_c, Some(&'>')) {
+                        tokens.push(TokenKind::RightShift.new_token(ctx, 2));
+                        chars.next();
+                    } else {
+                        tokens.push(TokenKind::Greater.new_token(ctx, 1));
+                    }
                 }
                 '<' => {
-                    tokens.push(TokenKind::Less.new_token(ctx, 1));
+                    let next_c = chars.peek();
+                    if matches!(next_c, Some(&'<')) {
+                        tokens.push(TokenKind::LeftShift.new_token(ctx, 2));
+                        chars.next();
+                    } else {
+                        tokens.push(TokenKind::Less.new_token(ctx, 1));
+                    }
                 }
                 '=' => {
                     let next_c = chars.peek();

src/mast/mod.rs

@@ -558,7 +558,8 @@ fn monomorphize_expr<B: Backend>(
                 | Op2::Division
                 | Op2::Modulus
                 | Op2::BoolAnd
-                | Op2::BoolOr => lhs_mono.typ,
+                | Op2::BoolOr 
+                | Op2::LeftShift => lhs_mono.clone().typ,
             };
 
             let ExprMonoInfo { expr: lhs_expr, .. } = lhs_mono;

src/parser/expr.rs

@@ -133,6 +133,7 @@ pub enum Op2 {
     Equality,
     Inequality,
     LessThan,
+    LeftShift,
     BoolAnd,
     BoolOr,
 }
@@ -444,7 +445,8 @@ impl Expr {
                     | TokenKind::Less
                     | TokenKind::DoubleAmpersand
                     | TokenKind::DoublePipe
-                    | TokenKind::Exclamation,
+                    | TokenKind::Exclamation
+                    | TokenKind::LeftShift,
                 ..
             }) => {
                 // lhs + rhs
@@ -458,6 +460,7 @@ impl Expr {
                     TokenKind::DoubleEqual => Op2::Equality,
                     TokenKind::NotEqual => Op2::Inequality,
                     TokenKind::Less => Op2::LessThan,
+                    TokenKind::LeftShift => Op2::LeftShift,
                     TokenKind::DoubleAmpersand => Op2::BoolAnd,
                     TokenKind::DoublePipe => Op2::BoolOr,
                     _ => unreachable!(),

src/stdlib/bits.rs

@@ -28,7 +28,7 @@ impl Module for BitsLib {
     }
 }
 
-fn to_bits<B: Backend>(
+pub fn to_bits<B: Backend>(
     compiler: &mut CircuitWriter<B>,
     generics: &GenericParameters,
     vars: &[VarInfo<B::Field, B::Var>],

src/type_checker/checker.rs

@@ -311,7 +311,8 @@ impl<B: Backend> TypeChecker<B> {
                     | Op2::Division
                     | Op2::Modulus
                     | Op2::BoolAnd
-                    | Op2::BoolOr => lhs_node.typ,
+                    | Op2::BoolOr 
+                    | Op2::LeftShift => lhs_node.typ,
                 };
 
                 Some(ExprTyInfo::new_anon(typ))