intern_syntax added

This will allow parsing Lurk code into `Ptr<F>`

src/lem/eval.rs

@@ -764,8 +764,11 @@ fn apply_cont() -> Func {
                                 return(hidden, env, continuation, makethunk)
                             }
                             Op2::Equal => {
-                                // TODO
-                                return (result, env, err, errctrl)
+                                // TODO should we check whether the tags are also equal?
+                                if evaled_arg == result {
+                                    return (t, env, continuation, makethunk)
+                                }
+                                return (nil, env, continuation, makethunk)
                             }
                             Op2::Sum => {
                                 // TODO deal with U64
@@ -879,8 +882,8 @@ mod tests {
     use blstrs::Scalar as Fr;
 
     const NUM_INPUTS: usize = 1;
-    const NUM_AUX: usize = 8027;
-    const NUM_CONSTRAINTS: usize = 9967;
+    const NUM_AUX: usize = 8032;
+    const NUM_CONSTRAINTS: usize = 9981;
     const NUM_SLOTS: SlotsCounter = SlotsCounter {
         hash2: 16,
         hash3: 4,

src/lem/store.rs

@@ -6,6 +6,8 @@ use crate::{
     hash::PoseidonCache,
     lem::Tag,
     tag::ExprTag::*,
+    syntax::Syntax,
+    uint::UInt,
 };
 use anyhow::{bail, Result};
 use dashmap::DashMap;
@@ -212,6 +214,49 @@ impl<F: LurkField> Store<F> {
         }
     }
 
+    pub fn intern_syntax(&mut self, syn: Syntax<F>) -> Ptr<F> {
+        match syn {
+            Syntax::Num(_, x) => Ptr::Leaf(Tag::Expr(Num), x.into_scalar()),
+            Syntax::UInt(_, UInt::U64(x)) => Ptr::Leaf(Tag::Expr(U64), x.into()),
+            Syntax::Char(_, x) => Ptr::Leaf(Tag::Expr(Char), (x as u64).into()),
+            Syntax::Symbol(_, x) => {
+                let path = x.path.iter().map(|s| Arc::from(s.clone())).collect();
+                self.intern_symbol(&Symbol::Sym(path))
+            },
+            Syntax::Keyword(_, x) => {
+                let path = x.path.iter().map(|s| Arc::from(s.clone())).collect();
+                self.intern_symbol(&Symbol::Key(path))
+            },
+            Syntax::LurkSym(_, x) => {
+                self.intern_symbol(&Symbol::lurk_sym(&format!("{x}")))
+            },
+            Syntax::String(_, x) => {
+                self.intern_string(&x)
+            },
+            Syntax::Quote(pos, x) => {
+                let quote = crate::symbol::Symbol::lurk_sym("quote");
+                let xs = vec![Syntax::Symbol(pos, quote), *x];
+                self.intern_syntax(Syntax::List(pos, xs))
+            }
+            Syntax::List(_, xs) => {
+                let mut cdr = self.intern_symbol(&Symbol::lurk_sym(&"nil"));
+                for x in xs.into_iter().rev() {
+                    let car = self.intern_syntax(x);
+                    cdr = self.intern_2_ptrs(Tag::Expr(Cons), car, cdr);
+                }
+                cdr
+            }
+            Syntax::Improper(_, xs, end) => {
+                let mut cdr = self.intern_syntax(*end);
+                for x in xs.into_iter().rev() {
+                    let car = self.intern_syntax(x);
+                    cdr = self.intern_2_ptrs(Tag::Expr(Cons), car, cdr);
+                }
+                cdr
+            }
+        }
+    }
+
     /// Recursively hashes the children of a `Ptr` in order to obtain its
     /// corresponding `ZPtr`. While traversing a `Ptr` tree, it consults the
     /// cache of `Ptr`s that have already been hydrated and also populates this