fix block compilation; compile & run repeat

bytecode_thoughts.md

@@ -229,3 +229,11 @@ struct StackFrame<'a> {
 
 This gives us a way to access everything we need: where to return to, the root of the stack, the chunk (function->chunk), the closures (function->closures).
 
+### 2024-12-26
+One particular concern here, which needs some work: recursion is challenging.
+
+In particular, the issue is that if, as I have been planning, a function closes over all its values at the moment it is compiled, the only value type that requires updating is a function. A function can be declared but not yet defined, and then when another function that uses that function is defined, the closed-over value will be to the declaration but not the definition.
+
+One way to handle this, I think is using `std::cell::OnceCell`. Rather than a `RefCell`, `OnceCell` has no runtime overhead. Instead, what happens is you effectively put a `None` in the cell. Then, once you have the value you want to put in there, you call `set` on the `OnceCell`, and it does what it needs to.
+
+This allows for the closures to be closed over right after compilation.

src/compiler.rs

@@ -4,6 +4,7 @@ use crate::value::*;
 use chumsky::prelude::SimpleSpan;
 use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::FromPrimitive;
+use std::cell::OnceCell;
 use std::rc::Rc;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, FromPrimitive, ToPrimitive)]
@@ -34,6 +35,12 @@ pub enum Op {
     PanicNoWhen,
     JumpIfNoMatch,
     PanicNoMatch,
+    TypeOf,
+    JumpBack,
+    JumpIfZero,
+    Duplicate,
+    Decrement,
+    Truncate,
 }
 
 impl std::fmt::Display for Op {
@@ -66,6 +73,12 @@ impl std::fmt::Display for Op {
             PanicNoWhen => "panic_no_when",
             JumpIfNoMatch => "jump_if_no_match",
             PanicNoMatch => "panic_no_match",
+            TypeOf => "type_of",
+            JumpBack => "jump_back",
+            JumpIfZero => "jump_if_zero",
+            Decrement => "decrement",
+            Truncate => "truncate",
+            Duplicate => "duplicate",
         };
         write!(f, "{rep}")
     }
