Merge pull request #1 from mileschet/feature/lisp

Feature/lisp

Cargo.toml

@@ -35,6 +35,12 @@ clap = "3.0.0-beta.1"
 failure = "0.1.8"
 failure_derive = "0.1.8"
 
+regex = "1"
+
+lazy_static = "1.4.0"
+itertools = "0.8.0"
+fnv = "1.0.6"
+
 [[bin]]
 name = "sha256"
 path = "src/sha256.rs"
@@ -107,3 +113,6 @@ path = "src/bin/mint.rs"
 name = "jubjub"
 path = "src/bin/jubjub.rs"
 
+[[bin]]
+name = "lisp"
+path = "lisp/lisp.rs"

lisp/README.md

@@ -0,0 +1,12 @@
+## zklisp
+
+This is a DSL for ZKVMCircuit from sapvi language.
+
+It uses the mal (lisp) version of rust with some modifications to interact with bellman backend and also sapvi vm.
+
+## run
+
+
+```
+cargo run --bin lisp load new.lisp
+```

lisp/TODO.md

@@ -0,0 +1,7 @@
+## TODO
+
+[] - Document the language
+[] - Integrate with zkvm command line
+[x] - Integrate with ZKVMCircuit: allocs and constraints
+[x] - Added CryptoOperation such double and square to core.rs
+[] - Adapt ZKContract to use lisp to read contract and execute

lisp/bits.lisp

@@ -0,0 +1,9 @@
+(def! bit-dec 
+      (fn* [x] (
+        (def! bits (unpack-bits x 256))                        
+        (def! enforce-step-1 (fn* [b] (enforce (add-one-lc0 (sub-lc0 b) (add-lc1 b))))
+        (map enforce-step-1 bits)
+        (map (fn* [b] ((add-lc0 b) double-coeff-lc) bits)                       
+        (enforce reset-coeff-lc sub-lc0 add-one-lc1)
+      )))))
+                            

lisp/core.rs

