add Op::Unit for general purpose debugging or data collection (#896)

src/lem/circuit.rs

@@ -984,7 +984,7 @@ fn synthesize_block<F: LurkField, CS: ConstraintSystem<F>, C: Coprocessor<F>>(
                 bound_allocations.insert_ptr(tgt[0].clone(), div_ptr);
                 bound_allocations.insert_ptr(tgt[1].clone(), rem_ptr);
             }
-            Op::Emit(_) => (),
+            Op::Emit(_) | Op::Unit(_) => (),
             Op::Hide(tgt, sec, pay) => {
                 let sec = bound_allocations.get_ptr(sec)?;
                 let pay = bound_allocations.get_ptr(pay)?;
@@ -1501,7 +1501,7 @@ impl Func {
                         // three implies_u64, one sub and one linear
                         num_constraints += 197;
                     }
-                    Op::Not(..) | Op::Emit(_) | Op::Cproc(..) | Op::Copy(..) => (),
+                    Op::Not(..) | Op::Emit(_) | Op::Cproc(..) | Op::Copy(..) | Op::Unit(_) => (),
                     Op::Cons2(_, tag, _) => {
                         // tag for the image
                         globals.insert(FWrap(tag.to_field()));

src/lem/interpreter.rs

@@ -434,6 +434,7 @@ impl Block {
                     bindings.insert_ptr(tgt_secret.clone(), Ptr::Atom(Tag::Expr(Num), *secret));
                     hints.commitment.push(Some(SlotData::FPtr(*secret, *ptr)))
                 }
+                Op::Unit(f) => f(),
             }
         }
         match &self.ctrl {

src/lem/macros.rs

@@ -208,6 +208,9 @@ macro_rules! op {
             let func = Box::new($func.clone());
             $crate::lem::Op::Call(out, func, inp)
         }
+    };
+    ( unit($f:expr) ) => {
+        $crate::lem::Op::Unit($f)
     }
 }
 
@@ -591,6 +594,16 @@ macro_rules! block {
             $($tail)*
         )
     };
+    (@seq {$($limbs:expr)*}, unit($f:expr) ; $($tail:tt)*) => {
+        $crate::block! (
+            @seq
+            {
+                $($limbs)*
+                $crate::op!(unit($f))
+            },
+            $($tail)*
+        )
+    };
     (@seq {$($limbs:expr)*}, let ($($tgt:ident),*) = $func:ident($($arg:ident),*) ; $($tail:tt)*) => {
         $crate::block! (
             @seq

src/lem/mod.rs

@@ -296,6 +296,7 @@ pub enum Op {
     /// `Open(s, p, h)` binds `s` and `p` to the secret and payload (respectively)
     /// of the commitment that resulted on (num or comm) `h`
     Open(Var, Var, Var),
+    Unit(fn()),
 }
 
 impl Func {
@@ -451,6 +452,7 @@ impl Func {
                         is_unique(tgt_secret, map);
                         is_unique(tgt_ptr, map);
                     }
+                    Op::Unit(_) => (),
                 }
             }
             match &block.ctrl {
@@ -736,6 +738,9 @@ impl Block {
                     let pay = insert_one(map, uniq, &pay);
                     ops.push(Op::Open(sec, pay, comm_or_num))
                 }
+                Op::Unit(x) => {
+                    ops.push(Op::Unit(x));
+                }
             }
         }
         let ctrl = match self.ctrl {