@@ -79,14 +92,50 @@ pub struct Binding {
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct Chunk {
+    pub constants: Vec<Value>,
+    pub bytecode: Vec<u8>,
+    pub strings: Vec<&'static str>,
+    pub keywords: Vec<&'static str>,
+}
+
+impl Chunk {
+    pub fn dissasemble_instr(&self, i: usize) {
+        let op = Op::from_u8(self.bytecode[i]).unwrap();
+        use Op::*;
+        match op {
+            Pop | Store | Load | Nil | True | False | MatchNil | MatchTrue | MatchFalse
+            | PanicIfNoMatch | MatchWord | ResetMatch | GetKey | PanicNoWhen | PanicNoMatch
+            | TypeOf | Duplicate | Decrement | Truncate => {
+                println!("{i:04}: {op}")
+            }
+            Constant | MatchConstant => {
+                let next = self.bytecode[i + 1];
+                let value = &self.constants[next as usize].show(self);
+                println!("{i:04}: {:16} {next:04}: {value}", op.to_string());
+            }
+            PushBinding | MatchTuple | PushTuple | PushDict | PushList | PushBox | Jump
+            | JumpIfFalse | JumpIfNoMatch | JumpBack | JumpIfZero => {
+                let next = self.bytecode[i + 1];
+                println!("{i:04}: {:16} {next:04}", op.to_string());
+            }
+        }
+    }
+
+    pub fn kw_from(&self, kw: &str) -> Option<Value> {
+        self.kw_index_from(kw).map(Value::Keyword)
+    }
+
+    pub fn kw_index_from(&self, kw: &str) -> Option<usize> {
+        self.keywords.iter().position(|s| *s == kw)
+    }
+}
+
+pub struct Compiler {
+    pub chunk: Chunk,
     pub bindings: Vec<Binding>,
     scope_depth: isize,
     num_bindings: usize,
-    pub constants: Vec<Value>,
-    pub bytecode: Vec<u8>,
     pub spans: Vec<SimpleSpan>,
-    pub strings: Vec<&'static str>,
-    pub keywords: Vec<&'static str>,
     pub nodes: Vec<&'static Ast>,
     pub ast: &'static Ast,
     pub span: SimpleSpan,
@@ -104,19 +153,22 @@ fn is_binding(expr: &Spanned<Ast>) -> bool {
     }
 }
 
-impl Chunk {
+impl Compiler {
-    pub fn new(ast: &'static Spanned<Ast>, name: &'static str, src: &'static str) -> Chunk {
+    pub fn new(ast: &'static Spanned<Ast>, name: &'static str, src: &'static str) -> Compiler {
-        Chunk {
+        let chunk = Chunk {
-            bindings: vec![],
-            scope_depth: -1,
-            num_bindings: 0,
             constants: vec![],
             bytecode: vec![],
-            spans: vec![],
             strings: vec![],
             keywords: vec![
                 "nil", "bool", "number", "keyword", "string", "tuple", "list", "dict", "box", "fn",
             ],
+        };
+        Compiler {
+            chunk,
+            bindings: vec![],
+            scope_depth: -1,
+            num_bindings: 0,
+            spans: vec![],
             nodes: vec![],
             ast: &ast.0,
             span: ast.1,
@@ -130,7 +182,7 @@ impl Chunk {
     }
 
     pub fn kw_index_from(&self, kw: &str) -> Option<usize> {
-        self.keywords.iter().position(|s| *s == kw)
+        self.chunk.keywords.iter().position(|s| *s == kw)
     }
 
     pub fn visit(&mut self, node: &'static Spanned<Ast>) {
@@ -145,24 +197,24 @@ impl Chunk {
     }
 
     fn emit_constant(&mut self, val: Value) {
-        let constant_index = self.constants.len();
+        let constant_index = self.chunk.constants.len();
         if constant_index > u8::MAX as usize {
             panic!(
                 "internal Ludus compiler error: too many constants in chunk:{}:: {}",
                 self.span, self.ast
             )
         }
-        self.constants.push(val);
+        self.chunk.constants.push(val);
-        self.bytecode.push(Op::Constant as u8);
+        self.chunk.bytecode.push(Op::Constant as u8);
         self.spans.push(self.span);
-        self.bytecode.push(constant_index as u8);
+        self.chunk.bytecode.push(constant_index as u8);
         self.spans.push(self.span);
     }
 
     fn match_constant(&mut self, val: Value) {
-        let constant_index = match self.constants.iter().position(|v| *v == val) {
+        let constant_index = match self.chunk.constants.iter().position(|v| *v == val) {
             Some(idx) => idx,
-            None => self.constants.len(),
+            None => self.chunk.constants.len(),
         };
         if constant_index > u8::MAX as usize {
             panic!(
@@ -170,18 +222,18 @@ impl Chunk {
                 self.span, self.ast
             )
         }
-        if constant_index == self.constants.len() {
+        if constant_index == self.chunk.constants.len() {
-            self.constants.push(val);
+            self.chunk.constants.push(val);
         }
-        self.bytecode.push(Op::MatchConstant as u8);
+        self.chunk.bytecode.push(Op::MatchConstant as u8);
         self.spans.push(self.span);
-        self.bytecode.push(constant_index as u8);
+        self.chunk.bytecode.push(constant_index as u8);
         self.spans.push(self.span);
         self.bind("");
     }
 
     fn emit_op(&mut self, op: Op) {
-        self.bytecode.push(op as u8);
+        self.chunk.bytecode.push(op as u8);
         self.spans.push(self.span);
     }
 
@@ -195,26 +247,27 @@ impl Chunk {
     pub fn compile(&mut self) {
         use Ast::*;
         match self.ast {
+            Error => unreachable!(),
             Nil => self.emit_op(Op::Nil),
             Number(n) => self.emit_constant(Value::Number(*n)),
             Boolean(b) => self.emit_op(if *b { Op::True } else { Op::False }),
             String(s) => {
-                let existing_str = self.strings.iter().position(|e| e == s);
+                let existing_str = self.chunk.strings.iter().position(|e| e == s);
                 let str_index = match existing_str {
                     Some(idx) => idx,
-                    None => self.strings.len(),
+                    None => self.chunk.strings.len(),
                 };
-                self.strings.push(s);
+                self.chunk.strings.push(s);
                 self.emit_constant(Value::Interned(str_index));
             }
             Keyword(s) => {
-                let existing_kw = self.keywords.iter().position(|kw| kw == s);
+                let existing_kw = self.chunk.keywords.iter().position(|kw| kw == s);
                 let kw_index = match existing_kw {
                     Some(index) => index,
-                    None => self.keywords.len(),
+                    None => self.chunk.keywords.len(),
                 };
-                if kw_index == self.keywords.len() {
+                if kw_index == self.chunk.keywords.len() {
-                    self.keywords.push(s);
+                    self.chunk.keywords.push(s);
                 }
                 self.emit_constant(Value::Keyword(kw_index));
             }
@@ -222,13 +275,19 @@ impl Chunk {
                 self.scope_depth += 1;
                 for expr in lines.iter().take(lines.len() - 1) {
                     if is_binding(expr) {
-                        self.visit(expr)
+                        self.visit(expr);
                     } else {
                         self.visit(expr);
                         self.emit_op(Op::Pop);
                     }
                 }
-                self.visit(lines.last().unwrap());
+                let last_expr = lines.last().unwrap();
+                if is_binding(last_expr) {
+                    self.visit(last_expr);
+                    self.emit_op(Op::Duplicate);
+                } else {
+                    self.visit(last_expr);
+                }
                 self.emit_op(Op::Store);
                 self.scope_depth -= 1;
                 while let Some(binding) = self.bindings.last() {
@@ -239,23 +298,24 @@ impl Chunk {
                         break;
                     }
                 }
+                self.emit_op(Op::Pop);
                 self.emit_op(Op::Load);
             }
             If(cond, then, r#else) => {
                 self.visit(cond);
-                let jif_idx = self.bytecode.len();
+                let jif_idx = self.chunk.bytecode.len();
                 self.emit_op(Op::JumpIfFalse);
-                self.bytecode.push(0xff);
+                self.chunk.bytecode.push(0xff);
                 self.visit(then);
-                let jump_idx = self.bytecode.len();
+                let jump_idx = self.chunk.bytecode.len();
                 self.emit_op(Op::Jump);
-                self.bytecode.push(0xff);
+                self.chunk.bytecode.push(0xff);
                 self.visit(r#else);
-                let end_idx = self.bytecode.len();
+                let end_idx = self.chunk.bytecode.len();
                 let jif_offset = jump_idx - jif_idx;
-                let jump_offset = end_idx - jump_idx;
+                let jump_offset = end_idx - jump_idx - 2;
-                self.bytecode[jif_idx + 1] = jif_offset as u8;
+                self.chunk.bytecode[jif_idx + 1] = jif_offset as u8;
-                self.bytecode[jump_idx + 1] = jump_offset as u8;
+                self.chunk.bytecode[jump_idx + 1] = jump_offset as u8;
             }
             Let(patt, expr) => {
                 self.emit_op(Op::ResetMatch);
@@ -272,7 +332,7 @@ impl Chunk {
                 let biter = self.bindings.iter().enumerate().rev();
                 for (i, binding) in biter {
                     if binding.name == *name {
-                        self.bytecode.push(i as u8);
+                        self.chunk.bytecode.push(i as u8);
                         break;
                     }
                 }
@@ -298,24 +358,24 @@ impl Chunk {
                 self.match_constant(Value::Number(*n));
             }
             KeywordPattern(s) => {
-                let existing_kw = self.keywords.iter().position(|kw| kw == s);
+                let existing_kw = self.chunk.keywords.iter().position(|kw| kw == s);
                 let kw_index = match existing_kw {
                     Some(index) => index,
-                    None => self.keywords.len(),
+                    None => self.chunk.keywords.len(),
                 };
-                if kw_index == self.keywords.len() {
+                if kw_index == self.chunk.keywords.len() {
-                    self.keywords.push(s);
+                    self.chunk.keywords.push(s);
                 }
                 self.match_constant(Value::Keyword(kw_index));
             }
             StringPattern(s) => {
-                let existing_str = self.strings.iter().position(|e| e == s);
+                let existing_str = self.chunk.strings.iter().position(|e| e == s);
                 let str_index = match existing_str {
                     Some(idx) => idx,
-                    None => self.strings.len(),
+                    None => self.chunk.strings.len(),
                 };
-                if str_index == self.strings.len() {
+                if str_index == self.chunk.strings.len() {
-                    self.strings.push(s)
+                    self.chunk.strings.push(s)
                 }
                 self.match_constant(Value::Interned(str_index));
             }
@@ -324,14 +384,14 @@ impl Chunk {
                     self.visit(member);
                 }
                 self.emit_op(Op::PushTuple);
-                self.bytecode.push(members.len() as u8);
+                self.chunk.bytecode.push(members.len() as u8);
             }
             List(members) => {
                 for member in members {
                     self.visit(member);
                 }
                 self.emit_op(Op::PushList);
-                self.bytecode.push(members.len() as u8);
+                self.chunk.bytecode.push(members.len() as u8);
             }
             LBox(name, expr) => {
                 self.visit(expr);
@@ -343,16 +403,16 @@ impl Chunk {
                     self.visit(pair);
                 }
                 self.emit_op(Op::PushDict);
-                self.bytecode.push(pairs.len() as u8);
+                self.chunk.bytecode.push(pairs.len() as u8);
             }
             Pair(key, value) => {
-                let existing_kw = self.keywords.iter().position(|kw| kw == key);
+                let existing_kw = self.chunk.keywords.iter().position(|kw| kw == key);
                 let kw_index = match existing_kw {
                     Some(index) => index,
-                    None => self.keywords.len(),
+                    None => self.chunk.keywords.len(),
                 };
-                if kw_index == self.keywords.len() {
+                if kw_index == self.chunk.keywords.len() {
-                    self.keywords.push(key);
+                    self.chunk.keywords.push(key);
                 }
                 self.emit_constant(Value::Keyword(kw_index));
                 self.visit(value);
@@ -385,20 +445,21 @@ impl Chunk {
                 while let Some((WhenClause(cond, body), _)) = clauses.next() {
                     self.visit(cond.as_ref());
                     self.emit_op(Op::JumpIfFalse);
-                    let jif_jump_idx = self.bytecode.len();
+                    let jif_jump_idx = self.chunk.bytecode.len();
-                    self.bytecode.push(0xff);
+                    self.chunk.bytecode.push(0xff);
                     self.visit(body);
                     self.emit_op(Op::Jump);
-                    jump_idxes.push(self.bytecode.len());
+                    jump_idxes.push(self.chunk.bytecode.len());
-                    self.bytecode.push(0xff);
+                    self.chunk.bytecode.push(0xff);
-                    self.bytecode[jif_jump_idx] =
+                    self.chunk.bytecode[jif_jump_idx] =
-                        self.bytecode.len() as u8 - jif_jump_idx as u8 - 1;
+                        self.chunk.bytecode.len() as u8 - jif_jump_idx as u8 - 1;
                 }
                 self.emit_op(Op::PanicNoWhen);
                 for idx in jump_idxes {
-                    self.bytecode[idx] = self.bytecode.len() as u8 - idx as u8 + 1;
+                    self.chunk.bytecode[idx] = self.chunk.bytecode.len() as u8 - idx as u8 + 1;
                 }
             }
+            WhenClause(..) => unreachable!(),
             Match(scrutinee, clauses) => {
                 self.visit(scrutinee.as_ref());
                 let mut jump_idxes = vec![];
@@ -408,8 +469,8 @@ impl Chunk {
                     self.scope_depth += 1;
                     self.visit(pattern);
                     self.emit_op(Op::JumpIfNoMatch);
-                    let jnm_jump_idx = self.bytecode.len();
+                    let jnm_jump_idx = self.chunk.bytecode.len();
-                    self.bytecode.push(0xff);
+                    self.chunk.bytecode.push(0xff);
                     self.visit(body);
                     self.emit_op(Op::Store);
                     self.scope_depth -= 1;
@@ -422,87 +483,120 @@ impl Chunk {
                         }
                     }
                     self.emit_op(Op::Jump);
-                    jump_idxes.push(self.bytecode.len());
+                    jump_idxes.push(self.chunk.bytecode.len());
-                    self.bytecode.push(0xff);
+                    self.chunk.bytecode.push(0xff);
-                    self.bytecode[jnm_jump_idx] =
+                    self.chunk.bytecode[jnm_jump_idx] =
-                        self.bytecode.len() as u8 - jnm_jump_idx as u8 - 1;
+                        self.chunk.bytecode.len() as u8 - jnm_jump_idx as u8 - 1;
                 }
                 self.emit_op(Op::PanicNoMatch);
                 self.emit_op(Op::Load);
                 for idx in jump_idxes {
-                    self.bytecode[idx] = self.bytecode.len() as u8 - idx as u8 + 2;
+                    self.chunk.bytecode[idx] = self.chunk.bytecode.len() as u8 - idx as u8 + 2;
                 }
             }
+            MatchClause(..) => unreachable!(),
             Fn(name, body, doc) => {
-                let mut chunk = Chunk::new(body, self.name, self.src);
+                // first, declare the function
-                chunk.compile();
+                // TODO: or, check if the function has already been declared!
+                let init_val = Value::Fn(Rc::new(OnceCell::new()));
+                self.emit_constant(init_val);
+                self.bind(name);
+
+                // compile the function
+                let mut compiler = Compiler::new(body, self.name, self.src);
+                compiler.compile();
                 if crate::DEBUG_COMPILE {
                     println!("==function: {name}==");
-                    chunk.disassemble();
+                    compiler.disassemble();
                 }
+
                 let lfn = crate::value::LFn {
                     name,
                     doc: *doc,
-                    chunk,
+                    chunk: compiler.chunk,
+                    closed: vec![],
                 };
-                let fn_val = Value::Fn(Rc::new(lfn));
+
-                self.emit_constant(fn_val);
+                // TODO: close over everything accessed in the function
-                self.bind(name);
+
+                // TODO: pull the function off the stack, and set the OnceCell.
             }
             FnDeclaration(name) => {
-                todo!()
+                let lfn = Value::Fn(Rc::new(OnceCell::new()));
+                self.emit_constant(lfn);
+                self.bind(name);
             }
             FnBody(clauses) => {
                 self.emit_op(Op::ResetMatch);
             }
-            _ => todo!(),
+            Repeat(times, body) => {
+                self.visit(times);
+                self.emit_op(Op::Truncate);
+                // skip the decrement the first time
+                self.emit_op(Op::Jump);
+                self.chunk.bytecode.push(1);
+                // begin repeat
+                self.emit_op(Op::Decrement);
+                let repeat_begin = self.chunk.bytecode.len();
+                self.emit_op(Op::Duplicate);
+                self.emit_op(Op::JumpIfZero);
+                self.chunk.bytecode.push(0xff);
+                // compile the body
+                self.visit(body);
+                // pop whatever value the body returns
+                self.emit_op(Op::Pop);
+                self.emit_op(Op::JumpBack);
+                // set jump points
+                let repeat_end = self.chunk.bytecode.len();
+                self.chunk.bytecode.push((repeat_end - repeat_begin) as u8);
+                self.chunk.bytecode[repeat_begin + 2] = (repeat_end - repeat_begin - 2) as u8;
+                // pop the counter
+                self.emit_op(Op::Pop);
+                // and emit nil
+                self.emit_constant(Value::Nil);
+            }
+            Interpolated(..)
+            | Arguments(..)
+            | Placeholder
+            | Panic(..)
+            | Do(..)
+            | Splat(..)
+            | Loop(..)
+            | Recur(..)
+            | InterpolatedPattern(..)
+            | AsPattern(..)
+            | Splattern(..)
+            | TuplePattern(..)
+            | ListPattern(..)
+            | PairPattern(..)
+            | DictPattern(..) => todo!(),
         }
     }
 
     pub fn disassemble(&self) {
         println!("=== chunk: {} ===", self.name);
         println!("IDX | CODE           | INFO");
-        let mut codes = self.bytecode.iter().enumerate();
+        let mut codes = self.chunk.bytecode.iter().enumerate();
         while let Some((i, byte)) = codes.next() {
             let op = Op::from_u8(*byte).unwrap();
             use Op::*;
             match op {
                 Pop | Store | Load | Nil | True | False | MatchNil | MatchTrue | MatchFalse
-                | MatchWord | ResetMatch | PanicIfNoMatch | GetKey | PanicNoWhen | PanicNoMatch => {
+                | MatchWord | ResetMatch | PanicIfNoMatch | GetKey | PanicNoWhen | PanicNoMatch
+                | TypeOf | Duplicate | Truncate | Decrement => {
                     println!("{i:04}: {op}")
                 }
                 Constant | MatchConstant => {
                     let (_, next) = codes.next().unwrap();
-                    let value = &self.constants[*next as usize].show(self);
+                    let value = &self.chunk.constants[*next as usize].show(&self.chunk);
                     println!("{i:04}: {:16} {next:04}: {value}", op.to_string());
                 }
                 PushBinding | MatchTuple | PushTuple | PushDict | PushList | PushBox | Jump
-                | JumpIfFalse | JumpIfNoMatch => {
+                | JumpIfFalse | JumpIfNoMatch | JumpBack | JumpIfZero => {
                     let (_, next) = codes.next().unwrap();
                     println!("{i:04}: {:16} {next:04}", op.to_string());
                 }
             }
         }
     }
-
-    pub fn dissasemble_instr(&self, i: usize) {
-        let op = Op::from_u8(self.bytecode[i]).unwrap();
-        use Op::*;
-        match op {
-            Pop | Store | Load | Nil | True | False | MatchNil | MatchTrue | MatchFalse
-            | PanicIfNoMatch | MatchWord | ResetMatch | GetKey | PanicNoWhen | PanicNoMatch => {
-                println!("{i:04}: {op}")
-            }
-            Constant | MatchConstant => {
-                let next = self.bytecode[i + 1];
-                let value = &self.constants[next as usize].show(self);
-                println!("{i:04}: {:16} {next:04}: {value}", op.to_string());
-            }
-            PushBinding | MatchTuple | PushTuple | PushDict | PushList | PushBox | Jump
-            | JumpIfFalse | JumpIfNoMatch => {
-                let next = self.bytecode[i + 1];
-                println!("{i:04}: {:16} {next:04}", op.to_string());
-            }
-        }
-    }
 }

src/main.rs

@@ -17,7 +17,7 @@ use crate::parser::{parser, Ast};
 mod validator;
 
 mod compiler;
-use crate::compiler::Chunk;
+use crate::compiler::Compiler;
 
 mod value;
 
@@ -46,10 +46,10 @@ pub fn run(src: &'static str) {
     // in any event, the AST should live forever
     let parsed: &'static Spanned<Ast> = Box::leak(Box::new(parse_result.unwrap()));
 
-    let mut chunk = Chunk::new(parsed, "test", src);
+    let mut compiler = Compiler::new(parsed, "test", src);
-    chunk.compile();
+    compiler.compile();
     if DEBUG_COMPILE {
-        chunk.disassemble();
+        compiler.disassemble();
         println!("\n\n")
     }
 
@@ -57,10 +57,10 @@ pub fn run(src: &'static str) {
         println!("=== vm run: test ===");
     }
 
-    let mut vm = Vm::new(&chunk);
+    let mut vm = Vm::new(&compiler.chunk);
     let result = vm.interpret();
     let output = match result {
-        Ok(val) => val.show(&chunk),
+        Ok(val) => val.show(&compiler.chunk),
         Err(panic) => format!("{:?}", panic),
     };
     println!("{output}");
@@ -68,16 +68,9 @@ pub fn run(src: &'static str) {
 
 pub fn main() {
     let src = "
-let foo = 42
+let foo = 4
-match foo with {
+repeat foo {
-    :foo -> {
+    :foo
-        1
-        2
-        x
-    }
-    2 -> :two
-    42 -> :everything
-    _ -> :something_else
 }
     ";
     run(src);

src/value.rs

@@ -2,7 +2,7 @@ use crate::compiler::Chunk;
 use crate::parser::Ast;
 use crate::spans::Spanned;
 use imbl::{HashMap, Vector};
-use std::cell::RefCell;
+use std::cell::{OnceCell, RefCell};
 use std::rc::Rc;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -37,7 +37,7 @@ pub enum Value {
     List(Box<Vector<Value>>),
     Dict(Box<HashMap<usize, Value>>),
     Box(Rc<RefCell<Value>>),
-    Fn(Rc<LFn>),
+    Fn(Rc<OnceCell<LFn>>),
 }
 
 impl std::fmt::Display for Value {
@@ -78,7 +78,7 @@ impl std::fmt::Display for Value {
                     .join(", ")
             ),
             Box(value) => write!(f, "box {}", value.as_ref().borrow()),
-            Fn(lfn) => write!(f, "fn {}", lfn.name),
+            Fn(lfn) => write!(f, "fn {}", lfn.get().unwrap().name),
             _ => todo!(),
         }
     }
@@ -122,8 +122,27 @@ impl Value {
             }
             String(s) => s.as_ref().clone(),
             Box(x) => format!("box {{ {} }}", x.as_ref().borrow().show(ctx)),
-            Fn(lfn) => format!("fn {}", lfn.name),
+            Fn(lfn) => format!("fn {}", lfn.get().unwrap().name),
             _ => todo!(),
         }
     }
+
+    pub fn type_of(&self) -> &'static str {
+        use Value::*;
+        match self {
+            Nil => "nil",
+            True => "bool",
+            False => "bool",
+            Keyword(..) => "keyword",
+            Interned(..) => "string",
+            FnDecl(..) => "fn",
+            String(..) => "string",
+            Number(..) => "number",
+            Tuple(..) => "tuple",
+            List(..) => "list",
+            Dict(..) => "dict",
+            Box(..) => "box",
+            Fn(..) => "fn",
+        }
+    }
 }

src/vm.rs

@@ -57,6 +57,10 @@ impl<'a> Vm<'a> {
         self.stack.pop().unwrap()
     }
 
+    pub fn peek(&self) -> &Value {
+        self.stack.last().unwrap()
+    }
+
     fn print_stack(&self) {
         let inner = self
             .stack
@@ -68,8 +72,8 @@ impl<'a> Vm<'a> {
     }
 
     fn print_debug(&self) {
-        self.chunk.dissasemble_instr(self.ip);
         self.print_stack();
+        self.chunk.dissasemble_instr(self.ip);
     }
 
     pub fn interpret(&mut self) -> Result<Value, Panic> {
@@ -106,7 +110,12 @@ impl<'a> Vm<'a> {
             }
             Jump => {
                 let jump_len = self.chunk.bytecode[self.ip + 1];
-                self.ip += jump_len as usize;
+                self.ip += jump_len as usize + 2;
+                self.interpret()
+            }
+            JumpBack => {
+                let jump_len = self.chunk.bytecode[self.ip + 1];
+                self.ip -= jump_len as usize;
                 self.interpret()
             }
             JumpIfFalse => {
@@ -123,6 +132,21 @@ impl<'a> Vm<'a> {
                     }
                 }
             }
+            JumpIfZero => {
+                let jump_len = self.chunk.bytecode[self.ip + 1];
+                let cond = self.pop();
+                match cond {
+                    Value::Number(0.0) => {
+                        self.ip += jump_len as usize + 2;
+                        self.interpret()
+                    }
+                    Value::Number(..) => {
+                        self.ip += 2;
+                        self.interpret()
+                    }
+                    _ => Err(Panic("repeat requires a number")),
+                }
+            }
             Pop => {
                 self.pop();
                 self.ip += 1;
@@ -258,6 +282,38 @@ impl<'a> Vm<'a> {
                 }
                 self.interpret()
             }
+            TypeOf => {
+                let val = self.pop();
+                let type_of = self.chunk.kw_from(val.type_of()).unwrap();
+                self.push(type_of);
+                self.ip += 1;
+                self.interpret()
+            }
+            Truncate => {
+                let val = self.pop();
+                if let Value::Number(x) = val {
+                    self.push(Value::Number(x as usize as f64));
+                    self.ip += 1;
+                    self.interpret()
+                } else {
+                    Err(Panic("repeat requires a number"))
+                }
+            }
+            Decrement => {
+                let val = self.pop();
+                if let Value::Number(x) = val {
+                    self.push(Value::Number(x - 1.0));
+                    self.ip += 1;
+                    self.interpret()
+                } else {
+                    Err(Panic("you may only decrement a number"))
+                }
+            }
+            Duplicate => {
+                self.push(self.peek().clone());
+                self.ip += 1;
+                self.interpret()
+            }
             PanicNoWhen | PanicNoMatch => Err(Panic("no match")),
         }
     }