@@ -0,0 +1,423 @@
+use std::fs::File;
+use std::io::Read;
+use std::rc::Rc;
+use std::sync::Mutex;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::printer::pr_seq;
+use crate::reader::read_str;
+use crate::types::MalErr::ErrMalVal;
+use crate::types::MalVal::{
+    Add, Atom, Bool, Func, Hash, Int, Lc0, List, MalFunc, Nil, Str, Sub, Sym, Vector,
+};
+use crate::types::{MalArgs, MalRet, MalVal, _assoc, _dissoc, atom, error, func, hash_map};
+use bellman::{gadgets::Assignment, groth16, Circuit, ConstraintSystem, SynthesisError};
+use bls12_381::Bls12;
+use bls12_381::Scalar;
+use ff::{Field, PrimeField};
+use rand::rngs::OsRng;
+use sapvi::bls_extensions::BlsStringConversion;
+use sapvi::error::{Error, Result};
+use sapvi::serial::{Decodable, Encodable};
+use sapvi::vm::{
+    AllocType, ConstraintInstruction, CryptoOperation, VariableIndex, VariableRef, ZKVMCircuit,
+    ZKVirtualMachine,
+};
+use std::ops::{AddAssign, MulAssign, SubAssign};
+use std::time::Instant;
+
+macro_rules! fn_t_int_int {
+    ($ret:ident, $fn:expr) => {{
+        |a: MalArgs| match (a[0].clone(), a[1].clone()) {
+            (Int(a0), Int(a1)) => Ok($ret($fn(a0, a1))),
+            _ => error("expecting (int,int) args"),
+        }
+    }};
+}
+
+macro_rules! fn_is_type {
+  ($($ps:pat),*) => {{
+    |a:MalArgs| { Ok(Bool(match a[0] { $($ps => true,)* _ => false})) }
+  }};
+  ($p:pat if $e:expr) => {{
+    |a:MalArgs| { Ok(Bool(match a[0] { $p if $e => true, _ => false})) }
+  }};
+  ($p:pat if $e:expr,$($ps:pat),*) => {{
+    |a:MalArgs| { Ok(Bool(match a[0] { $p if $e => true, $($ps => true,)* _ => false})) }
+  }};
+}
+
+macro_rules! fn_str {
+    ($fn:expr) => {{
+        |a: MalArgs| match a[0].clone() {
+            Str(a0) => $fn(a0),
+            _ => error("expecting (str) arg"),
+        }
+    }};
+}
+
+fn symbol(a: MalArgs) -> MalRet {
+    match a[0] {
+        Str(ref s) => Ok(Sym(s.to_string())),
+        _ => error("illegal symbol call"),
+    }
+}
+
+fn slurp(f: String) -> MalRet {
+    let mut s = String::new();
+    match File::open(f).and_then(|mut f| f.read_to_string(&mut s)) {
+        Ok(_) => Ok(Str(s)),
+        Err(e) => error(&e.to_string()),
+    }
+}
+
+fn time_ms(_a: MalArgs) -> MalRet {
+    let ms_e = match SystemTime::now().duration_since(UNIX_EPOCH) {
+        Ok(d) => d,
+        Err(e) => return error(&format!("{:?}", e)),
+    };
+    Ok(Int(
+        ms_e.as_secs() as i64 * 1000 + ms_e.subsec_nanos() as i64 / 1_000_000
+    ))
+}
+
+fn get(a: MalArgs) -> MalRet {
+    match (a[0].clone(), a[1].clone()) {
+        (Nil, _) => Ok(Nil),
+        (Hash(ref hm, _), Str(ref s)) => match hm.get(s) {
+            Some(mv) => Ok(mv.clone()),
+            None => Ok(Nil),
+        },
+        _ => error("illegal get args"),
+    }
+}
+
+fn assoc(a: MalArgs) -> MalRet {
+    match a[0] {
+        Hash(ref hm, _) => _assoc((**hm).clone(), a[1..].to_vec()),
+        _ => error("assoc on non-Hash Map"),
+    }
+}
+
+fn dissoc(a: MalArgs) -> MalRet {
+    match a[0] {
+        Hash(ref hm, _) => _dissoc((**hm).clone(), a[1..].to_vec()),
+        _ => error("dissoc on non-Hash Map"),
+    }
+}
+
+fn contains_q(a: MalArgs) -> MalRet {
+    match (a[0].clone(), a[1].clone()) {
+        (Hash(ref hm, _), Str(ref s)) => Ok(Bool(hm.contains_key(s))),
+        _ => error("illegal get args"),
+    }
+}
+
+fn keys(a: MalArgs) -> MalRet {
+    match a[0] {
+        Hash(ref hm, _) => Ok(list!(hm.keys().map(|k| { Str(k.to_string()) }).collect())),
+        _ => error("keys requires Hash Map"),
+    }
+}
+
+fn vals(a: MalArgs) -> MalRet {
+    match a[0] {
+        Hash(ref hm, _) => Ok(list!(hm.values().map(|v| { v.clone() }).collect())),
+        _ => error("keys requires Hash Map"),
+    }
+}
+
+fn vec(a: MalArgs) -> MalRet {
+    match a[0] {
+        List(ref v, _) | Vector(ref v, _) => Ok(vector!(v.to_vec())),
+        _ => error("non-seq passed to vec"),
+    }
+}
+
+fn cons(a: MalArgs) -> MalRet {
+    match a[1].clone() {
+        List(v, _) | Vector(v, _) => {
+            let mut new_v = vec![a[0].clone()];
+            new_v.extend_from_slice(&v);
+            Ok(list!(new_v.to_vec()))
+        }
+        _ => error("cons expects seq as second arg"),
+    }
+}
+
+fn concat(a: MalArgs) -> MalRet {
+    let mut new_v = vec![];
+    for seq in a.iter() {
+        match seq {
+            List(v, _) | Vector(v, _) => new_v.extend_from_slice(v),
+            _ => return error("non-seq passed to concat"),
+        }
+    }
+    Ok(list!(new_v.to_vec()))
+}
+
+fn nth(a: MalArgs) -> MalRet {
+    match (a[0].clone(), a[1].clone()) {
+        (List(seq, _), Int(idx)) | (Vector(seq, _), Int(idx)) => {
+            if seq.len() <= idx as usize {
+                return error("nth: index out of range");
+            }
+            Ok(seq[idx as usize].clone())
+        }
+        _ => error("invalid args to nth"),
+    }
+}
+
+fn unpack_bits(a: MalArgs) -> MalRet {
+    let mut result = vec![];
+    match (a[0].clone()) {
+        (Str(ref s)) => {
+            let value = Scalar::from_string(s);
+            for (_, bit) in value.to_le_bits().into_iter().cloned().enumerate() {
+                match bit {
+                    true => result.push(Scalar::one()),
+                    false => result.push(Scalar::zero()),
+                }
+            }
+            Ok(list!(result
+                .iter()
+                .map(|a| Str(std::string::ToString::to_string(&a)[2..].to_string()))
+                .collect::<Vec<MalVal>>()))
+        }
+        _ => error("invalid args to unpack-bits"),
+    }
+}
+
+fn first(a: MalArgs) -> MalRet {
+    match a[0].clone() {
+        List(ref seq, _) | Vector(ref seq, _) if seq.len() == 0 => Ok(Nil),
+        List(ref seq, _) | Vector(ref seq, _) => Ok(seq[0].clone()),
+        Nil => Ok(Nil),
+        _ => error("invalid args to first"),
+    }
+}
+
+fn rest(a: MalArgs) -> MalRet {
+    match a[0].clone() {
+        List(ref seq, _) | Vector(ref seq, _) => {
+            if seq.len() > 1 {
+                Ok(list!(seq[1..].to_vec()))
+            } else {
+                Ok(list![])
+            }
+        }
+        Nil => Ok(list![]),
+        _ => error("invalid args to first"),
+    }
+}
+
+fn apply(a: MalArgs) -> MalRet {
+    match a[a.len() - 1] {
+        List(ref v, _) | Vector(ref v, _) => {
+            let f = &a[0];
+            let mut fargs = a[1..a.len() - 1].to_vec();
+            fargs.extend_from_slice(&v);
+            f.apply(fargs)
+        }
+        _ => error("apply called with non-seq"),
+    }
+}
+
+fn map(a: MalArgs) -> MalRet {
+    match a[1] {
+        List(ref v, _) | Vector(ref v, _) => {
+            let mut res = vec![];
+            for mv in v.iter() {
+                res.push(a[0].apply(vec![mv.clone()])?)
+            }
+            Ok(list!(res))
+        }
+        _ => error("map called with non-seq"),
+    }
+}
+
+fn conj(a: MalArgs) -> MalRet {
+    match a[0] {
+        List(ref v, _) => {
+            let sl = a[1..]
+                .iter()
+                .rev()
+                .map(|a| a.clone())
+                .collect::<Vec<MalVal>>();
+            Ok(list!([&sl[..], v].concat()))
+        }
+        Vector(ref v, _) => Ok(vector!([v, &a[1..]].concat())),
+        _ => error("conj: called with non-seq"),
+    }
+}
+
+fn sub(a: MalArgs) -> MalRet {
+    // get next symbol should be lc0 lc1 lc2
+    Ok(Sub(Rc::new(a[0].clone()), Rc::new(a[1].clone())))
+}
+
+fn sub_scalar(a: MalArgs) -> MalRet {
+    match (a[0].clone(), a[1].clone()) {
+        (Str(a0), Str(a1)) => {
+            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            s0.sub_assign(s1);
+            Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
+        }
+        _ => error("expected (scalar, scalar"),
+    }
+}
+
+fn mul_scalar(a: MalArgs) -> MalRet {
+    match (a[0].clone(), a[1].clone()) {
+        (Str(a0), Str(a1)) => {
+            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            s0.mul_assign(s1);
+            Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
+        }
+        _ => error("expected (scalar, scalar"),
+    }
+}
+
+fn div_scalar(a: MalArgs) -> MalRet {
+    match (a[0].clone(), a[1].clone()) {
+        (Str(a0), Str(a1)) => {
+            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            let ret = s1.invert().map(|other| *&s0 * other);
+            Ok(Str(std::string::ToString::to_string(&ret.unwrap())[2..].to_string()))
+        }
+        _ => error("expected (scalar, scalar"),
+    }
+}
+fn add_scalar(a: MalArgs) -> MalRet {
+    match (a[0].clone(), a[1].clone()) {
+        (Str(a0), Str(a1)) => {
+            let (mut s0, mut s1) = (Scalar::from_string(&a0), Scalar::from_string(&a1));
+            s0.add_assign(s1);
+            Ok(Str(std::string::ToString::to_string(&s0)[2..].to_string()))
+        }
+        _ => error("expected (scalar, scalar"),
+    }
+}
+
+fn add(a: MalArgs) -> MalRet {
+    // get next symbol should be lc0 lc1 lc2
+    Ok(Add(Rc::new(a[0].clone()), Rc::new(a[1].clone())))
+}
+
+fn seq(a: MalArgs) -> MalRet {
+    match a[0] {
+        List(ref v, _) | Vector(ref v, _) if v.len() == 0 => Ok(Nil),
+        List(ref v, _) | Vector(ref v, _) => Ok(list!(v.to_vec())),
+        Str(ref s) if s.len() == 0 => Ok(Nil),
+        Str(ref s) if !a[0].keyword_q() => {
+            Ok(list!(s.chars().map(|c| { Str(c.to_string()) }).collect()))
+        }
+        Nil => Ok(Nil),
+        _ => error("seq: called with non-seq"),
+    }
+}
+
+pub fn ns() -> Vec<(&'static str, MalVal)> {
+    vec![
+        ("=", func(|a| Ok(Bool(a[0] == a[1])))),
+        ("throw", func(|a| Err(ErrMalVal(a[0].clone())))),
+        ("nil?", func(fn_is_type!(Nil))),
+        ("true?", func(fn_is_type!(Bool(true)))),
+        ("false?", func(fn_is_type!(Bool(false)))),
+        ("symbol", func(symbol)),
+        ("symbol?", func(fn_is_type!(Sym(_)))),
+        (
+            "string?",
+            func(fn_is_type!(Str(ref s) if !s.starts_with("\u{29e}"))),
+        ),
+        ("keyword", func(|a| a[0].keyword())),
+        (
+            "keyword?",
+            func(fn_is_type!(Str(ref s) if s.starts_with("\u{29e}"))),
+        ),
+        ("number?", func(fn_is_type!(Int(_)))),
+        (
+            "fn?",
+            func(fn_is_type!(MalFunc{is_macro,..} if !is_macro,Func(_,_))),
+        ),
+        (
+            "macro?",
+            func(fn_is_type!(MalFunc{is_macro,..} if is_macro)),
+        ),
+        ("pr-str", func(|a| Ok(Str(pr_seq(&a, true, "", "", " "))))),
+        ("str", func(|a| Ok(Str(pr_seq(&a, false, "", "", ""))))),
+        (
+            "prn",
+            func(|a| {
+                println!("{}", pr_seq(&a, true, "", "", " "));
+                Ok(Nil)
+            }),
+        ),
+        (
+            "println",
+            func(|a| {
+                println!("{}", pr_seq(&a, false, "", "", " "));
+                Ok(Nil)
+            }),
+        ),
+        ("read-string", func(fn_str!(|s| { read_str(s) }))),
+        ("slurp", func(fn_str!(|f| { slurp(f) }))),
+        ("<", func(fn_t_int_int!(Bool, |i, j| { i < j }))),
+        ("<=", func(fn_t_int_int!(Bool, |i, j| { i <= j }))),
+        (">", func(fn_t_int_int!(Bool, |i, j| { i > j }))),
+        (">=", func(fn_t_int_int!(Bool, |i, j| { i >= j }))),
+        ("+", func(add_scalar)),
+        ("-", func(sub_scalar)),
+        ("*", func(mul_scalar)),
+        ("/", func(div_scalar)),
+        ("time-ms", func(time_ms)),
+        ("i+", func(fn_t_int_int!(Int, |i, j| { i + j }))),
+        ("i-", func(fn_t_int_int!(Int, |i, j| { i - j }))),
+        ("i*", func(fn_t_int_int!(Int, |i, j| { i * j }))),
+        ("i/", func(fn_t_int_int!(Int, |i, j| { i / j }))),
+        ("i<", func(fn_t_int_int!(Bool, |i, j| { i < j }))),
+        ("i<=", func(fn_t_int_int!(Bool, |i, j| { i <= j }))),
+        ("i>", func(fn_t_int_int!(Bool, |i, j| { i > j }))),
+        ("i>=", func(fn_t_int_int!(Bool, |i, j| { i >= j }))),
+        ("time-ms", func(time_ms)),
+        ("sequential?", func(fn_is_type!(List(_, _), Vector(_, _)))),
+        ("list", func(|a| Ok(list!(a)))),
+        ("list?", func(fn_is_type!(List(_, _)))),
+        ("vector", func(|a| Ok(vector!(a)))),
+        ("vector?", func(fn_is_type!(Vector(_, _)))),
+        ("hash-map", func(|a| hash_map(a))),
+        ("map?", func(fn_is_type!(Hash(_, _)))),
+        ("assoc", func(assoc)),
+        ("dissoc", func(dissoc)),
+        ("get", func(get)),
+        ("contains?", func(contains_q)),
+        ("keys", func(keys)),
+        ("vals", func(vals)),
+        ("vec", func(vec)),
+        ("cons", func(cons)),
+        ("concat", func(concat)),
+        ("empty?", func(|a| a[0].empty_q())),
+        ("nth", func(nth)),
+        ("first", func(first)),
+        ("rest", func(rest)),
+        ("count", func(|a| a[0].count())),
+        ("apply", func(apply)),
+        ("map", func(map)),
+        ("conj", func(conj)),
+        ("seq", func(seq)),
+        ("meta", func(|a| a[0].get_meta())),
+        ("with-meta", func(|a| a[0].clone().with_meta(&a[1]))),
+        ("atom", func(|a| Ok(atom(&a[0])))),
+        ("atom?", func(fn_is_type!(Atom(_)))),
+        ("deref", func(|a| a[0].deref())),
+        ("reset!", func(|a| a[0].reset_bang(&a[1]))),
+        ("swap!", func(|a| a[0].swap_bang(&a[1..].to_vec()))),
+        ("unpack-bits", func(unpack_bits)),
+        ("add", func(add)),
+        ("sub", func(sub)),
+        ("lc0", func(|a| Ok(MalVal::Lc0))),
+        ("lc1", func(|a| Ok(MalVal::Lc1))),
+        ("lc2", func(|a| Ok(MalVal::Lc2))),
+        ("enforce", func(|a| Ok(MalVal::Enforce))),
+    ]
+}

