rudus/src/value.rs

use crate::parser::*;
use crate::spans::*;
use imbl::*;
use std::fmt;
use std::rc::Rc;

#[derive(Clone, Debug, PartialEq)]
pub struct Clause<'src> {
    patt: Pattern<'src>,
    span: Span,
    body: Ast<'src>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Fn<'src> {
    name: &'src str,
    span: Span,
    body: Vec<Clause<'src>>,
}

#[derive(Debug, PartialEq)]
pub enum Value<'src> {
    Nil,
    Boolean(bool),
    Number(f64),
    Keyword(&'src str),
    String(&'src str),
    // on the heap for now
    Tuple(Rc<Vec<Self>>),
    // ref-counted, immutable, persistent
    List(Rc<Vector<Self>>),
    // ref-counted, immutable, persistent
    Dict(Rc<HashMap<&'src str, Self>>),
    // Fn(Rc<Fn<'src>>),
    // 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.clone()),
            Value::String(s) => Value::String(s),
            Value::Keyword(s) => Value::Keyword(s),
            Value::Number(n) => Value::Number(n.clone()),
            Value::Tuple(t) => Value::Tuple(t.clone()),
            Value::List(l) => Value::List(l.clone()),
            Value::Dict(d) => Value::Dict(d.clone()),
        }
    }
}

impl<'src> fmt::Display for Value<'src> {
    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::String(s) => write!(f, "\"{}\"", s),
            // Value::Fn(fun) => write!(f, "fn {}", fun.name),
            Value::Tuple(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),
        }
    }
}

impl<'src> Value<'src> {
    pub fn bool(&self) -> bool {
        match self {
            Value::Nil | Value::Boolean(false) => false,
            _ => true,
        }
    }
}