some simple bytecodes!

Cargo.toml

@@ -12,3 +12,8 @@ imbl = "3.0.0"
 struct_scalpel = "0.1.1"
 ran = "2.0.1"
 rust-embed = "8.5.0"
+boxing = "0.1.2"
+ordered-float = "4.5.0"
+index_vec = "0.1.4"
+num-derive = "0.4.2"
+num-traits = "0.2.19"

src/compiler.rs

@@ -0,0 +1,96 @@
+use crate::parser::Ast;
+use crate::spans::Spanned;
+use crate::value::*;
+use chumsky::prelude::SimpleSpan;
+use num_derive::{FromPrimitive, ToPrimitive};
+use num_traits::FromPrimitive;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+enum Op {
+    Return,
+    Constant,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+struct Chunk<'a> {
+    pub constants: Vec<Value<'a>>,
+    pub bytecode: Vec<u8>,
+    pub spans: Vec<SimpleSpan>,
+    pub strings: Vec<&'static str>,
+    pub keywords: Vec<&'static str>,
+    pub nodes: Vec<&'a Ast>,
+    pub ast: &'a Ast,
+    pub span: SimpleSpan,
+    pub src: &'static str,
+    pub name: &'static str,
+}
+
+impl<'a> Chunk<'a> {
+    fn visit(&mut self, node: &'a Spanned<Ast>) {
+        let root_node = self.ast;
+        let root_span = self.span;
+        let (ast, span) = node;
+        self.ast = ast;
+        self.span = *span;
+        self.compile();
+        self.ast = root_node;
+        self.span = root_span;
+    }
+
+    fn emit_constant(&mut self, val: Value<'a>) {
+        let constant_index = self.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.bytecode.push(Op::Constant as u8);
+        self.spans.push(self.span);
+        self.bytecode.push(constant_index as u8);
+        self.spans.push(self.span);
+    }
+
+    fn emit_op(&mut self, op: Op) {
+        self.bytecode.push(op as u8);
+        self.spans.push(self.span);
+    }
+
+    fn compile(&mut self) {
+        match self.ast {
+            Ast::Nil => self.emit_constant(Value::Nil),
+            Ast::Number(n) => self.emit_constant(Value::Number(*n)),
+            Ast::Boolean(b) => self.emit_constant(Value::Boolean(*b)),
+            Ast::String(s) => {
+                let str_index = self.strings.len();
+                self.strings.push(s);
+                self.emit_constant(Value::InternedString(s));
+            }
+            Ast::Block(lines) => {
+                for expr in lines {
+                    self.visit(expr);
+                }
+                self.emit_op(Op::Return);
+            }
+            _ => todo!(),
+        }
+    }
+
+    fn disassemble(&self) {
+        println!("=== chunk: {} ===", self.name);
+        let mut codes = self.bytecode.iter().enumerate();
+        while let Some((i, byte)) = codes.next() {
+            let op = Op::from_u8(*byte);
+            match op {
+                Some(Op::Return) => println!("{i:04}: {byte:16}"),
+                Some(Op::Constant) => {
+                    let (_, next) = codes.next().unwrap();
+                    let value = &self.constants[*next as usize];
+                    println!("i:04: {byte:16} {next:16} {value}")
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+}

src/memory_sandbox.rs

@@ -0,0 +1,58 @@
+use imbl::{HashMap, Vector};
+use index_vec::Idx;
+use std::cell::RefCell;
+use std::ops::Range;
+use std::rc::Rc;
+
+struct Word(&'static str);
+
+struct Keyword(&'static str);
+
+struct Interned(&'static str);
+
+enum StringPart {
+    Word(&'static str),
+    Data(&'static str),
+    Inline(&'static str),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+struct LBox {
+    name: usize,
+    cell: RefCell<Value>,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+struct Fn {
+    name: &'static str,
+    body: Vec<String>,
+    //...etc
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum Value {
+    Nil,
+    Placeholder,
+    Boolean(bool),
+    Keyword(usize),
+    Interned(usize),
+    FnDecl(usize),
+    String(Rc<String>),
+    Number(f64),
+    Tuple(Rc<Vec<Value>>),
+    List(Box<Vector<Value>>),
+    Dict(Box<HashMap<&'static str, Value>>),
+    Box(Rc<LBox>),
+    Fn(Rc<RefCell<Fn>>),
+}
+
+fn futz() {
+    let foo: &'static str = "foo";
+    let baz: Vec<u8> = vec![];
+    let bar: Range<usize> = 1..3;
+    let quux: Vector<u8> = Vector::new();
+    let fuzz = Rc::new(quux);
+    let blah = Box::new(foo);
+    let val = Value::Number(12.09);
+    let foo: f64 = 12.0;
+}

src/old_main.rs

@@ -62,6 +62,10 @@ use crate::process::*;
 mod errors;
 use crate::errors::*;
 
+mod byte_values;
+mod compiler;
+mod memory_sandbox;
+
 #[derive(Embed)]
 #[folder = "assets/"]
 struct Asset;

src/old_value.rs

@@ -0,0 +1,193 @@
+use crate::base::*;
+use crate::parser::*;
+use crate::spans::*;
+use imbl::*;
+use std::cell::RefCell;
+use std::fmt;
+use std::rc::Rc;
+use struct_scalpel::Dissectible;
+
+#[derive(Clone, Debug)]
+pub struct Fn<'src> {
+    pub name: String,
+    pub body: &'src Vec<Spanned<Ast>>,
+    pub doc: Option<String>,
+    pub enclosing: Vec<(String, Value<'src>)>,
+    pub has_run: bool,
+    pub input: &'static str,
+    pub src: &'static str,
+}
+
+#[derive(Debug, Dissectible)]
+pub enum Value<'src> {
+    Nil,
+    Placeholder,
+    Boolean(bool),
+    Number(f64),
+    Keyword(&'static str),
+    InternedString(&'static str),
+    AllocatedString(Rc<String>),
+    // on the heap for now
+    Tuple(Rc<Vec<Self>>),
+    Args(Rc<Vec<Self>>),
+    List(Vector<Self>),
+    Dict(HashMap<&'static str, Self>),
+    Box(&'static str, Rc<RefCell<Self>>),
+    Fn(Rc<RefCell<Fn<'src>>>),
+    FnDecl(&'static str),
+    Base(BaseFn<'src>),
+    Recur(Vec<Self>),
+    // Set(HashSet<Self>),
+    // Sets are hard
+    // Sets require Eq
+    // Eq is not implemented on f64, because NaNs
+    // We could use ordered_float::NotNan
+    // Let's defer that
+    // We're not really using sets in Ludus
+
+    // Other things we're not implementing yet:
+    // pkgs, nses, tests
+}
+
+impl<'src> Clone for Value<'src> {
+    fn clone(&self) -> Value<'src> {
+        match self {
+            Value::Nil => Value::Nil,
+            Value::Boolean(b) => Value::Boolean(*b),
+            Value::InternedString(s) => Value::InternedString(s),
+            Value::AllocatedString(s) => Value::AllocatedString(s.clone()),
+            Value::Keyword(s) => Value::Keyword(s),
+            Value::Number(n) => Value::Number(*n),
+            Value::Tuple(t) => Value::Tuple(t.clone()),
+            Value::Args(a) => Value::Args(a.clone()),
+            Value::Fn(f) => Value::Fn(f.clone()),
+            Value::FnDecl(name) => Value::FnDecl(name),
+            Value::List(l) => Value::List(l.clone()),
+            Value::Dict(d) => Value::Dict(d.clone()),
+            Value::Box(name, b) => Value::Box(name, b.clone()),
+            Value::Placeholder => Value::Placeholder,
+            Value::Base(b) => Value::Base(b.clone()),
+            Value::Recur(..) => unreachable!(),
+        }
+    }
+}
+
+impl fmt::Display for Value<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Value::Nil => write!(f, "nil"),
+            Value::Boolean(b) => write!(f, "{b}"),
+            Value::Number(n) => write!(f, "{n}"),
+            Value::Keyword(k) => write!(f, ":{k}"),
+            Value::InternedString(s) => write!(f, "\"{s}\""),
+            Value::AllocatedString(s) => write!(f, "\"{s}\""),
+            Value::Fn(fun) => write!(f, "fn {}", fun.borrow().name),
+            Value::FnDecl(name) => write!(f, "fn {name}"),
+            Value::Tuple(t) | Value::Args(t) => write!(
+                f,
+                "({})",
+                t.iter()
+                    .map(|x| x.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Value::List(l) => write!(
+                f,
+                "[{}]",
+                l.iter()
+                    .map(|x| x.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Value::Dict(d) => write!(
+                f,
+                "#{{{}}}",
+                d.iter()
+                    .map(|(k, v)| format!(":{k} {v}"))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Value::Box(name, value) => {
+                write!(
+                    f,
+                    "box {}: [{}]",
+                    name,
+                    &value.try_borrow().unwrap().to_string()
+                )
+            }
+            Value::Placeholder => write!(f, "_"),
+            Value::Base(..) => unreachable!(),
+            Value::Recur(..) => unreachable!(),
+        }
+    }
+}
+
+impl Value<'_> {
+    pub fn bool(&self) -> bool {
+        !matches!(self, Value::Nil | Value::Boolean(false))
+    }
+}
+
+impl<'src> PartialEq for Value<'src> {
+    fn eq(&self, other: &Value<'src>) -> bool {
+        match (self, other) {
+            // value equality types
+            (Value::Nil, Value::Nil) => true,
+            (Value::Boolean(x), Value::Boolean(y)) => x == y,
+            (Value::Number(x), Value::Number(y)) => x == y,
+            (Value::InternedString(x), Value::InternedString(y)) => x == y,
+            (Value::AllocatedString(x), Value::AllocatedString(y)) => x == y,
+            (Value::InternedString(x), Value::AllocatedString(y)) => *x == **y,
+            (Value::AllocatedString(x), Value::InternedString(y)) => **x == *y,
+            (Value::Keyword(x), Value::Keyword(y)) => x == y,
+            (Value::Tuple(x), Value::Tuple(y)) => x == y,
+            (Value::List(x), Value::List(y)) => x == y,
+            (Value::Dict(x), Value::Dict(y)) => x == y,
+            // reference equality types
+            (Value::Fn(x), Value::Fn(y)) => {
+                Rc::<RefCell<Fn<'_>>>::as_ptr(x) == Rc::<RefCell<Fn<'_>>>::as_ptr(y)
+            }
+            (Value::Box(_, x), Value::Box(_, y)) => {
+                Rc::<RefCell<Value<'_>>>::as_ptr(x) == Rc::<RefCell<Value<'_>>>::as_ptr(y)
+            }
+            _ => false,
+        }
+    }
+}
+
+impl Eq for Value<'_> {}
+
+impl Value<'_> {
+    pub fn interpolate(&self) -> String {
+        match self {
+            Value::Nil => String::new(),
+            Value::Boolean(b) => format!("{b}"),
+            Value::Number(n) => format!("{n}"),
+            Value::Keyword(k) => format!(":{k}"),
+            Value::AllocatedString(s) => format!("{s}"),
+            Value::InternedString(s) => s.to_string(),
+            Value::Box(_, x) => x.borrow().interpolate(),
+            Value::Tuple(xs) => xs
+                .iter()
+                .map(|x| x.interpolate())
+                .collect::<Vec<_>>()
+                .join(", "),
+            Value::List(xs) => xs
+                .iter()
+                .map(|x| x.interpolate())
+                .collect::<Vec<_>>()
+                .join(", "),
+            Value::Dict(xs) => xs
+                .iter()
+                .map(|(k, v)| format!(":{} {}", k, v.interpolate()))
+                .collect::<Vec<_>>()
+                .join(", "),
+            Value::Fn(x) => format!("fn {}", x.borrow().name),
+            Value::FnDecl(name) => format!("fn {name}"),
+            Value::Placeholder => unreachable!(),
+            Value::Args(_) => unreachable!(),
+            Value::Recur(_) => unreachable!(),
+            Value::Base(_) => unreachable!(),
+        }
+    }
+}

src/value.rs

@@ -1,193 +1,47 @@
-use crate::base::*;
+use crate::compiler::Chunk;
-use crate::parser::*;
+use crate::parser::Ast;
-use crate::spans::*;
+use crate::spans::Spanned;
-use imbl::*;
+use imbl::{HashMap, Vector};
 use std::cell::RefCell;
-use std::fmt;
 use std::rc::Rc;
-use struct_scalpel::Dissectible;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
-pub struct Fn<'src> {
+pub struct LBox {
-    pub name: String,
+    pub name: usize,
-    pub body: &'src Vec<Spanned<Ast>>,
+    pub cell: RefCell<Value>,
-    pub doc: Option<String>,
+}
-    pub enclosing: Vec<(String, Value<'src>)>,
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct LFn {
+    pub name: &'static str,
+    pub body: Vec<Spanned<Ast>>,
+    pub doc: Option<&'static str>,
+    pub enclosing: Vec<(usize, Value)>,
     pub has_run: bool,
     pub input: &'static str,
     pub src: &'static str,
 }
 
-#[derive(Debug, Dissectible)]
+#[derive(Clone, Debug, PartialEq)]
-pub enum Value<'src> {
+pub enum Value {
     Nil,
-    Placeholder,
     Boolean(bool),
+    Keyword(usize), // use an idx, rather than a raw index
+    Interned(usize),
+    FnDecl(usize),
+    String(Rc<String>),
     Number(f64),
-    Keyword(&'static str),
+    List(Box<Vector<Value>>),
-    InternedString(&'static str),
+    Dict(Box<HashMap<&'static str, Value>>),
-    AllocatedString(Rc<String>),
+    Box(Rc<LBox>),
-    // on the heap for now
+    Fn(Rc<RefCell<LFn>>),
-    Tuple(Rc<Vec<Self>>),
-    Args(Rc<Vec<Self>>),
-    List(Vector<Self>),
-    Dict(HashMap<&'static str, Self>),
-    Box(&'static str, Rc<RefCell<Self>>),
-    Fn(Rc<RefCell<Fn<'src>>>),
-    FnDecl(&'static str),
-    Base(BaseFn<'src>),
-    Recur(Vec<Self>),
-    // Set(HashSet<Self>),
-    // Sets are hard
-    // Sets require Eq
-    // Eq is not implemented on f64, because NaNs
-    // We could use ordered_float::NotNan
-    // Let's defer that
-    // We're not really using sets in Ludus
-
-    // Other things we're not implementing yet:
-    // pkgs, nses, tests
 }
 
-impl<'src> Clone for Value<'src> {
+impl Value {
-    fn clone(&self) -> Value<'src> {
+    fn show(&self, ctx: &Chunk) -> String {
-        match self {
+        use Value::*;
-            Value::Nil => Value::Nil,
+        match &self {
-            Value::Boolean(b) => Value::Boolean(*b),
+            Nil => format!("nil"),
-            Value::InternedString(s) => Value::InternedString(s),
-            Value::AllocatedString(s) => Value::AllocatedString(s.clone()),
-            Value::Keyword(s) => Value::Keyword(s),
-            Value::Number(n) => Value::Number(*n),
-            Value::Tuple(t) => Value::Tuple(t.clone()),
-            Value::Args(a) => Value::Args(a.clone()),
-            Value::Fn(f) => Value::Fn(f.clone()),
-            Value::FnDecl(name) => Value::FnDecl(name),
-            Value::List(l) => Value::List(l.clone()),
-            Value::Dict(d) => Value::Dict(d.clone()),
-            Value::Box(name, b) => Value::Box(name, b.clone()),
-            Value::Placeholder => Value::Placeholder,
-            Value::Base(b) => Value::Base(b.clone()),
-            Value::Recur(..) => unreachable!(),
-        }
-    }
-}
-
-impl fmt::Display for Value<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Value::Nil => write!(f, "nil"),
-            Value::Boolean(b) => write!(f, "{b}"),
-            Value::Number(n) => write!(f, "{n}"),
-            Value::Keyword(k) => write!(f, ":{k}"),
-            Value::InternedString(s) => write!(f, "\"{s}\""),
-            Value::AllocatedString(s) => write!(f, "\"{s}\""),
-            Value::Fn(fun) => write!(f, "fn {}", fun.borrow().name),
-            Value::FnDecl(name) => write!(f, "fn {name}"),
-            Value::Tuple(t) | Value::Args(t) => write!(
-                f,
-                "({})",
-                t.iter()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            ),
-            Value::List(l) => write!(
-                f,
-                "[{}]",
-                l.iter()
-                    .map(|x| x.to_string())
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            ),
-            Value::Dict(d) => write!(
-                f,
-                "#{{{}}}",
-                d.iter()
-                    .map(|(k, v)| format!(":{k} {v}"))
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            ),
-            Value::Box(name, value) => {
-                write!(
-                    f,
-                    "box {}: [{}]",
-                    name,
-                    &value.try_borrow().unwrap().to_string()
-                )
-            }
-            Value::Placeholder => write!(f, "_"),
-            Value::Base(..) => unreachable!(),
-            Value::Recur(..) => unreachable!(),
-        }
-    }
-}
-
-impl Value<'_> {
-    pub fn bool(&self) -> bool {
-        !matches!(self, Value::Nil | Value::Boolean(false))
-    }
-}
-
-impl<'src> PartialEq for Value<'src> {
-    fn eq(&self, other: &Value<'src>) -> bool {
-        match (self, other) {
-            // value equality types
-            (Value::Nil, Value::Nil) => true,
-            (Value::Boolean(x), Value::Boolean(y)) => x == y,
-            (Value::Number(x), Value::Number(y)) => x == y,
-            (Value::InternedString(x), Value::InternedString(y)) => x == y,
-            (Value::AllocatedString(x), Value::AllocatedString(y)) => x == y,
-            (Value::InternedString(x), Value::AllocatedString(y)) => *x == **y,
-            (Value::AllocatedString(x), Value::InternedString(y)) => **x == *y,
-            (Value::Keyword(x), Value::Keyword(y)) => x == y,
-            (Value::Tuple(x), Value::Tuple(y)) => x == y,
-            (Value::List(x), Value::List(y)) => x == y,
-            (Value::Dict(x), Value::Dict(y)) => x == y,
-            // reference equality types
-            (Value::Fn(x), Value::Fn(y)) => {
-                Rc::<RefCell<Fn<'_>>>::as_ptr(x) == Rc::<RefCell<Fn<'_>>>::as_ptr(y)
-            }
-            (Value::Box(_, x), Value::Box(_, y)) => {
-                Rc::<RefCell<Value<'_>>>::as_ptr(x) == Rc::<RefCell<Value<'_>>>::as_ptr(y)
-            }
-            _ => false,
-        }
-    }
-}
-
-impl Eq for Value<'_> {}
-
-impl Value<'_> {
-    pub fn interpolate(&self) -> String {
-        match self {
-            Value::Nil => String::new(),
-            Value::Boolean(b) => format!("{b}"),
-            Value::Number(n) => format!("{n}"),
-            Value::Keyword(k) => format!(":{k}"),
-            Value::AllocatedString(s) => format!("{s}"),
-            Value::InternedString(s) => s.to_string(),
-            Value::Box(_, x) => x.borrow().interpolate(),
-            Value::Tuple(xs) => xs
-                .iter()
-                .map(|x| x.interpolate())
-                .collect::<Vec<_>>()
-                .join(", "),
-            Value::List(xs) => xs
-                .iter()
-                .map(|x| x.interpolate())
-                .collect::<Vec<_>>()
-                .join(", "),
-            Value::Dict(xs) => xs
-                .iter()
-                .map(|(k, v)| format!(":{} {}", k, v.interpolate()))
-                .collect::<Vec<_>>()
-                .join(", "),
-            Value::Fn(x) => format!("fn {}", x.borrow().name),
-            Value::FnDecl(name) => format!("fn {name}"),
-            Value::Placeholder => unreachable!(),
-            Value::Args(_) => unreachable!(),
-            Value::Recur(_) => unreachable!(),
-            Value::Base(_) => unreachable!(),
         }
     }
 }