conlang: Move all cl-libs into the compiler directory

compiler/cl-interpret/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "cl-interpret"
+repository.workspace = true
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]
+cl-ast = { path = "../cl-ast" }
+cl-structures = { path = "../cl-structures" }
+
+
+[dev-dependencies]
+cl-lexer = { path = "../cl-lexer" }
+cl-parser = { path = "../cl-parser" }

compiler/cl-interpret/examples/fib.rs

@@ -0,0 +1,16 @@
+// Calculate Fibonacci numbers
+
+fn main() {
+    for num in 0..=30 {
+        println!("fib({num}) = {}", fib(num))
+    }
+}
+
+/// Implements the classic recursive definition of fib()
+fn fib(a: i64) -> i64 {
+    if a > 1 {
+        fib(a - 1) + fib(a - 2)
+    } else {
+        1
+    }
+}

compiler/cl-interpret/src/builtin.rs

@@ -0,0 +1,239 @@
+//! Implementations of built-in functions
+
+use super::{
+    env::Environment,
+    error::{Error, IResult},
+    temp_type_impl::ConValue,
+    BuiltIn, Callable,
+};
+use std::io::{stdout, Write};
+
+builtins! {
+    const MISC;
+    /// Unstable variadic print function
+    pub fn print<_, args> () -> IResult<ConValue> {
+        let mut out = stdout().lock();
+        for arg in args {
+            write!(out, "{arg}").ok();
+        }
+        writeln!(out).ok();
+        Ok(ConValue::Empty)
+    }
+    /// Prints the [Debug](std::fmt::Debug) version of the input values
+    pub fn dbg<_, args> () -> IResult<ConValue> {
+        let mut out = stdout().lock();
+        for arg in args {
+            writeln!(out, "{arg:?}").ok();
+        }
+        Ok(args.into())
+    }
+    /// Dumps info from the environment
+    pub fn dump<env, _>() -> IResult<ConValue> {
+        println!("{}", *env);
+        Ok(ConValue::Empty)
+    }
+}
+builtins! {
+    const BINARY;
+    /// Multiplication `a * b`
+    pub fn mul(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a * b),
+            _ => Err(Error::TypeError)?
+        })
+    }
+    /// Division `a / b`
+    pub fn div(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs){
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a / b),
+            _ => Err(Error::TypeError)?
+        })
+    }
+    /// Remainder `a % b`
+    pub fn rem(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a % b),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+
+    /// Addition `a + b`
+    pub fn add(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a + b),
+            (ConValue::String(a), ConValue::String(b)) => ConValue::String(a.to_string() + b),
+            _ => Err(Error::TypeError)?
+        })
+    }
+    /// Subtraction `a - b`
+    pub fn sub(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a - b),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+
+    /// Shift Left `a << b`
+    pub fn shl(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a << b),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+    /// Shift Right `a >> b`
+    pub fn shr(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a >> b),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+
+    /// Bitwise And `a & b`
+    pub fn and(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a & b),
+            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a & b),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+    /// Bitwise Or `a | b`
+    pub fn or(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a | b),
+            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a | b),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+    /// Bitwise Exclusive Or `a ^ b`
+    pub fn xor(lhs, rhs) -> IResult<ConValue> {
+        Ok(match (lhs, rhs) {
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a ^ b),
+            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a ^ b),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+
+    /// Tests whether `a < b`
+    pub fn lt(lhs, rhs) -> IResult<ConValue> {
+        cmp!(lhs, rhs, false, <)
+    }
+    /// Tests whether `a <= b`
+    pub fn lt_eq(lhs, rhs) -> IResult<ConValue> {
+        cmp!(lhs, rhs, true, <=)
+    }
+    /// Tests whether `a == b`
+    pub fn eq(lhs, rhs) -> IResult<ConValue> {
+        cmp!(lhs, rhs, true, ==)
+    }
+    /// Tests whether `a != b`
+    pub fn neq(lhs, rhs) -> IResult<ConValue> {
+        cmp!(lhs, rhs, false, !=)
+    }
+    /// Tests whether `a <= b`
+    pub fn gt_eq(lhs, rhs) -> IResult<ConValue> {
+        cmp!(lhs, rhs, true, >=)
+    }
+    /// Tests whether `a < b`
+    pub fn gt(lhs, rhs) -> IResult<ConValue> {
+        cmp!(lhs, rhs, false, >)
+    }
+}
+builtins! {
+    const RANGE;
+    /// Exclusive Range `a..b`
+    pub fn range_exc(lhs, rhs) -> IResult<ConValue> {
+        let (&ConValue::Int(lhs), &ConValue::Int(rhs)) = (lhs, rhs) else {
+            Err(Error::TypeError)?
+        };
+        Ok(ConValue::RangeExc(lhs, rhs.saturating_sub(1)))
+    }
+    /// Inclusive Range `a..=b`
+    pub fn range_inc(lhs, rhs) -> IResult<ConValue> {
+        let (&ConValue::Int(lhs), &ConValue::Int(rhs)) = (lhs, rhs) else {
+            Err(Error::TypeError)?
+        };
+        Ok(ConValue::RangeInc(lhs, rhs))
+    }
+}
+builtins! {
+    const UNARY;
+    /// Negates the ConValue
+    pub fn neg(tail) -> IResult<ConValue> {
+        Ok(match tail {
+            ConValue::Empty => ConValue::Empty,
+            ConValue::Int(v) => ConValue::Int(-v),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+    /// Inverts the ConValue
+    pub fn not(tail) -> IResult<ConValue> {
+        Ok(match tail {
+            ConValue::Empty => ConValue::Empty,
+            ConValue::Int(v) => ConValue::Int(!v),
+            ConValue::Bool(v) => ConValue::Bool(!v),
+            _ => Err(Error::TypeError)?,
+        })
+    }
+}
+
+/// Turns an argument slice into an array with the (inferred) correct number of elements
+pub fn to_args<const N: usize>(args: &[ConValue]) -> IResult<&[ConValue; N]> {
+    args.try_into()
+        .map_err(|_| Error::ArgNumber { want: N, got: args.len() })
+}
+
+/// Turns function definitions into ZSTs which implement [Callable] and [BuiltIn]
+macro builtins (
+    $(prefix = $prefix:literal)?
+    const $defaults:ident $( = [$($additional_builtins:expr),*$(,)?])?;
+    $(
+        $(#[$meta:meta])*$vis:vis fn $name:ident$(<$env:tt, $args:tt>)? ( $($($arg:tt),+$(,)?)? ) $(-> $rety:ty)?
+            $body:block
+    )*
+) {
+    /// Builtins to load when a new interpreter is created
+    pub const $defaults: &[&dyn BuiltIn] = &[$(&$name,)* $($additional_builtins)*];
+    $(
+        $(#[$meta])* #[allow(non_camel_case_types)] #[derive(Clone, Debug)]
+        /// ```rust,ignore
+        #[doc = stringify!(builtin! fn $name($($($arg),*)?) $(-> $rety)? $body)]
+        /// ```
+        $vis struct $name;
+        impl BuiltIn for $name {
+            fn description(&self) -> &str { concat!("builtin ", stringify!($name), stringify!(($($($arg),*)?) )) }
+        }
+        impl Callable for $name {
+            #[allow(unused)]
+            fn call(&self, env: &mut Environment, args: &[ConValue]) $(-> $rety)? {
+                // println!("{}", stringify!($name), );
+                $(let $env = env;
+                let $args = args;)?
+                $(let [$($arg),*] = to_args(args)?;)?
+                $body
+            }
+            fn name(&self) -> &str { stringify!($name) }
+        }
+    )*
+}
+
+/// Templates comparison functions for [ConValue]
+macro cmp ($a:expr, $b:expr, $empty:literal, $op:tt) {
+    match ($a, $b) {
+        (ConValue::Empty, ConValue::Empty) => Ok(ConValue::Bool($empty)),
+        (ConValue::Int(a), ConValue::Int(b)) => Ok(ConValue::Bool(a $op b)),
+        (ConValue::Bool(a), ConValue::Bool(b)) => Ok(ConValue::Bool(a $op b)),
+        (ConValue::Char(a), ConValue::Char(b)) => Ok(ConValue::Bool(a $op b)),
+        (ConValue::String(a), ConValue::String(b)) => Ok(ConValue::Bool(a $op b)),
+        _ => Err(Error::TypeError)
+    }
+}

compiler/cl-interpret/src/interpret.rs

@@ -0,0 +1,464 @@
+//! A work-in-progress tree walk interpreter for Conlang
+//!
+//! Currently, major parts of the interpreter are not yet implemented, and major parts will never be
+//! implemented in its current form. Namely, since no [ConValue] has a stable location, it's
+//! meaningless to get a pointer to one, and would be undefined behavior to dereference a pointer to
+//! one in any situation.
+
+use std::borrow::Borrow;
+
+use super::*;
+use cl_ast::*;
+/// A work-in-progress tree walk interpreter for Conlang
+pub trait Interpret {
+    /// Interprets this thing in the given [`Environment`].
+    ///
+    /// Everything returns a value!™
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue>;
+}
+
+impl Interpret for File {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        for item in &self.items {
+            item.interpret(env)?;
+        }
+        Ok(ConValue::Empty)
+    }
+}
+impl Interpret for Item {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        match &self.kind {
+            ItemKind::Alias(item) => item.interpret(env),
+            ItemKind::Const(item) => item.interpret(env),
+            ItemKind::Static(item) => item.interpret(env),
+            ItemKind::Module(item) => item.interpret(env),
+            ItemKind::Function(item) => item.interpret(env),
+            ItemKind::Struct(item) => item.interpret(env),
+            ItemKind::Enum(item) => item.interpret(env),
+            ItemKind::Impl(item) => item.interpret(env),
+        }
+    }
+}
+impl Interpret for Alias {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        todo!("Interpret type alias in {env}")
+    }
+}
+impl Interpret for Const {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        todo!("interpret const in {env}")
+    }
+}
+impl Interpret for Static {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        todo!("interpret static in {env}")
+    }
+}
+impl Interpret for Module {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        // TODO: Enter this module's namespace
+        match &self.kind {
+            ModuleKind::Inline(file) => file.interpret(env),
+            ModuleKind::Outline => todo!("Load and parse external files"),
+        }
+    }
+}
+impl Interpret for Function {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        // register the function in the current environment
+        env.insert_fn(self);
+        Ok(ConValue::Empty)
+    }
+}
+impl Interpret for Struct {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        todo!("Interpret structs in {env}")
+    }
+}
+impl Interpret for Enum {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        todo!("Interpret enums in {env}")
+    }
+}
+impl Interpret for Impl {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        todo!("Enter a struct's namespace and insert function definitions into it in {env}");
+    }
+}
+impl Interpret for Stmt {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { extents: _, kind, semi } = self;
+        let out = match kind {
+            StmtKind::Empty => ConValue::Empty,
+            StmtKind::Local(stmt) => stmt.interpret(env)?,
+            StmtKind::Item(stmt) => stmt.interpret(env)?,
+            StmtKind::Expr(stmt) => stmt.interpret(env)?,
+        };
+        Ok(match semi {
+            Semi::Terminated => ConValue::Empty,
+            Semi::Unterminated => out,
+        })
+    }
+}
+impl Interpret for Let {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Let { mutable: _, name: Identifier(name), ty: _, init } = self;
+        let init = init.as_ref().map(|i| i.interpret(env)).transpose()?;
+        env.insert(name, init);
+        Ok(ConValue::Empty)
+    }
+}
+impl Interpret for Expr {
+    #[inline]
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { extents: _, kind } = self;
+        kind.interpret(env)
+    }
+}
+impl Interpret for ExprKind {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        match self {
+            ExprKind::Assign(v) => v.interpret(env),
+            ExprKind::Binary(v) => v.interpret(env),
+            ExprKind::Unary(v) => v.interpret(env),
+            ExprKind::Index(v) => v.interpret(env),
+            ExprKind::Path(v) => v.interpret(env),
+            ExprKind::Literal(v) => v.interpret(env),
+            ExprKind::Array(v) => v.interpret(env),
+            ExprKind::ArrayRep(v) => v.interpret(env),
+            ExprKind::AddrOf(v) => v.interpret(env),
+            ExprKind::Block(v) => v.interpret(env),
+            ExprKind::Empty => Ok(ConValue::Empty),
+            ExprKind::Group(v) => v.interpret(env),
+            ExprKind::Tuple(v) => v.interpret(env),
+            ExprKind::Loop(v) => v.interpret(env),
+            ExprKind::While(v) => v.interpret(env),
+            ExprKind::If(v) => v.interpret(env),
+            ExprKind::For(v) => v.interpret(env),
+            ExprKind::Break(v) => v.interpret(env),
+            ExprKind::Return(v) => v.interpret(env),
+            ExprKind::Continue(v) => v.interpret(env),
+        }
+    }
+}
+impl Interpret for Assign {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Assign { kind: op, parts } = self;
+        let (head, tail) = parts.borrow();
+        // Resolve the head pattern
+        let head = match &head {
+            ExprKind::Path(Path { parts, .. }) if parts.len() == 1 => {
+                match parts.last().expect("parts should not be empty") {
+                    PathPart::SuperKw => Err(Error::NotAssignable)?,
+                    PathPart::SelfKw => todo!("Assignment to `self`"),
+                    PathPart::Ident(Identifier(s)) => s,
+                }
+            }
+            ExprKind::Index(_) => todo!("Assignment to an index operation"),
+            ExprKind::Path(_) => todo!("Path expression resolution (IMPORTANT)"),
+            ExprKind::Empty | ExprKind::Group(_) | ExprKind::Tuple(_) => {
+                todo!("Pattern Destructuring?")
+            }
+            _ => Err(Error::NotAssignable)?,
+        };
+        // Get the initializer and the tail
+        let init = tail.interpret(env)?;
+        let target = env.get_mut(head)?;
+
+        if let AssignKind::Plain = op {
+            use std::mem::discriminant as variant;
+            // runtime typecheck
+            match target {
+                Some(value) if variant(value) == variant(&init) => {
+                    *value = init;
+                }
+                value @ None => *value = Some(init),
+                _ => Err(Error::TypeError)?,
+            }
+            return Ok(ConValue::Empty);
+        }
+        let Some(target) = target else {
+            return Err(Error::NotInitialized(head.into()));
+        };
+
+        match op {
+            AssignKind::Add => target.add_assign(init)?,
+            AssignKind::Sub => target.sub_assign(init)?,
+            AssignKind::Mul => target.mul_assign(init)?,
+            AssignKind::Div => target.div_assign(init)?,
+            AssignKind::Rem => target.rem_assign(init)?,
+            AssignKind::And => target.bitand_assign(init)?,
+            AssignKind::Or => target.bitor_assign(init)?,
+            AssignKind::Xor => target.bitxor_assign(init)?,
+            AssignKind::Shl => target.shl_assign(init)?,
+            AssignKind::Shr => target.shr_assign(init)?,
+            _ => (),
+        }
+        Ok(ConValue::Empty)
+    }
+}
+impl Interpret for Binary {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Binary { kind, parts } = self;
+        let (head, tail) = parts.borrow();
+
+        let head = head.interpret(env)?;
+
+        // Short-circuiting ops
+        match kind {
+            BinaryKind::LogAnd => {
+                return if head.truthy()? {
+                    tail.interpret(env)
+                } else {
+                    Ok(head)
+                }; // Short circuiting
+            }
+            BinaryKind::LogOr => {
+                return if !head.truthy()? {
+                    tail.interpret(env)
+                } else {
+                    Ok(head)
+                }; // Short circuiting
+            }
+            BinaryKind::LogXor => {
+                return Ok(ConValue::Bool(
+                    head.truthy()? ^ tail.interpret(env)?.truthy()?,
+                ));
+            }
+            _ => {}
+        }
+        let tail = tail.interpret(env)?;
+        match kind {
+            BinaryKind::Mul => env.call("mul", &[head, tail]),
+            BinaryKind::Div => env.call("div", &[head, tail]),
+            BinaryKind::Rem => env.call("rem", &[head, tail]),
+            BinaryKind::Add => env.call("add", &[head, tail]),
+            BinaryKind::Sub => env.call("sub", &[head, tail]),
+            BinaryKind::Shl => env.call("shl", &[head, tail]),
+            BinaryKind::Shr => env.call("shr", &[head, tail]),
+            BinaryKind::BitAnd => env.call("and", &[head, tail]),
+            BinaryKind::BitOr => env.call("or", &[head, tail]),
+            BinaryKind::BitXor => env.call("xor", &[head, tail]),
+            BinaryKind::RangeExc => env.call("range_exc", &[head, tail]),
+            BinaryKind::RangeInc => env.call("range_inc", &[head, tail]),
+            BinaryKind::Lt => env.call("lt", &[head, tail]),
+            BinaryKind::LtEq => env.call("lt_eq", &[head, tail]),
+            BinaryKind::Equal => env.call("eq", &[head, tail]),
+            BinaryKind::NotEq => env.call("neq", &[head, tail]),
+            BinaryKind::GtEq => env.call("gt_eq", &[head, tail]),
+            BinaryKind::Gt => env.call("gt", &[head, tail]),
+            BinaryKind::Dot => todo!("search within a type's namespace!"),
+            BinaryKind::Call => match tail {
+                ConValue::Empty => head.call(env, &[]),
+                ConValue::Tuple(args) => head.call(env, &args),
+                _ => Err(Error::TypeError),
+            },
+            _ => Ok(head),
+        }
+    }
+}
+
+impl Interpret for Unary {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Unary { kind, tail } = self;
+        let operand = tail.interpret(env)?;
+        match kind {
+            UnaryKind::Deref => env.call("deref", &[operand]),
+            UnaryKind::Neg => env.call("neg", &[operand]),
+            UnaryKind::Not => env.call("not", &[operand]),
+            UnaryKind::At => {
+                println!("{operand}");
+                Ok(operand)
+            }
+            UnaryKind::Tilde => unimplemented!("Tilde operator"),
+        }
+    }
+}
+impl Interpret for Index {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { head, indices } = self;
+        let mut head = head.interpret(env)?;
+        for index in indices {
+            head = head.index(&index.interpret(env)?)?;
+        }
+        Ok(head)
+    }
+}
+impl Interpret for Path {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { absolute: _, parts } = self;
+
+        if parts.len() == 1 {
+            match parts.last().expect("parts should not be empty") {
+                PathPart::SuperKw | PathPart::SelfKw => todo!("Path navigation"),
+                PathPart::Ident(Identifier(s)) => env.get(s).cloned(),
+            }
+        } else {
+            todo!("Path navigation!")
+        }
+    }
+}
+impl Interpret for Literal {
+    fn interpret(&self, _env: &mut Environment) -> IResult<ConValue> {
+        Ok(match self {
+            Literal::String(value) => ConValue::from(value.as_str()),
+            Literal::Char(value) => ConValue::Char(*value),
+            Literal::Bool(value) => ConValue::Bool(*value),
+            // Literal::Float(value) => todo!("Float values in interpreter: {value:?}"),
+            Literal::Int(value) => ConValue::Int(*value as _),
+        })
+    }
+}
+impl Interpret for Array {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { values } = self;
+        let mut out = vec![];
+        for expr in values {
+            out.push(expr.interpret(env)?)
+        }
+        Ok(ConValue::Array(out))
+    }
+}
+impl Interpret for ArrayRep {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { value, repeat } = self;
+        let repeat = match repeat.interpret(env)? {
+            ConValue::Int(v) => v,
+            _ => Err(Error::TypeError)?,
+        };
+        let value = value.interpret(env)?;
+        Ok(ConValue::Array(vec![value; repeat as usize]))
+    }
+}
+impl Interpret for AddrOf {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { count: _, mutable: _, expr } = self;
+        // this is stupid
+        todo!("Create reference\nfrom expr: {expr}\nin env:\n{env}\n")
+    }
+}
+impl Interpret for Block {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { stmts } = self;
+        let mut env = env.frame("block");
+        let mut out = ConValue::Empty;
+        for stmt in stmts {
+            out = stmt.interpret(&mut env)?;
+        }
+        Ok(out)
+    }
+}
+impl Interpret for Group {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { expr } = self;
+        expr.interpret(env)
+    }
+}
+impl Interpret for Tuple {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { exprs } = self;
+        Ok(ConValue::Tuple(exprs.iter().try_fold(
+            vec![],
+            |mut out, element| {
+                out.push(element.interpret(env)?);
+                Ok(out)
+            },
+        )?))
+    }
+}
+impl Interpret for Loop {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { body } = self;
+        loop {
+            match body.interpret(env) {
+                Err(Error::Break(value)) => return Ok(value),
+                Err(Error::Continue) => continue,
+                e => e?,
+            };
+        }
+    }
+}
+impl Interpret for While {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { cond, pass, fail } = self;
+        loop {
+            if cond.interpret(env)?.truthy()? {
+                match pass.interpret(env) {
+                    Err(Error::Break(value)) => return Ok(value),
+                    Err(Error::Continue) => continue,
+                    e => e?,
+                };
+            } else {
+                break fail.interpret(env);
+            }
+        }
+    }
+}
+impl Interpret for If {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { cond, pass, fail } = self;
+        if cond.interpret(env)?.truthy()? {
+            pass.interpret(env)
+        } else {
+            fail.interpret(env)
+        }
+    }
+}
+impl Interpret for For {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { bind: Identifier(name), cond, pass, fail } = self;
+        // TODO: A better iterator model
+        let mut bounds = match cond.interpret(env)? {
+            ConValue::RangeExc(a, b) => a..=b,
+            ConValue::RangeInc(a, b) => a..=b,
+            _ => Err(Error::TypeError)?,
+        };
+        loop {
+            let mut env = env.frame("loop variable");
+            if let Some(loop_var) = bounds.next() {
+                env.insert(name, Some(loop_var.into()));
+                match pass.interpret(&mut env) {
+                    Err(Error::Break(value)) => return Ok(value),
+                    Err(Error::Continue) => continue,
+                    result => result?,
+                };
+            } else {
+                break fail.interpret(&mut env);
+            }
+        }
+    }
+}
+impl Interpret for Else {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { body } = self;
+        match body {
+            Some(body) => body.interpret(env),
+            None => Ok(ConValue::Empty),
+        }
+    }
+}
+impl Interpret for Continue {
+    fn interpret(&self, _env: &mut Environment) -> IResult<ConValue> {
+        Err(Error::Continue)
+    }
+}
+impl Interpret for Return {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { body } = self;
+        Err(Error::Return(
+            body.as_ref()
+                .map(|body| body.interpret(env))
+                .unwrap_or(Ok(ConValue::Empty))?,
+        ))
+    }
+}
+impl Interpret for Break {
+    fn interpret(&self, env: &mut Environment) -> IResult<ConValue> {
+        let Self { body } = self;
+        Err(Error::Break(
+            body.as_ref()
+                .map(|body| body.interpret(env))
+                .unwrap_or(Ok(ConValue::Empty))?,
+        ))
+    }
+}

