rudus/src/value.rs

use crate::compiler::Chunk;
use crate::parser::Ast;
use crate::spans::Spanned;
use imbl::{HashMap, Vector};
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Clone, Debug, PartialEq)]
pub struct LBox {
    pub name: usize,
    pub cell: RefCell<Value>,
}

#[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(Clone, Debug, PartialEq)]
pub enum Value {
    Nil,
    True,
    False,
    Keyword(usize), // use an idx, rather than a raw index
    Interned(usize),
    FnDecl(usize),
    String(Rc<String>),
    Number(f64),
    Tuple(Rc<Vec<Value>>),
    TupleStart { len: u8, size: u16 },
    TupleEnd { len: u8, size: u16 },
    List(Box<Vector<Value>>),
    Dict(Box<HashMap<usize, Value>>),
    Box(Rc<LBox>),
    Fn(Rc<RefCell<LFn>>),
}

impl Value {
    pub fn show(&self, ctx: &Chunk) -> String {
        use Value::*;
        match &self {
            Nil => "nil".to_string(),
            True => "true".to_string(),
            False => "false".to_string(),
            Number(n) => format!("{n}"),
            Interned(i) => {
                let str_str = ctx.strings[*i];
                format!("\"{str_str}\"")
            }
            Keyword(i) => {
                let kw_str = ctx.keywords[*i];
                format!(":{kw_str}")
            }
            Tuple(t) => {
                let members = t.iter().map(|e| e.show(ctx)).collect::<Vec<_>>().join(", ");
                format!("({members})")
            }
            List(l) => {
                let members = l.iter().map(|e| e.show(ctx)).collect::<Vec<_>>().join(", ");
                format!("[{members}]")
            }
            Dict(d) => {
                let members = d
                    .iter()
                    .map(|(k, v)| {
                        let key_show = Value::Keyword(*k).show(ctx);
                        let value_show = v.show(ctx);
                        format!("{key_show} {value_show}")
                    })
                    .collect::<Vec<_>>()
                    .join(", ");
                format!("#{{{members}}}")
            }
            String(s) => s.as_ref().clone(),
            _ => todo!(),
        }
    }
}