no more duplicate allocs: instantiate and replace root of the redex direcctly

Author: DavidLee18

src/compiler/mod.rs

@@ -115,15 +115,10 @@ fn sc_step(state: &mut TiState, sc_addr: Addr, arg_names: Vec<lang::Name>, body:
         globals.push_front(arg.clone());
     }
     let is_let = body.is_let();
-    let result_addr = heap.instantiate(body, globals);
     for _ in 0..arg_names_len {
         stack.pop();
     }
-    heap.update(
-        stack.pop().unwrap_or(sc_addr),
-        Node::Ind(result_addr),
-    );
-    stack.push(result_addr);
+    heap.instantiate_and_update(body, *stack.last().unwrap_or(&sc_addr), globals);
     if !is_let {
         for (name, _) in arg_bindings {
             for i in 0..globals.len() {

src/core/mod.rs

@@ -134,4 +134,38 @@ impl Heap<Node> {
             CoreExpr::Lam(_, _) => panic!("unable to instantiate lam"),
         }
     }
+
+    pub fn instantiate_and_update(
+        &mut self,
+        body: CoreExpr,
+        root_addr: Addr,
+        env: &mut ASSOC<Name, Addr>,
+    ) {
+        match body {
+            CoreExpr::Var(a) => {
+                let a_addr = env
+                    .iter()
+                    .find(|(n, _)| *n == a)
+                    .map(|(_, addr)| *addr)
+                    .expect(&format!("undefined name {}", a));
+                self.update(root_addr, Node::Ind(a_addr));
+            }
+            CoreExpr::Num(n) => self.update(root_addr, Node::Num(n)),
+            CoreExpr::Constr { .. } => panic!("unable to instantiate constr yet"),
+            CoreExpr::Ap(e1, e2) => {
+                let a1 = self.instantiate(*e1, env);
+                let a2 = self.instantiate(*e2, env);
+                self.update(root_addr, Node::Ap(a1, a2));
+            }
+            CoreExpr::Let { defs, body } => {
+                for (name, expr) in defs {
+                    let addr = self.alloc(Node::SuperComb(name.clone(), vec![], expr));
+                    env.push_front((name, addr));
+                }
+                self.instantiate_and_update(*body, root_addr, env);
+            }
+            CoreExpr::Case(_, _) => panic!("unable to instantiate case"),
+            CoreExpr::Lam(_, _) => panic!("unable to instantiate lam"),
+        }
+    }
 }

src/main.rs

@@ -15,6 +15,6 @@ fn run(s: String) -> String {
 }
 
 fn main() {
-    let program = String::from("id x = x; main = twice twice id 3");
+    let program = String::from("oct g x = let h = twice g in let k = twice h in k (k x); main = oct I 4");
     println!("{}", run(program));
 }