lisp/env.rs

@@ -0,0 +1,85 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+//use std::collections::HashMap;
+use fnv::FnvHashMap;
+
+use crate::types::MalErr::ErrString;
+use crate::types::MalVal::{List, Nil, Sym, Vector};
+use crate::types::{error, MalErr, MalRet, MalVal};
+
+#[derive(Debug)]
+pub struct EnvStruct {
+    data: RefCell<FnvHashMap<String, MalVal>>,
+    pub outer: Option<Env>,
+}
+
+pub type Env = Rc<EnvStruct>;
+
+// TODO: it would be nice to use impl here but it doesn't work on
+// a deftype (i.e. Env)
+
+pub fn env_new(outer: Option<Env>) -> Env {
+    Rc::new(EnvStruct {
+        data: RefCell::new(FnvHashMap::default()),
+        outer: outer,
+    })
+}
+
+// TODO: mbinds and exprs as & types
+pub fn env_bind(outer: Option<Env>, mbinds: MalVal, exprs: Vec<MalVal>) -> Result<Env, MalErr> {
+    let env = env_new(outer);
+    match mbinds {
+        List(binds, _) | Vector(binds, _) => {
+            for (i, b) in binds.iter().enumerate() {
+                match b {
+                    Sym(s) if s == "&" => {
+                        env_set(&env, binds[i + 1].clone(), list!(exprs[i..].to_vec()))?;
+                        break;
+                    }
+                    _ => {
+                        env_set(&env, b.clone(), exprs[i].clone())?;
+                    }
+                }
+            }
+            Ok(env)
+        }
+        _ => Err(ErrString("env_bind binds not List/Vector".to_string())),
+    }
+}
+
+pub fn env_find(env: &Env, key: &str) -> Option<Env> {
+    match (env.data.borrow().contains_key(key), env.outer.clone()) {
+        (true, _) => Some(env.clone()),
+        (false, Some(o)) => env_find(&o, key),
+        _ => None,
+    }
+}
+
+pub fn env_get(env: &Env, key: &MalVal) -> MalRet {
+    match key {
+        Sym(ref s) => match env_find(env, s) {
+            Some(e) => Ok(e
+                .data
+                .borrow()
+                .get(s)
+                .ok_or(ErrString(format!("'{}' not found", s)))?
+                .clone()),
+            _ => error(&format!("'{}' not found", s)),
+        },
+        _ => error("Env.get called with non-Str"),
+    }
+}
+
+pub fn env_set(env: &Env, key: MalVal, val: MalVal) -> MalRet {
+    match key {
+        Sym(ref s) => {
+            env.data.borrow_mut().insert(s.to_string(), val.clone());
+            Ok(val)
+        }
+        _ => error("Env.set called with non-Str"),
+    }
+}
+
+pub fn env_sets(env: &Env, key: &str, val: MalVal) {
+    env.data.borrow_mut().insert(key.to_string(), val);
+}

lisp/jubjub.lisp