compiler/cl-interpret/src/lib.rs

@@ -0,0 +1,612 @@
+//! Walks a Conlang AST, interpreting it as a program.
+#![warn(clippy::all)]
+#![feature(decl_macro)]
+
+use env::Environment;
+use error::{Error, IResult};
+use interpret::Interpret;
+use temp_type_impl::ConValue;
+
+/// Callable types can be called from within a Conlang program
+pub trait Callable: std::fmt::Debug {
+    /// Calls this [Callable] in the provided [Environment], with [ConValue] args  \
+    /// The Callable is responsible for checking the argument count and validating types
+    fn call(&self, interpreter: &mut Environment, args: &[ConValue]) -> IResult<ConValue>;
+    /// Returns the common name of this identifier.
+    fn name(&self) -> &str;
+}
+
+/// [BuiltIn]s are [Callable]s with bespoke definitions
+pub trait BuiltIn: std::fmt::Debug + Callable {
+    fn description(&self) -> &str;
+}
+
+pub mod temp_type_impl {
+    //! Temporary implementations of Conlang values
+    //!
+    //! The most permanent fix is a temporary one.
+    use super::{
+        error::{Error, IResult},
+        function::Function,
+        BuiltIn, Callable, Environment,
+    };
+    use std::ops::*;
+
+    type Integer = isize;
+
+    /// A Conlang value
+    ///
+    /// This is a hack to work around the fact that Conlang doesn't
+    /// have a functioning type system yet :(
+    #[derive(Clone, Debug, Default)]
+    pub enum ConValue {
+        /// The empty/unit `()` type
+        #[default]
+        Empty,
+        /// An integer
+        Int(Integer),
+        /// A boolean
+        Bool(bool),
+        /// A unicode character
+        Char(char),
+        /// A string
+        String(String),
+        /// An Array
+        Array(Vec<ConValue>),
+        /// A tuple
+        Tuple(Vec<ConValue>),
+        /// An exclusive range
+        RangeExc(Integer, Integer),
+        /// An inclusive range
+        RangeInc(Integer, Integer),
+        /// A callable thing
+        Function(Function),
+        /// A built-in function
+        BuiltIn(&'static dyn BuiltIn),
+    }
+    impl ConValue {
+        /// Gets whether the current value is true or false
+        pub fn truthy(&self) -> IResult<bool> {
+            match self {
+                ConValue::Bool(v) => Ok(*v),
+                _ => Err(Error::TypeError)?,
+            }
+        }
+        pub fn range_exc(self, other: Self) -> IResult<Self> {
+            let (Self::Int(a), Self::Int(b)) = (self, other) else {
+                Err(Error::TypeError)?
+            };
+            Ok(Self::RangeExc(a, b.saturating_sub(1)))
+        }
+        pub fn range_inc(self, other: Self) -> IResult<Self> {
+            let (Self::Int(a), Self::Int(b)) = (self, other) else {
+                Err(Error::TypeError)?
+            };
+            Ok(Self::RangeInc(a, b))
+        }
+        pub fn index(&self, index: &Self) -> IResult<ConValue> {
+            let Self::Int(index) = index else {
+                Err(Error::TypeError)?
+            };
+            let Self::Array(arr) = self else {
+                Err(Error::TypeError)?
+            };
+            arr.get(*index as usize)
+                .cloned()
+                .ok_or(Error::OobIndex(*index as usize, arr.len()))
+        }
+        cmp! {
+            lt: false, <;
+            lt_eq: true, <=;
+            eq: true, ==;
+            neq: false, !=;
+            gt_eq: true, >=;
+            gt: false, >;
+        }
+        assign! {
+            add_assign: +;
+            bitand_assign: &;
+            bitor_assign: |;
+            bitxor_assign: ^;
+            div_assign: /;
+            mul_assign: *;
+            rem_assign: %;
+            shl_assign: <<;
+            shr_assign: >>;
+            sub_assign: -;
+        }
+    }
+
+    impl Callable for ConValue {
+        fn name(&self) -> &str {
+            match self {
+                ConValue::Function(func) => func.name(),
+                ConValue::BuiltIn(func) => func.name(),
+                _ => "",
+            }
+        }
+        fn call(&self, interpreter: &mut Environment, args: &[ConValue]) -> IResult<ConValue> {
+            match self {
+                Self::Function(func) => func.call(interpreter, args),
+                Self::BuiltIn(func) => func.call(interpreter, args),
+                _ => Err(Error::NotCallable(self.clone())),
+            }
+        }
+    }
+    /// Templates comparison functions for [ConValue]
+    macro cmp ($($fn:ident: $empty:literal, $op:tt);*$(;)?) {$(
+        /// TODO: Remove when functions are implemented:
+        ///       Desugar into function calls
+        pub fn $fn(&self, other: &Self) -> IResult<Self> {
+            match (self, other) {
+                (Self::Empty, Self::Empty) => Ok(Self::Bool($empty)),
+                (Self::Int(a), Self::Int(b)) => Ok(Self::Bool(a $op b)),
+                (Self::Bool(a), Self::Bool(b)) => Ok(Self::Bool(a $op b)),
+                (Self::Char(a), Self::Char(b)) => Ok(Self::Bool(a $op b)),
+                (Self::String(a), Self::String(b)) => Ok(Self::Bool(a $op b)),
+                _ => Err(Error::TypeError)
+            }
+        }
+    )*}
+    macro assign($( $fn: ident: $op: tt );*$(;)?) {$(
+        pub fn $fn(&mut self, other: Self) -> IResult<()> {
+            *self = (std::mem::take(self) $op other)?;
+            Ok(())
+        }
+    )*}
+    /// Implements [From] for an enum with 1-tuple variants
+    macro from ($($T:ty => $v:expr),*$(,)?) {
+        $(impl From<$T> for ConValue {
+            fn from(value: $T) -> Self { $v(value.into()) }
+        })*
+    }
+    from! {
+        Integer => ConValue::Int,
+        bool => ConValue::Bool,
+        char => ConValue::Char,
+        &str => ConValue::String,
+        String => ConValue::String,
+        Function => ConValue::Function,
+        Vec<ConValue> => ConValue::Tuple,
+        &'static dyn BuiltIn => ConValue::BuiltIn,
+    }
+    impl From<()> for ConValue {
+        fn from(_: ()) -> Self {
+            Self::Empty
+        }
+    }
+    impl From<&[ConValue]> for ConValue {
+        fn from(value: &[ConValue]) -> Self {
+            match value.len() {
+                0 => Self::Empty,
+                1 => value[0].clone(),
+                _ => Self::Tuple(value.into()),
+            }
+        }
+    }
+
+    /// Implements binary [std::ops] traits for [ConValue]
+    ///
+    /// TODO: Desugar operators into function calls
+    macro ops($($trait:ty: $fn:ident = [$($match:tt)*])*) {
+        $(impl $trait for ConValue {
+            type Output = IResult<Self>;
+            /// TODO: Desugar operators into function calls
+            fn $fn(self, rhs: Self) -> Self::Output {Ok(match (self, rhs) {$($match)*})}
+        })*
+    }
+    ops! {
+        Add: add = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a + b),
+            (ConValue::String(a), ConValue::String(b)) => ConValue::String(a + &b),
+            _ => Err(Error::TypeError)?
+            ]
+        BitAnd: bitand = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a & b),
+            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a & b),
+            _ => Err(Error::TypeError)?
+        ]
+        BitOr: bitor = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a | b),
+            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a | b),
+            _ => Err(Error::TypeError)?
+        ]
+        BitXor: bitxor = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a ^ b),
+            (ConValue::Bool(a), ConValue::Bool(b)) => ConValue::Bool(a ^ b),
+            _ => Err(Error::TypeError)?
+        ]
+        Div: div = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a / b),
+            _ => Err(Error::TypeError)?
+        ]
+        Mul: mul = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a * b),
+            _ => Err(Error::TypeError)?
+        ]
+        Rem: rem = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a % b),
+            _ => Err(Error::TypeError)?
+        ]
+        Shl: shl = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a << b),
+            _ => Err(Error::TypeError)?
+        ]
+        Shr: shr = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a >> b),
+            _ => Err(Error::TypeError)?
+        ]
+        Sub: sub = [
+            (ConValue::Empty, ConValue::Empty) => ConValue::Empty,
+            (ConValue::Int(a), ConValue::Int(b)) => ConValue::Int(a - b),
+            _ => Err(Error::TypeError)?
+        ]
+    }
+    impl std::fmt::Display for ConValue {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                ConValue::Empty => "Empty".fmt(f),
+                ConValue::Int(v) => v.fmt(f),
+                ConValue::Bool(v) => v.fmt(f),
+                ConValue::Char(v) => v.fmt(f),
+                ConValue::String(v) => v.fmt(f),
+                ConValue::Array(array) => {
+                    '['.fmt(f)?;
+                    for (idx, element) in array.iter().enumerate() {
+                        if idx > 0 {
+                            ", ".fmt(f)?
+                        }
+                        element.fmt(f)?
+                    }
+                    ']'.fmt(f)
+                }
+                ConValue::RangeExc(a, b) => write!(f, "{a}..{}", b + 1),
+                ConValue::RangeInc(a, b) => write!(f, "{a}..={b}"),
+                ConValue::Tuple(tuple) => {
+                    '('.fmt(f)?;
+                    for (idx, element) in tuple.iter().enumerate() {
+                        if idx > 0 {
+                            ", ".fmt(f)?
+                        }
+                        element.fmt(f)?
+                    }
+                    ')'.fmt(f)
+                }
+                ConValue::Function(func) => {
+                    write!(f, "{}", func.decl())
+                }
+                ConValue::BuiltIn(func) => {
+                    write!(f, "{}", func.description())
+                }
+            }
+        }
+    }
+}
+
+pub mod interpret;
+
+pub mod function {
+    //! Represents a block of code which lives inside the Interpreter
+    use super::{Callable, ConValue, Environment, Error, IResult, Interpret};
+    use cl_ast::{Function as FnDecl, Identifier, Param};
+    /// Represents a block of code which persists inside the Interpreter
+    #[derive(Clone, Debug)]
+    pub struct Function {
+        /// Stores the contents of the function declaration
+        decl: Box<FnDecl>,
+        // /// Stores the enclosing scope of the function
+        // env: Box<Environment>,
+    }
+
+    impl Function {
+        pub fn new(decl: &FnDecl) -> Self {
+            Self { decl: decl.clone().into() }
+        }
+        pub fn decl(&self) -> &FnDecl {
+            &self.decl
+        }
+    }
+
+    impl Callable for Function {
+        fn name(&self) -> &str {
+            let FnDecl { name: Identifier(ref name), .. } = *self.decl;
+            name
+        }
+        fn call(&self, env: &mut Environment, args: &[ConValue]) -> IResult<ConValue> {
+            let FnDecl { name: Identifier(name), bind: declargs, body, sign: _ } = &*self.decl;
+            // Check arg mapping
+            if args.len() != declargs.len() {
+                return Err(Error::ArgNumber { want: declargs.len(), got: args.len() });
+            }
+            let Some(body) = body else {
+                return Err(Error::NotDefined(name.into()));
+            };
+            // TODO: completely refactor data storage
+            let mut frame = env.frame("fn args");
+            for (Param { mutability: _, name: Identifier(name) }, value) in
+                declargs.iter().zip(args)
+            {
+                frame.insert(name, Some(value.clone()));
+            }
+            match body.interpret(&mut frame) {
+                Err(Error::Return(value)) => Ok(value),
+                Err(Error::Break(value)) => Err(Error::BadBreak(value)),
+                result => result,
+            }
+        }
+    }
+}
+
+pub mod builtin;
+
+pub mod env {
+    //! Lexical and non-lexical scoping for variables
+    use super::{
+        builtin::{BINARY, MISC, RANGE, UNARY},
+        error::{Error, IResult},
+        function::Function,
+        temp_type_impl::ConValue,
+        BuiltIn, Callable, Interpret,
+    };
+    use cl_ast::{Function as FnDecl, Identifier};
+    use std::{
+        collections::HashMap,
+        fmt::Display,
+        ops::{Deref, DerefMut},
+    };
+
+    /// Implements a nested lexical scope
+    #[derive(Clone, Debug)]
+    pub struct Environment {
+        frames: Vec<(HashMap<String, Option<ConValue>>, &'static str)>,
+    }
+
+    impl Display for Environment {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            for (frame, name) in self.frames.iter().rev() {
+                writeln!(f, "--- {name} ---")?;
+                for (var, val) in frame {
+                    write!(f, "{var}: ")?;
+                    match val {
+                        Some(value) => writeln!(f, "\t{value}"),
+                        None => writeln!(f, "<undefined>"),
+                    }?
+                }
+            }
+            Ok(())
+        }
+    }
+    impl Default for Environment {
+        fn default() -> Self {
+            Self {
+                frames: vec![
+                    (to_hashmap(RANGE), "range ops"),
+                    (to_hashmap(UNARY), "unary ops"),
+                    (to_hashmap(BINARY), "binary ops"),
+                    (to_hashmap(MISC), "builtins"),
+                    (HashMap::new(), "globals"),
+                ],
+            }
+        }
+    }
+    fn to_hashmap(from: &[&'static dyn BuiltIn]) -> HashMap<String, Option<ConValue>> {
+        from.iter()
+            .map(|&v| (v.name().into(), Some(v.into())))
+            .collect()
+    }
+
+    impl Environment {
+        pub fn new() -> Self {
+            Self::default()
+        }
+        /// Creates an [Environment] with no [builtins](super::builtin)
+        pub fn no_builtins(name: &'static str) -> Self {
+            Self { frames: vec![(Default::default(), name)] }
+        }
+
+        pub fn eval(&mut self, node: &impl Interpret) -> IResult<ConValue> {
+            node.interpret(self)
+        }
+
+        /// Calls a function inside the interpreter's scope,
+        /// and returns the result
+        pub fn call(&mut self, name: &str, args: &[ConValue]) -> IResult<ConValue> {
+            // FIXME: Clone to satisfy the borrow checker
+            let function = self.get(name)?.clone();
+            function.call(self, args)
+        }
+        /// Enters a nested scope, returning a [`Frame`] stack-guard.
+        ///
+        /// [`Frame`] implements Deref/DerefMut for [`Environment`].
+        pub fn frame(&mut self, name: &'static str) -> Frame {
+            Frame::new(self, name)
+        }
+        /// Resolves a variable mutably.
+        ///
+        /// Returns a mutable reference to the variable's record, if it exists.
+        pub fn get_mut(&mut self, id: &str) -> IResult<&mut Option<ConValue>> {
+            for (frame, _) in self.frames.iter_mut().rev() {
+                if let Some(var) = frame.get_mut(id) {
+                    return Ok(var);
+                }
+            }
+            Err(Error::NotDefined(id.into()))
+        }
+        /// Resolves a variable immutably.
+        ///
+        /// Returns a reference to the variable's contents, if it is defined and initialized.
+        pub fn get(&self, id: &str) -> IResult<&ConValue> {
+            for (frame, _) in self.frames.iter().rev() {
+                match frame.get(id) {
+                    Some(Some(var)) => return Ok(var),
+                    Some(None) => return Err(Error::NotInitialized(id.into())),
+                    _ => (),
+                }
+            }
+            Err(Error::NotDefined(id.into()))
+        }
+        /// Inserts a new [ConValue] into this [Environment]
+        pub fn insert(&mut self, id: &str, value: Option<ConValue>) {
+            if let Some((frame, _)) = self.frames.last_mut() {
+                frame.insert(id.into(), value);
+            }
+        }
+        /// A convenience function for registering a [FnDecl] as a [Function]
+        pub fn insert_fn(&mut self, decl: &FnDecl) {
+            let FnDecl { name: Identifier(name), .. } = decl;
+            let (name, function) = (name.clone(), Some(Function::new(decl).into()));
+            if let Some((frame, _)) = self.frames.last_mut() {
+                frame.insert(name, function);
+            }
+        }
+    }
+
+    /// Functions which aid in the implementation of [`Frame`]
+    impl Environment {
+        /// Enters a scope, creating a new namespace for variables
+        fn enter(&mut self, name: &'static str) -> &mut Self {
+            self.frames.push((Default::default(), name));
+            self
+        }
+
+        /// Exits the scope, destroying all local variables and
+        /// returning the outer scope, if there is one
+        fn exit(&mut self) -> &mut Self {
+            if self.frames.len() > 2 {
+                self.frames.pop();
+            }
+            self
+        }
+    }
+
+    /// Represents a stack frame
+    #[derive(Debug)]
+    pub struct Frame<'scope> {
+        scope: &'scope mut Environment,
+    }
+    impl<'scope> Frame<'scope> {
+        fn new(scope: &'scope mut Environment, name: &'static str) -> Self {
+            Self { scope: scope.enter(name) }
+        }
+    }
+    impl<'scope> Deref for Frame<'scope> {
+        type Target = Environment;
+        fn deref(&self) -> &Self::Target {
+            self.scope
+        }
+    }
+    impl<'scope> DerefMut for Frame<'scope> {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            self.scope
+        }
+    }
+    impl<'scope> Drop for Frame<'scope> {
+        fn drop(&mut self) {
+            self.scope.exit();
+        }
+    }
+}
+
+pub mod error {
+    //! The [Error] type represents any error thrown by the [Environment](super::Environment)
+
+    use super::temp_type_impl::ConValue;
+
+    pub type IResult<T> = Result<T, Error>;
+
+    /// Represents any error thrown by the [Environment](super::Environment)
+    #[derive(Clone, Debug)]
+    pub enum Error {
+        /// Propagate a Return value
+        Return(ConValue),
+        /// Propagate a Break value
+        Break(ConValue),
+        /// Break propagated across function bounds
+        BadBreak(ConValue),
+        /// Continue to the next iteration of a loop
+        Continue,
+        /// Underflowed the stack
+        StackUnderflow,
+        /// Exited the last scope
+        ScopeExit,
+        /// Type incompatibility
+        // TODO: store the type information in this error
+        TypeError,
+        /// In clause of For loop didn't yield a Range
+        NotIterable,
+        /// A value could not be indexed
+        NotIndexable,
+        /// An array index went out of bounds
+        OobIndex(usize, usize),
+        /// An expression is not assignable
+        NotAssignable,
+        /// A name was not defined in scope before being used
+        NotDefined(String),
+        /// A name was defined but not initialized
+        NotInitialized(String),
+        /// A value was called, but is not callable
+        NotCallable(ConValue),
+        /// A function was called with the wrong number of arguments
+        ArgNumber {
+            want: usize,
+            got: usize,
+        },
+        NullPointer,
+    }
+
+    impl std::error::Error for Error {}
+    impl std::fmt::Display for Error {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            match self {
+                Error::Return(value) => write!(f, "return {value}"),
+                Error::Break(value) => write!(f, "break {value}"),
+                Error::BadBreak(value) => write!(f, "rogue break: {value}"),
+                Error::Continue => "continue".fmt(f),
+                Error::StackUnderflow => "Stack underflow".fmt(f),
+                Error::ScopeExit => "Exited the last scope. This is a logic bug.".fmt(f),
+                Error::TypeError => "Incompatible types".fmt(f),
+                Error::NotIterable => "`in` clause of `for` loop did not yield an iterable".fmt(f),
+                Error::NotIndexable => {
+                    write!(f, "expression cannot be indexed")
+                }
+                Error::OobIndex(idx, len) => {
+                    write!(f, "Index out of bounds: index was {idx}. but len is {len}")
+                }
+                Error::NotAssignable => {
+                    write!(f, "expression is not assignable")
+                }
+                Error::NotDefined(value) => {
+                    write!(f, "{value} not bound. Did you mean `let {value};`?")
+                }
+                Error::NotInitialized(value) => {
+                    write!(f, "{value} bound, but not initialized")
+                }
+                Error::NotCallable(value) => {
+                    write!(f, "{value} is not callable.")
+                }
+                Error::ArgNumber { want, got } => {
+                    write!(
+                        f,
+                        "Expected {want} argument{}, got {got}",
+                        if *want == 1 { "" } else { "s" }
+                    )
+                }
+                Error::NullPointer => {
+                    write!(f, "Attempted to dereference a null pointer?")
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;

compiler/cl-interpret/src/tests.rs

@@ -0,0 +1,476 @@
+#![allow(unused_imports)]
+use crate::{env::Environment, temp_type_impl::ConValue, Interpret};
+use cl_ast::*;
+use cl_lexer::Lexer;
+use cl_parser::Parser;
+pub use macros::*;
+
+mod macros {
+    //! Useful macros for parsing Conlang
+    //!
+    //! # Parsing
+    //! Macro [`parse`] stringifies, lexes, and parses everything you give to it
+    //! ```rust
+    //! # use conlang::interpreter::tests::*;
+    //! parse!{
+    //!     fn main () {
+    //!         "Hello, world!"
+    //!     }
+    //! }
+    //! ```
+    //!
+    //! # Evaluating
+    //! Macro [`eval`] parses code in the given [`Environment`].
+    //! - [`assert_eval`] does the above, but expects [`Ok`]
+    //! - [`assert_noeval`] does the above, but expects [`Err`]
+    //! ```rust
+    //! # use conlang::interpreter::tests::*;
+    //! let mut env = Default::default();
+    //! eval!{env,
+    //!     let x = 2;
+    //! }.expect("variable binding should succeed.");
+    //! ```
+    //!
+    //! # Extracting Results
+    //! Macros [`env_eq`] and [`env_ne`] take an "Environment Member Expression" and a value which
+    //! implements [`Into<ConValue>`], and asserts that they are either equal or not equal,
+    //! respectively.
+    //!
+    //! Macro [`conv_cmp`] takes two things that can be converted to [`ConValue`], and calls the
+    //! provided comparison function on them, returning a [`bool`].
+    //! ```rust
+    //! # use conlang::interpreter::tests::*;
+    //! let mut env = Default::default();
+    //! assert_eval!{env,
+    //!     let x = 10;
+    //! }
+    //! env_eq!(env.x, 10); // like assert_eq! for Environments
+    //! ```
+    #![allow(unused_macros)]
+    use crate::IResult;
+
+    use super::*;
+
+    pub fn test_inside_block(block: &Block, env: &mut Environment) -> IResult<()> {
+        let Block { stmts } = block;
+        for stmt in stmts {
+            stmt.interpret(env)?;
+        }
+        Ok(())
+    }
+
+    /// Stringifies, lexes, and parses everything you give to it
+    ///
+    /// Returns a `Result<`[`File`]`, ParseError>`
+    pub macro file($($t:tt)*) {
+        Parser::new(Lexer::new(stringify!( $($t)* ))).file()
+    }
+
+    /// Stringifies, lexes, and parses everything you give to it
+    ///
+    /// Returns a `Result<`[`Block`]`, ParseError>`
+    pub macro block($($t:tt)*) {
+        Parser::new(Lexer::new(stringify!({ $($t)* }))).block()
+    }
+
+    /// Evaluates a block of code in the given environment
+    ///
+    /// ```rust,ignore
+    /// eval!(env,
+    ///     // Conlang code goes here
+    ///     fn main () {
+    ///         "Hello, world!"
+    ///     }
+    /// )
+    /// ```
+    pub macro eval($env: path, $($t:tt)*) {{
+        test_inside_block(&block!($($t)*)
+            .expect("code passed to eval! should parse correctly"),
+            &mut $env)
+    }}
+
+    /// Evaluates a block of code in the given environment, expecting the interpreter to succeed
+    ///
+    /// ```rust,ignore
+    /// assert_eval!(env,
+    ///     // Conlang code goes here
+    ///     fn main () {
+    ///         "Hello, world!"
+    ///     }
+    /// )
+    /// ```
+    pub macro assert_eval($($t:tt)*) {
+        eval!($($t)*)
+            .expect(stringify!($($t)* should execute correctly))
+    }
+
+    /// Evaluates a block of code in the given environment, expecting the interpreter to fail
+    ///
+    /// ```rust,ignore
+    /// assert_noeval!(env,
+    ///     // Conlang code goes here
+    ///     fn main () {
+    ///         1 == "Hello world!" // type incompatibility
+    ///     }
+    /// )
+    /// ```
+    pub macro assert_noeval($($t:tt)*) {
+        eval!($($t)*)
+            .expect_err(stringify!($($t)* should not execute correctly))
+    }
+
+    pub macro conv_cmp($func: ident, $a: expr, $b: expr) {
+        $a.$func(&($b).into())
+            .expect(stringify!($a should be comparable to $b))
+            .truthy()
+            .expect(stringify!(result of comparison should be ConValue::Bool))
+    }
+
+    pub macro env_ne($env:ident.$var:ident, $expr:expr) {{
+        let evaluated = $env.get(stringify!($var))
+            .expect(stringify!($var should be defined and initialized));
+        if !conv_cmp!(neq, evaluated, $expr) {
+            panic!("assertion {} ({evaluated}) != {} failed.", stringify!($var), stringify!($expr))
+        }
+    }}
+
+    pub macro env_eq($env:ident.$var:ident, $expr:expr) {{
+        let evaluated = $env.get(stringify!($var))
+            .expect(stringify!($var should be defined and initialized));
+        if !conv_cmp!(eq, evaluated, $expr) {
+            panic!("assertion {} ({evaluated}) == {} failed.", stringify!($var), stringify!($expr))
+        }
+    }}
+    pub macro tuple($($expr:expr),*) {
+        ConValue::from(vec![$(ConValue::from($expr)),*])
+    }
+}
+
+mod let_declarations {
+    use super::*;
+
+    #[test]
+    fn let_binding_uninit() {
+        let mut env = Environment::new();
+        assert_eval!(
+            env,
+            let x;
+        );
+    }
+    #[test]
+    fn let_binding_with_init() {
+        let mut env = Environment::new();
+        assert_eval!( env,
+            let x = 10;
+        );
+
+        env_eq!(env.x, 10)
+    }
+    #[test]
+    fn let_binding_from_another_variable() {
+        let mut env = Environment::new();
+        assert_eval!(env,
+            let x = 10;
+            let y = x;
+        );
+
+        env_eq!(env.x, 10);
+        env_eq!(env.y, 10);
+    }
+}
+
+mod fn_declarations {
+    use super::*;
+    #[test]
+    fn empty_fn() {
+        let mut env = Environment::new();
+        assert_eval!(env, fn empty_fn() {});
+        // TODO: true equality for functions
+        assert_eq!(
+            "fn empty_fn () {\n    \n}",
+            format!(
+                "{}",
+                env.get("empty_fn")
+                    .expect(stringify!(empty_fn should be defined and initialized))
+            )
+        )
+    }
+    #[test]
+    fn identity_fn() {
+        let mut env = Environment::new();
+        assert_eval!(
+            env,
+            fn identity(input: i32) -> i32 {
+                input
+            }
+            let output = identity(12);
+        );
+        env_eq!(env.output, 12);
+    }
+}
+
+mod operators {
+    use cl_ast::Tuple;
+
+    use super::*;
+    #[test]
+    fn unary() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let neg_one = -1;
+            let pos_one = -neg_one;
+            let not_true = !true;
+            let not_false = !false;
+        );
+        env_eq!(env.neg_one, -1);
+        env_eq!(env.pos_one, 1);
+        env_eq!(env.not_true, false);
+        env_eq!(env.not_false, true);
+    }
+    #[test]
+    fn mul_div_rem() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let one = 129 % 32;
+            let twelve = 144 / 12;
+            let one_forty_four = 12 * 12;
+        );
+        env_eq!(env.one, 1);
+        env_eq!(env.twelve, 12);
+        env_eq!(env.one_forty_four, 144);
+    }
+    #[test]
+    fn add_sub() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let is_42 = 17 + 25;
+            let also_42 = 165 - 123;
+        );
+        env_eq!(env.is_42, 42);
+        env_eq!(env.also_42, 42);
+    }
+    #[test]
+    fn shift() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let eight = 1<<3;
+            let one = 8>>3;
+        );
+        env_eq!(env.eight, 8);
+        env_eq!(env.one, 1);
+    }
+    #[test]
+    fn bitwise() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let and_b1010 = 0b1111 & 0b1010;
+            let or__b1111 = 0b1111 | 0b1010;
+            let xor_b0101 = 0b1111 ^ 0b1010;
+        );
+        env_eq!(env.and_b1010, 0b1010);
+        env_eq!(env.or__b1111, 0b1111);
+        env_eq!(env.xor_b0101, 0b0101);
+    }
+    #[test]
+    fn logical() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let t_and_t = true && true;
+            let t_and_f = true && false;
+            let f_and_t = false && true;
+            let f_and_f = false && false;
+
+            let t_or_t = true || true;
+            let t_or_f = true || false;
+            let f_or_t = false || true;
+            let f_or_f = false || false;
+
+            let t_xor_t = true ^^ true;
+            let t_xor_f = true ^^ false;
+            let f_xor_t = false ^^ true;
+            let f_xor_f = false ^^ false;
+        );
+        env_eq!(env.t_and_t, true);
+        env_eq!(env.t_and_f, false);
+        env_eq!(env.f_and_t, false);
+        env_eq!(env.f_and_f, false);
+
+        env_eq!(env.t_or_t, true);
+        env_eq!(env.t_or_f, true);
+        env_eq!(env.f_or_t, true);
+        env_eq!(env.f_or_f, false);
+
+        env_eq!(env.t_xor_t, false);
+        env_eq!(env.t_xor_f, true);
+        env_eq!(env.f_xor_t, true);
+        env_eq!(env.f_xor_f, false);
+    }
+    #[test]
+    fn logical_short_circuits() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let mut and_short_circuits = true;
+            false && { and_short_circuits = false; false };
+
+            let mut or_short_circuits = true;
+            true || { or_short_circuits = false; false };
+        );
+        env_eq!(env.and_short_circuits, true);
+        env_eq!(env.or_short_circuits, true);
+    }
+    #[test]
+    fn range() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let inclusive = 0..=10;
+            let exclusive = 0..10;
+        );
+        // TODO: extract the ranges and actually check them
+    }
+
+    #[test]
+    fn compare() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            // Less than
+            let is_10_lt_20 = 10 <  20;
+            let is_10_le_20 = 10 <= 20;
+            let is_10_eq_20 = 10 == 20;
+            let is_10_ne_20 = 10 != 20;
+            let is_10_ge_20 = 10 >= 20;
+            let is_10_gt_20 = 10 >  20;
+            // Equal to
+            let is_10_lt_10 = 10 <  10;
+            let is_10_le_10 = 10 <= 10;
+            let is_10_eq_10 = 10 == 10;
+            let is_10_ne_10 = 10 != 10;
+            let is_10_ge_10 = 10 >= 10;
+            let is_10_gt_10 = 10 >  10;
+            // Greater than
+            let is_20_lt_10 = 20 <  10;
+            let is_20_le_10 = 20 <= 10;
+            let is_20_eq_10 = 20 == 10;
+            let is_20_ne_10 = 20 != 10;
+            let is_20_ge_10 = 20 >= 10;
+            let is_20_gt_10 = 20 >  10;
+            dump();
+        );
+
+        // Less than
+        env_eq!(env.is_10_lt_20, true); //  <
+        env_eq!(env.is_10_le_20, true); //  <=
+        env_eq!(env.is_10_eq_20, false); // ==
+        env_eq!(env.is_10_ne_20, true); //  !=
+        env_eq!(env.is_10_ge_20, false); // >=
+        env_eq!(env.is_10_gt_20, false); // >
+                                         // Equal to
+        env_eq!(env.is_10_lt_10, false);
+        env_eq!(env.is_10_le_10, true);
+        env_eq!(env.is_10_eq_10, true);
+        env_eq!(env.is_10_ne_10, false);
+        env_eq!(env.is_10_ge_10, true);
+        env_eq!(env.is_10_gt_10, false);
+        // Greater than
+        env_eq!(env.is_20_lt_10, false);
+        env_eq!(env.is_20_le_10, false);
+        env_eq!(env.is_20_eq_10, false);
+        env_eq!(env.is_20_ne_10, true);
+        env_eq!(env.is_20_ge_10, true);
+        env_eq!(env.is_20_gt_10, true);
+    }
+    #[test]
+    fn assign() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let base = 10;
+            let mut assign = base;
+            let mut add = base;
+            let mut sub = base;
+            let mut mul = base;
+            let mut div = base;
+            let mut rem = base;
+            let mut and = base;
+            let mut or_ = base;
+            let mut xor = base;
+            let mut shl = base;
+            let mut shr = base;
+
+            let modifier = 3;
+            assign = modifier;
+            add += modifier;
+            sub -= modifier;
+            mul *= modifier;
+            div /= modifier;
+            rem %= modifier;
+            and &= modifier;
+            or_ |= modifier;
+            xor ^= modifier;
+            shl <<= modifier;
+            shr >>= modifier;
+
+        );
+        let (base, modifier) = (10, 3);
+        env_eq!(env.assign, modifier);
+        env_eq!(env.add, base + modifier);
+        env_eq!(env.sub, base - modifier);
+        env_eq!(env.mul, base * modifier);
+        env_eq!(env.div, base / modifier);
+        env_eq!(env.rem, base % modifier);
+        env_eq!(env.and, base & modifier);
+        env_eq!(env.or_, base | modifier);
+        env_eq!(env.xor, base ^ modifier);
+        env_eq!(env.shl, base << modifier);
+        env_eq!(env.shr, base >> modifier);
+    }
+    #[test]
+    fn assignment_is_left_assoc_and_returns_empty() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let x; // uninitialized (no type)
+            let y = 0xdeadbeef;
+            let z = 10;
+
+            x = y = z;
+        );
+        env_eq!(env.x, ());
+        env_eq!(env.y, 10);
+        env_eq!(env.z, 10);
+    }
+    #[test]
+    #[should_panic]
+    fn assignment_accounts_for_type() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            let x = "a string";
+            let y = 0xdeadbeef;
+            y = x; // should crash: type error
+        );
+    }
+    #[test]
+    fn precedence() {
+        let mut env = Default::default();
+        assert_eval!(env,
+            // mul/div/rem > add/sub
+            let a = 2 * 3 + 4 * 5 / 6; // = 9
+            // add/sub > shift
+            let b = 1 << 3 + 1 << 2; // 1 << 6 = 64
+            // shift > bitwise
+            let c = 4 | 4 << 4; // 4 | 64 = 68
+            // all together now!
+            let d = 1 << 2 + 3 * 4; // 2 << 14 = 16384
+            let e = 4 * 3 + 2 << 1; // 14 << 1 = 28
+        );
+        env_eq!(env.a, 9);
+        env_eq!(env.b, 64);
+        env_eq!(env.c, 68);
+        env_eq!(env.d, 16384);
+        env_eq!(env.e, 28);
+    }
+}
+
+#[allow(dead_code)]
+fn test_template() {
+    let mut env = Default::default();
+    assert_eval!(env,);
+    //env_eq!(, );
+}