@@ -0,0 +1,38 @@
+(def! a_u "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e")
+(def! a_v "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891")
+(def! b_u "15a36d1f0f390d8852a35a8c1908dd87a361ee3fd48fdf77b9819dc82d90607e")
+(def! b_v "015d8c7f5b43fe33f7891142c001d9251f3abeeb98fad3e87b0dc53c4ebf1891")
+(def! a "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000000")
+(def! d "2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1")
+(def! one "0000000000000000000000000000000000000000000000000000000000000001")
+(defzk! circuit ())
+(def! U (fn* [x1 y1 x2 y2] (+ (+ x1 y1) (+ x2 y2))))
+(def! A (fn* [x1 y2] (* y2 x1)))
+(def! B (fn* [y1 x2] (* x2 y1)))
+(def! C (fn* [x1 y1 x2 y2] (* d (A x1 y2) (B y1 x2))))
+(def! P.x (fn* [x1 y1 x2 y2] (/ (+ (A x1 y2) (B y1 x2)) (+ one (C x1 y1 x2 y2)))))
+(def! P.y (fn* [x1 y1 x2 y2] (/ (- (U x1 y1 x2 y2) (A x1 y2) (B y1 x2)) (+ one (C x1 y1 x2 y2)))))
+(def! jubjub-add (fn* [x1 y1 x2 y2] (zkcons! circuit (
+                    (add lc0 x1)
+                    (add lc0 y1)
+                    (add lc1 x2)
+                    (add lc1 y2)
+                    (add lc2 (U x1 y1 x2 y2))
+                    enforce
+;; Compute P.x = (A + B) / (1 + C)
+                    (add lc0 one)
+                    (add lc0 (C x1 y1 x2 y2))
+                    (add lc1 (P.x x1 y1 x2 y2))
+                    (add lc1 (A x1 y2))
+                    (add lc1 (B y1 x2))
+                    enforce
+;; Compute P.y = (U - A - B) / (1 - C)                    
+                    (add lc0 one)
+                    (sub lc0 (C x1 y1 x2 y2))
+                    (add lc1 (P.y x1 y1 x2 y2))
+                    (add lc2 (U x1 y1 x2 y2))
+                    (sub lc2 (A x1 y2))
+                    (sub lc2 (B y1 x2))
+                    enforce 
+                    ))))
+(println (jubjub-add a_u a_v b_u b_v))

lisp/lisp.rs

@@ -0,0 +1,482 @@
+#![allow(non_snake_case)]
+use bls12_381::Scalar;
+use sapvi::bls_extensions::BlsStringConversion;
+use sapvi::serial::{Decodable, Encodable};
+use simplelog::*;
+use std::fs;
+use std::fs::File;
+use std::rc::Rc;
+use std::time::Instant;
+//use std::collections::HashMap;
+use fnv::FnvHashMap;
+use itertools::Itertools;
+use sapvi::vm::{
+    AllocType, ConstraintInstruction, CryptoOperation, VariableIndex, VariableRef, ZKVirtualMachine,
+};
+
+#[macro_use]
+extern crate clap;
+#[macro_use]
+extern crate lazy_static;
+extern crate fnv;
+extern crate itertools;
+extern crate regex;
+
+#[macro_use]
+mod types;
+use crate::types::MalErr::{ErrMalVal, ErrString};
+use crate::types::MalVal::{
+    Add, Bool, Func, Hash, Lc0, Lc1, Lc2, List, MalFunc, Nil, Str, Sub, Sym, Vector, Zk,
+};
+use crate::types::ZKCircuit;
+use crate::types::{error, format_error, MalArgs, MalErr, MalRet, MalVal};
+mod env;
+mod printer;
+mod reader;
+use crate::env::{env_bind, env_find, env_get, env_new, env_set, env_sets, Env};
+#[macro_use]
+mod core;
+
+// read
+fn read(str: &str) -> MalRet {
+    reader::read_str(str.to_string())
+}
+
+// eval
+
+fn qq_iter(elts: &MalArgs) -> MalVal {
+    let mut acc = list![];
+    for elt in elts.iter().rev() {
+        if let List(v, _) = elt {
+            if v.len() == 2 {
+                if let Sym(ref s) = v[0] {
+                    if s == "splice-unquote" {
+                        acc = list![Sym("concat".to_string()), v[1].clone(), acc];
+                        continue;
+                    }
+                }
+            }
+        }
+        acc = list![Sym("cons".to_string()), quasiquote(&elt), acc];
+    }
+    return acc;
+}
+
+fn quasiquote(ast: &MalVal) -> MalVal {
+    match ast {
+        List(v, _) => {
+            if v.len() == 2 {
+                if let Sym(ref s) = v[0] {
+                    if s == "unquote" {
+                        return v[1].clone();
+                    }
+                }
+            }
+            return qq_iter(&v);
+        }
+        Vector(v, _) => return list![Sym("vec".to_string()), qq_iter(&v)],
+        Hash(_, _) | Sym(_) => return list![Sym("quote".to_string()), ast.clone()],
+        _ => ast.clone(),
+    }
+}
+
+fn is_macro_call(ast: &MalVal, env: &Env) -> Option<(MalVal, MalArgs)> {
+    match ast {
+        List(v, _) => match v[0] {
+            Sym(ref s) => match env_find(env, s) {
+                Some(e) => match env_get(&e, &v[0]) {
+                    Ok(f @ MalFunc { is_macro: true, .. }) => Some((f, v[1..].to_vec())),
+                    _ => None,
+                },
+                _ => None,
+            },
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
+fn macroexpand(mut ast: MalVal, env: &Env) -> (bool, MalRet) {
+    let mut was_expanded = false;
+    while let Some((mf, args)) = is_macro_call(&ast, env) {
+        //println!("macroexpand 1: {:?}", ast);
+        ast = match mf.apply(args) {
+            Err(e) => return (false, Err(e)),
+            Ok(a) => a,
+        };
+        //println!("macroexpand 2: {:?}", ast);
+        was_expanded = true;
+    }
+    ((was_expanded, Ok(ast)))
+}
+
+fn eval_ast(ast: &MalVal, env: &Env) -> MalRet {
+    match ast {
+        Sym(_) => Ok(env_get(&env, &ast)?),
+        List(v, _) => {
+            let mut lst: MalArgs = vec![];
+            for a in v.iter() {
+                lst.push(eval(a.clone(), env.clone())?)
+            }
+            Ok(list!(lst))
+        }
+        Vector(v, _) => {
+            let mut lst: MalArgs = vec![];
+            for a in v.iter() {
+                lst.push(eval(a.clone(), env.clone())?)
+            }
+            Ok(vector!(lst))
+        }
+        Hash(hm, _) => {
+            let mut new_hm: FnvHashMap<String, MalVal> = FnvHashMap::default();
+            for (k, v) in hm.iter() {
+                new_hm.insert(k.to_string(), eval(v.clone(), env.clone())?);
+            }
+            Ok(Hash(Rc::new(new_hm), Rc::new(Nil)))
+        }
+        _ => Ok(ast.clone()),
+    }
+}
+
+fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
+    let ret: MalRet;
+
+    'tco: loop {
+        ret = match ast.clone() {
+            List(l, _) => {
+                if l.len() == 0 {
+                    return Ok(ast);
+                }
+                match macroexpand(ast.clone(), &env) {
+                    (true, Ok(new_ast)) => {
+                        ast = new_ast;
+                        continue 'tco;
+                    }
+                    (_, Err(e)) => return Err(e),
+                    _ => (),
+                }
+
+                if l.len() == 0 {
+                    return Ok(ast);
+                }
+                let a0 = &l[0];
+                match a0 {
+                    Sym(ref a0sym) if a0sym == "def!" => {
+                        env_set(&env, l[1].clone(), eval(l[2].clone(), env.clone())?)
+                    }
+                    Sym(ref a0sym) if a0sym == "let*" => {
+                        env = env_new(Some(env.clone()));
+                        let (a1, a2) = (l[1].clone(), l[2].clone());
+                        match a1 {
+                            List(ref binds, _) | Vector(ref binds, _) => {
+                                for (b, e) in binds.iter().tuples() {
+                                    match b {
+                                        Sym(_) => {
+                                            let _ = env_set(
+                                                &env,
+                                                b.clone(),
+                                                eval(e.clone(), env.clone())?,
+                                            );
+                                        }
+                                        _ => {
+                                            return error("let* with non-Sym binding");
+                                        }
+                                    }
+                                }
+                            }
+                            _ => {
+                                return error("let* with non-List bindings");
+                            }
+                        };
+                        ast = a2;
+                        continue 'tco;
+                    }
+                    Sym(ref a0sym) if a0sym == "quote" => Ok(l[1].clone()),
+                    Sym(ref a0sym) if a0sym == "quasiquoteexpand" => Ok(quasiquote(&l[1])),
+                    Sym(ref a0sym) if a0sym == "quasiquote" => {
+                        ast = quasiquote(&l[1]);
+                        continue 'tco;
+                    }
+                    Sym(ref a0sym) if a0sym == "defmacro!" => {
+                        let (a1, a2) = (l[1].clone(), l[2].clone());
+                        let r = eval(a2, env.clone())?;
+                        match r {
+                            MalFunc {
+                                eval,
+                                ast,
+                                env,
+                                params,
+                                ..
+                            } => Ok(env_set(
+                                &env,
+                                a1.clone(),
+                                MalFunc {
+                                    eval: eval,
+                                    ast: ast.clone(),
+                                    env: env.clone(),
+                                    params: params.clone(),
+                                    is_macro: true,
+                                    meta: Rc::new(Nil),
+                                },
+                            )?),
+                            _ => error("set_macro on non-function"),
+                        }
+                    }
+                    Sym(ref a0sym) if a0sym == "macroexpand" => {
+                        match macroexpand(l[1].clone(), &env) {
+                            (_, Ok(new_ast)) => Ok(new_ast),
+                            (_, e) => return e,
+                        }
+                    }
+                    Sym(ref a0sym) if a0sym == "try*" => match eval(l[1].clone(), env.clone()) {
+                        Err(ref e) if l.len() >= 3 => {
+                            let exc = match e {
+                                ErrMalVal(mv) => mv.clone(),
+                                ErrString(s) => Str(s.to_string()),
+                            };
+                            match l[2].clone() {
+                                List(c, _) => {
+                                    let catch_env = env_bind(
+                                        Some(env.clone()),
+                                        list!(vec![c[1].clone()]),
+                                        vec![exc],
+                                    )?;
+                                    eval(c[2].clone(), catch_env)
+                                }
+                                _ => error("invalid catch block"),
+                            }
+                        }
+                        res => res,
+                    },
+                    Sym(ref a0sym) if a0sym == "do" => {
+                        match eval_ast(&list!(l[1..l.len() - 1].to_vec()), &env)? {
+                            List(_, _) => {
+                                ast = l.last().unwrap_or(&Nil).clone();
+                                continue 'tco;
+                            }
+                            _ => error("invalid do form"),
+                        }
+                    }
+                    Sym(ref a0sym) if a0sym == "if" => {
+                        let cond = eval(l[1].clone(), env.clone())?;
+                        match cond {
+                            Bool(false) | Nil if l.len() >= 4 => {
+                                ast = l[3].clone();
+                                continue 'tco;
+                            }
+                            Bool(false) | Nil => Ok(Nil),
+                            _ if l.len() >= 3 => {
+                                ast = l[2].clone();
+                                continue 'tco;
+                            }
+                            _ => Ok(Nil),
+                        }
+                    }
+                    Sym(ref a0sym) if a0sym == "zkcons!" => {
+                        let (a1, a2) = (l[1].clone(), l[2].clone());
+                        let value = eval_ast(&a2, &env)?;
+                        match value {
+                            List(ref el, _) => {
+                                let val = zkcons_eval(el.to_vec(), &a1, &env)?;
+                                val.clone();
+                            }
+                            _ => println!("invalid format"),
+                        }
+//                        println!("3 {:?}", eval(a1.clone(), env.clone()));
+                        env_set(&env, a1.clone(), eval(a1.clone(), env.clone())?); 
+                        eval(a1.clone(), env.clone())
+                    }
+                    Sym(ref a0sym) if a0sym == "defzk!" => {
+                        // private, public and constrains
+                        //let (a1, a2, a3) = (l[1].clone(), l[2].clone(), l[3].clone());
+                        let (a1) = (l[1].clone());
+                        let circuit = zk_circuit_create(&a1, &env);
+                        let val = types::MalVal::Zk(circuit.clone());
+                        env_set(&env, a1.clone(), val.clone());
+                        Ok(val.clone())
+                    }
+                    Sym(ref a0sym) if a0sym == "fn*" => {
+                        let (a1, a2) = (l[1].clone(), l[2].clone());
+                        Ok(MalFunc {
+                            eval: eval,
+                            ast: Rc::new(a2),
+                            env: env,
+                            params: Rc::new(a1),
+                            is_macro: false,
+                            meta: Rc::new(Nil),
+                        })
+                    }
+                    Sym(ref a0sym) if a0sym == "eval" => {
+                        ast = eval(l[1].clone(), env.clone())?;
+                        while let Some(ref e) = env.clone().outer {
+                            env = e.clone();
+                        }
+                        continue 'tco;
+                    }
+                    _ => match eval_ast(&ast, &env)? {
+                        List(ref el, _) => {
+                            let ref f = el[0].clone();
+                            let args = el[1..].to_vec();
+                            match f {
+                                Func(_, _) => f.apply(args),
+                                MalFunc {
+                                    ast: mast,
+                                    env: menv,
+                                    params,
+                                    ..
+                                } => {
+                                    let a = &**mast;
+                                    let p = &**params;
+                                    env = env_bind(Some(menv.clone()), p.clone(), args)?;
+                                    ast = a.clone();
+                                    continue 'tco;
+                                }
+                                _ => {
+                                    Ok(Nil)
+                                    //error("call non-function")
+                                }
+                            }
+                        }
+                        _ => error("expected a list"),
+                    },
+                }
+            }
+            _ => eval_ast(&ast, &env),
+        };
+
+        break;
+    } // end 'tco loop
+
+    ret
+}
+
+fn zk_circuit_create(a1: &MalVal, env: &Env) -> ZKCircuit {
+    let zk_circuit = ZKCircuit {
+        name: a1.pr_str(true),
+        constraints: Vec::new(),
+        private: Vec::new(),
+        public: Vec::new(),
+    };
+    zk_circuit
+}
+
+fn zkcons_eval(elements: Vec<MalVal>, a1: &MalVal, env: &Env) -> MalRet {
+    let zkc = match eval(a1.clone(), env.clone()) {
+        Ok(mut zkv) => {
+            match zkv {
+                Zk(mut zk) => {
+                    for b in elements.iter() {
+                        match b {
+                            Add(b1, b2) => {
+                                zk.private
+                                    .push(Scalar::from_string(&b2.pr_str(false).to_string()));
+                                let const_a: ConstraintInstruction = match b1.apply(vec![])? {
+                                    Lc0 => ConstraintInstruction::Lc0Add(zk.private.len()),
+                                    Lc1 => ConstraintInstruction::Lc1Add(zk.private.len()),
+                                    Lc2 => ConstraintInstruction::Lc2Add(zk.private.len()),
+                                    _ => {
+                                        println!("{:?}", b1.apply(vec![]));
+                                        ConstraintInstruction::Lc0Add(0)
+                                    }
+                                };
+                                zk.constraints.push(const_a);
+                                //env_set(&env, a1.clone(), types::MalVal::Zk(zk.clone()));
+                            }
+                            Sub(b1, b2) => {
+                                zk.private
+                                    .push(Scalar::from_string(&b2.pr_str(false).to_string()));
+                                let const_a: ConstraintInstruction = match b1.apply(vec![])? {
+                                    Lc0 => ConstraintInstruction::Lc0Sub(zk.private.len()),
+                                    Lc1 => ConstraintInstruction::Lc1Sub(zk.private.len()),
+                                    Lc2 => ConstraintInstruction::Lc2Sub(zk.private.len()),
+                                    _ => {
+                                        println!("{:?}", b1.apply(vec![]));
+                                        ConstraintInstruction::Lc0Sub(0)
+                                    }
+                                };
+                                zk.constraints.push(const_a);
+                                //env_set(&env, a1.clone(), types::MalVal::Zk(zk.clone()));
+                            },
+                            Enforce => {
+                                zk.constraints.push(ConstraintInstruction::Enforce);
+                            }
+                            _ => println!("not mapped"),
+                        }
+                    }
+                    env_set(&env, a1.clone(), types::MalVal::Zk(zk.clone()));
+                }
+                _ => println!("not parsed"),
+            }
+        }
+        _ => println!("not a circuit"),
+    };
+
+    env_get(&env, &a1.clone())
+}
+
+// print
+fn print(ast: &MalVal) -> String {
+    ast.pr_str(true)
+}
+
+fn rep(str: &str, env: &Env) -> Result<String, MalErr> {
+    let ast = read(str)?;
+    let exp = eval(ast, env.clone())?;
+    Ok(print(&exp))
+}
+
+fn main() -> Result<(), ()> {
+    let matches = clap_app!(zklisp =>
+        (version: "0.1.0")
+        (author: "Roberto Santacroce Martins <miles.chet@gmail.com>")
+        (about: "A Lisp Interpreter for Zero Knowledge Virtual Machine")
+        (@subcommand load =>
+            (about: "Load the file into the interpreter")
+            (@arg FILE: +required "Lisp Contract filename")
+        )
+    )
+    .get_matches();
+
+    CombinedLogger::init(vec![TermLogger::new(
+        LevelFilter::Debug,
+        Config::default(),
+        TerminalMode::Mixed,
+    )
+    .unwrap()])
+    .unwrap();
+
+    match matches.subcommand() {
+        Some(("load", matches)) => {
+            let file: String = matches.value_of("FILE").unwrap().parse().unwrap();
+            repl_load(file);
+        }
+        _ => {
+            eprintln!("error: Invalid subcommand invoked");
+            std::process::exit(-1);
+        }
+    }
+
+    Ok(())
+}
+
+fn repl_load(file: String) -> Result<(), ()> {
+    let repl_env = env_new(None);
+    for (k, v) in core::ns() {
+        env_sets(&repl_env, k, v);
+    }
+    let _ = rep("(def! *host-language* \"rust\")", &repl_env);
+    let _ = rep("(def! not (fn* (a) (if a false true)))", &repl_env);
+    let _ = rep(
+        "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \"\nnil)\")))))",
+        &repl_env,
+    );
+    let _ = rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))", &repl_env);
+    match rep(&format!("(load-file \"{}\")", file), &repl_env) {
+        Ok(_) => std::process::exit(0),
+        Err(e) => {
+            println!("Error: {}", format_error(e));
+            std::process::exit(1);
+        }
+    }
+    Ok(())
+}

lisp/new.lisp

@@ -0,0 +1,17 @@
+(def! x "73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000000")
+(def! one "0000000000000000000000000000000000000000000000000000000000000001")
+(def! bits (unpack-bits x))
+(defzk! circuit ())
+(def! cvalues (map (fn* [b] (eval
+                    (add lc0 one) 
+                    (sub lc0 b)
+                    (add lc1 x)
+                    enforce)
+                        ) bits))
+(def! cs (concat cvalues (list 
+                 'reset-coeff-lc
+                 (sub lc0 x)
+                 (add lc1 one)
+                 'enforce)))
+(println "bit-dec")
+(zkcons! circuit cs)

lisp/printer.rs

@@ -0,0 +1,66 @@
+use crate::types::MalVal;
+use crate::types::MalVal::{Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector, Zk};
+
+fn escape_str(s: &str) -> String {
+    s.chars()
+        .map(|c| match c {
+            '"' => "\\\"".to_string(),
+            '\n' => "\\n".to_string(),
+            '\\' => "\\\\".to_string(),
+            _ => c.to_string(),
+        })
+        .collect::<Vec<String>>()
+        .join("")
+}
+
+impl MalVal {
+    pub fn pr_str(&self, print_readably: bool) -> String {
+        match self {
+            Nil => String::from("nil"),
+            Bool(true) => String::from("true"),
+            Bool(false) => String::from("false"),
+            Int(i) => format!("{}", i),
+            //Float(f)    => format!("{}", f),
+            Str(s) => {
+                if s.starts_with("\u{29e}") {
+                    format!(":{}", &s[2..])
+                } else if print_readably {
+                    format!("\"{}\"", escape_str(s))
+                } else {
+                    s.clone()
+                }
+            }
+            Sym(s) => s.clone(),
+            List(l, _) => pr_seq(&**l, print_readably, "(", ")", " "),
+            Vector(l, _) => pr_seq(&**l, print_readably, "[", "]", " "),
+            Hash(hm, _) => {
+                let l: Vec<MalVal> = hm
+                    .iter()
+                    .flat_map(|(k, v)| vec![Str(k.to_string()), v.clone()])
+                    .collect();
+                pr_seq(&l, print_readably, "{", "}", " ")
+            }
+            Func(f, _) => format!("#<fn {:?}>", f),
+            MalFunc {
+                ast: a, params: p, ..
+            } => format!("(fn* {} {})", p.pr_str(true), a.pr_str(true)),
+            Atom(a) => format!("(atom {})", a.borrow().pr_str(true)),
+            Zk(a) => format!("{:?}", a),
+            Add => format!("add"),
+            Sub => format!("sub"),
+            Lc0 => format!("Lc0"),
+            i => format!("{:?}", i.pr_str(true)),
+        }
+    }
+}
+
+pub fn pr_seq(
+    seq: &Vec<MalVal>,
+    print_readably: bool,
+    start: &str,
+    end: &str,
+    join: &str,
+) -> String {
+    let strs: Vec<String> = seq.iter().map(|x| x.pr_str(print_readably)).collect();
+    format!("{}{}{}", start, strs.join(join), end)
+}

lisp/reader.rs

@@ -0,0 +1,156 @@
+use regex::{Captures, Regex};
+use std::rc::Rc;
+
+use crate::types::MalErr::ErrString;
+use crate::types::MalVal::{Bool, Int, List, Nil, Str, Sym, Vector};
+use crate::types::{error, hash_map, MalErr, MalRet, MalVal};
+
+#[derive(Debug, Clone)]
+struct Reader {
+    tokens: Vec<String>,
+    pos: usize,
+}
+
+impl Reader {
+    fn next(&mut self) -> Result<String, MalErr> {
+        self.pos = self.pos + 1;
+        Ok(self
+            .tokens
+            .get(self.pos - 1)
+            .ok_or(ErrString("underflow".to_string()))?
+            .to_string())
+    }
+    fn peek(&self) -> Result<String, MalErr> {
+        Ok(self
+            .tokens
+            .get(self.pos)
+            .ok_or(ErrString("underflow".to_string()))?
+            .to_string())
+    }
+}
+
+fn tokenize(str: &str) -> Vec<String> {
+    lazy_static! {
+        static ref RE: Regex = Regex::new(
+            r###"[\s,]*(~@|[\[\]{}()'`~^@]|"(?:\\.|[^\\"])*"?|;.*|[^\s\[\]{}('"`,;)]+)"###
+        )
+        .unwrap();
+    }
+
+    let mut res = vec![];
+    for cap in RE.captures_iter(str) {
+        if cap[1].starts_with(";") {
+            continue;
+        }
+        res.push(String::from(&cap[1]));
+    }
+    res
+}
+
+fn unescape_str(s: &str) -> String {
+    lazy_static! {
+        static ref RE: Regex = Regex::new(r#"\\(.)"#).unwrap();
+    }
+    RE.replace_all(&s, |caps: &Captures| {
+        format!("{}", if &caps[1] == "n" { "\n" } else { &caps[1] })
+    })
+    .to_string()
+}
+
+fn read_atom(rdr: &mut Reader) -> MalRet {
+    lazy_static! {
+        static ref INT_RE: Regex = Regex::new(r"^-?[0-9]+$").unwrap();
+        static ref STR_RE: Regex = Regex::new(r#""(?:\\.|[^\\"])*""#).unwrap();
+    }
+    let token = rdr.next()?;
+    match &token[..] {
+        "nil" => Ok(Nil),
+        "false" => Ok(Bool(false)),
+        "true" => Ok(Bool(true)),
+        _ => {
+            if INT_RE.is_match(&token) {
+                Ok(Int(token.parse().unwrap()))
+            } else if STR_RE.is_match(&token) {
+                Ok(Str(unescape_str(&token[1..token.len() - 1])))
+            } else if token.starts_with("\"") {
+                error("expected '\"', got EOF")
+            } else if token.starts_with(":") {
+                Ok(Str(format!("\u{29e}{}", &token[1..])))
+            } else {
+                Ok(Sym(token.to_string()))
+            }
+        }
+    }
+}
+
+fn read_seq(rdr: &mut Reader, end: &str) -> MalRet {
+    let mut seq: Vec<MalVal> = vec![];
+    rdr.next()?;
+    loop {
+        let token = match rdr.peek() {
+            Ok(t) => t,
+            Err(_) => return error(&format!("expected '{}', got EOF", end)),
+        };
+        if token == end {
+            break;
+        }
+        seq.push(read_form(rdr)?)
+    }
+    let _ = rdr.next();
+    match end {
+        ")" => Ok(list!(seq)),
+        "]" => Ok(vector!(seq)),
+        "}" => hash_map(seq),
+        _ => error("read_seq unknown end value"),
+    }
+}
+
+fn read_form(rdr: &mut Reader) -> MalRet {
+    let token = rdr.peek()?;
+    match &token[..] {
+        "'" => {
+            let _ = rdr.next();
+            Ok(list![Sym("quote".to_string()), read_form(rdr)?])
+        }
+        "`" => {
+            let _ = rdr.next();
+            Ok(list![Sym("quasiquote".to_string()), read_form(rdr)?])
+        }
+        "~" => {
+            let _ = rdr.next();
+            Ok(list![Sym("unquote".to_string()), read_form(rdr)?])
+        }
+        "~@" => {
+            let _ = rdr.next();
+            Ok(list![Sym("splice-unquote".to_string()), read_form(rdr)?])
+        }
+        "^" => {
+            let _ = rdr.next();
+            let meta = read_form(rdr)?;
+            Ok(list![Sym("with-meta".to_string()), read_form(rdr)?, meta])
+        }
+        "@" => {
+            let _ = rdr.next();
+            Ok(list![Sym("deref".to_string()), read_form(rdr)?])
+        }
+        ")" => error("unexpected ')'"),
+        "(" => read_seq(rdr, ")"),
+        "]" => error("unexpected ']'"),
+        "[" => read_seq(rdr, "]"),
+        "}" => error("unexpected '}'"),
+        "{" => read_seq(rdr, "}"),
+        _ => read_atom(rdr),
+    }
+}
+
+pub fn read_str(str: String) -> MalRet {
+    let tokens = tokenize(&str);
+    //println!("tokens: {:?}", tokens);
+    if tokens.len() == 0 {
+        return error("no input");
+    }
+    read_form(&mut Reader {
+        pos: 0,
+        tokens: tokens,
+    })
+}

lisp/types.rs

@@ -0,0 +1,269 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+//use std::collections::HashMap;
+use fnv::FnvHashMap;
+use itertools::Itertools;
+
+use crate::env::{env_bind, Env};
+use crate::types::MalErr::{ErrMalVal, ErrString};
+use crate::types::MalVal::{Atom, Bool, Func, Hash, Int, List, MalFunc, Nil, Str, Sym, Vector};
+
+use bls12_381::Scalar;
+use sapvi::{
+    BlsStringConversion, ConstraintInstruction, Decodable, Encodable, ZKContract, ZKProof,
+    ZKVMCircuit,
+};
+
+use bellman::{
+    gadgets::{
+        boolean::{AllocatedBit, Boolean},
+        multipack, num, Assignment,
+    },
+    groth16, Circuit, ConstraintSystem, SynthesisError,
+};
+
+#[derive(Debug, Clone)]
+pub enum MalVal {
+    Nil,
+    Bool(bool),
+    Int(i64),
+    //Float(f64),
+    Str(String),
+    Sym(String),
+    List(Rc<Vec<MalVal>>, Rc<MalVal>),
+    Vector(Rc<Vec<MalVal>>, Rc<MalVal>),
+    Hash(Rc<FnvHashMap<String, MalVal>>, Rc<MalVal>),
+    Func(fn(MalArgs) -> MalRet, Rc<MalVal>),
+    MalFunc {
+        eval: fn(ast: MalVal, env: Env) -> MalRet,
+        ast: Rc<MalVal>,
+        env: Env,
+        params: Rc<MalVal>,
+        is_macro: bool,
+        meta: Rc<MalVal>,
+    },
+    Atom(Rc<RefCell<MalVal>>),
+    Zk(ZKCircuit),
+    Lc0,
+    Lc1,
+    Lc2,
+    Enforce,
+    Add(Rc<MalVal>, Rc<MalVal>),
+    Sub(Rc<MalVal>, Rc<MalVal>),
+}
+
+#[derive(Debug, Clone)]
+pub struct ZKCircuit {
+    pub name: String,
+    pub constraints: Vec<ConstraintInstruction>,
+    pub private: Vec<Scalar>,
+    pub public: Vec<Scalar>,
+}
+
+#[derive(Debug)]
+pub enum MalErr {
+    ErrString(String),
+    ErrMalVal(MalVal),
+}
+
+pub type MalArgs = Vec<MalVal>;
+pub type MalRet = Result<MalVal, MalErr>;
+
+// type utility macros
+
+macro_rules! list {
+  ($seq:expr) => {{
+    List(Rc::new($seq),Rc::new(Nil))
+  }};
+  [$($args:expr),*] => {{
+    let v: Vec<MalVal> = vec![$($args),*];
+    List(Rc::new(v),Rc::new(Nil))
+  }}
+}
+
+macro_rules! vector {
+  ($seq:expr) => {{
+    Vector(Rc::new($seq),Rc::new(Nil))
+  }};
+  [$($args:expr),*] => {{
+    let v: Vec<MalVal> = vec![$($args),*];
+    Vector(Rc::new(v),Rc::new(Nil))
+  }}
+}
+
+// type utility functions
+
+pub fn error(s: &str) -> MalRet {
+    Err(ErrString(s.to_string()))
+}
+
+pub fn format_error(e: MalErr) -> String {
+    match e {
+        ErrString(s) => s.clone(),
+        ErrMalVal(mv) => mv.pr_str(true),
+    }
+}
+
+pub fn atom(mv: &MalVal) -> MalVal {
+    Atom(Rc::new(RefCell::new(mv.clone())))
+}
+
+impl MalVal {
+    pub fn keyword(&self) -> MalRet {
+        match self {
+            Str(s) if s.starts_with("\u{29e}") => Ok(Str(s.to_string())),
+            Str(s) => Ok(Str(format!("\u{29e}{}", s))),
+            _ => error("invalid type for keyword"),
+        }
+    }
+
+    pub fn empty_q(&self) -> MalRet {
+        match self {
+            List(l, _) | Vector(l, _) => Ok(Bool(l.len() == 0)),
+            Nil => Ok(Bool(true)),
+            _ => error("invalid type for empty?"),
+        }
+    }
+
+    pub fn count(&self) -> MalRet {
+        match self {
+            List(l, _) | Vector(l, _) => Ok(Int(l.len() as i64)),
+            Nil => Ok(Int(0)),
+            _ => error("invalid type for count"),
+        }
+    }
+
+    pub fn apply(&self, args: MalArgs) -> MalRet {
+        match *self {
+            Func(f, _) => f(args),
+            MalFunc {
+                eval,
+                ref ast,
+                ref env,
+                ref params,
+                ..
+            } => {
+                let a = &**ast;
+                let p = &**params;
+                let fn_env = env_bind(Some(env.clone()), p.clone(), args)?;
+                Ok(eval(a.clone(), fn_env)?)
+            }
+            _ => error("attempt to call non-function"),
+        }
+    }
+
+    pub fn keyword_q(&self) -> bool {
+        match self {
+            Str(s) if s.starts_with("\u{29e}") => true,
+            _ => false,
+        }
+    }
+
+    pub fn deref(&self) -> MalRet {
+        match self {
+            Atom(a) => Ok(a.borrow().clone()),
+            _ => error("attempt to deref a non-Atom"),
+        }
+    }
+
+    pub fn reset_bang(&self, new: &MalVal) -> MalRet {
+        match self {
+            Atom(a) => {
+                *a.borrow_mut() = new.clone();
+                Ok(new.clone())
+            }
+            _ => error("attempt to reset! a non-Atom"),
+        }
+    }
+
+    pub fn swap_bang(&self, args: &MalArgs) -> MalRet {
+        match self {
+            Atom(a) => {
+                let f = &args[0];
+                let mut fargs = args[1..].to_vec();
+                fargs.insert(0, a.borrow().clone());
+                *a.borrow_mut() = f.apply(fargs)?;
+                Ok(a.borrow().clone())
+            }
+            _ => error("attempt to swap! a non-Atom"),
+        }
+    }
+
+    pub fn get_meta(&self) -> MalRet {
+        match self {
+            List(_, meta) | Vector(_, meta) | Hash(_, meta) => Ok((&**meta).clone()),
+            Func(_, meta) => Ok((&**meta).clone()),
+            MalFunc { meta, .. } => Ok((&**meta).clone()),
+            _ => error("meta not supported by type"),
+        }
+    }
+
+    pub fn with_meta(&mut self, new_meta: &MalVal) -> MalRet {
+        match self {
+            List(_, ref mut meta)
+            | Vector(_, ref mut meta)
+            | Hash(_, ref mut meta)
+            | Func(_, ref mut meta)
+            | MalFunc { ref mut meta, .. } => {
+                *meta = Rc::new((&*new_meta).clone());
+            }
+            _ => return error("with-meta not supported by type"),
+        };
+        Ok(self.clone())
+    }
+}
+
+impl PartialEq for MalVal {
+    fn eq(&self, other: &MalVal) -> bool {
+        match (self, other) {
+            (Nil, Nil) => true,
+            (Bool(ref a), Bool(ref b)) => a == b,
+            (Int(ref a), Int(ref b)) => a == b,
+            (Str(ref a), Str(ref b)) => a == b,
+            (Sym(ref a), Sym(ref b)) => a == b,
+            (List(ref a, _), List(ref b, _))
+            | (Vector(ref a, _), Vector(ref b, _))
+            | (List(ref a, _), Vector(ref b, _))
+            | (Vector(ref a, _), List(ref b, _)) => a == b,
+            (Hash(ref a, _), Hash(ref b, _)) => a == b,
+            (MalFunc { .. }, MalFunc { .. }) => false,
+            _ => false,
+        }
+    }
+}
+
+pub fn func(f: fn(MalArgs) -> MalRet) -> MalVal {
+    Func(f, Rc::new(Nil))
+}
+
+pub fn _assoc(mut hm: FnvHashMap<String, MalVal>, kvs: MalArgs) -> MalRet {
+    if kvs.len() % 2 != 0 {
+        return error("odd number of elements");
+    }
+    for (k, v) in kvs.iter().tuples() {
+        match k {
+            Str(s) => {
+                hm.insert(s.to_string(), v.clone());
+            }
+            _ => return error("key is not string"),
+        }
+    }
+    Ok(Hash(Rc::new(hm), Rc::new(Nil)))
+}
+
+pub fn _dissoc(mut hm: FnvHashMap<String, MalVal>, ks: MalArgs) -> MalRet {
+    for k in ks.iter() {
+        match k {
+            Str(ref s) => {
+                hm.remove(s);
+            }
+            _ => return error("key is not string"),
+        }
+    }
+    Ok(Hash(Rc::new(hm), Rc::new(Nil)))
+}
+
+pub fn hash_map(kvs: MalArgs) -> MalRet {
+    let hm: FnvHashMap<String, MalVal> = FnvHashMap::default();
+    _assoc(hm, kvs)
+}

src/vm.rs

@@ -55,7 +55,7 @@ pub enum AllocType {
     Public,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub enum ConstraintInstruction {
     Lc0Add(VariableIndex),
     Lc1Add(VariableIndex),