pub fn eval_program(symbols: &mut SymbolTable, program: &Program) -> Result<Value> {

    if program.exprs.is_empty() {

    }

    for expr in &program.exprs[..program.exprs.len() - 1] {

        eval_value(symbols, expr)?;

    let value = eval_value(symbols, program.exprs.last().unwrap())?;

    expr_to_value(&value)

}

fn expr_to_value(expr: &Expr) -> Result<Value> {

    match expr {

        Expr::Nil => Ok(Value::Nil),

        Expr::Bool(b) => Ok(Value::Bool(*b)),

        Expr::Number(n) => Ok(Value::Number(*n)),

        Expr::String(s) => Ok(Value::String(s.clone())),

        Expr::Symbol(s) => Ok(Value::Symbol(s.clone())),

        Expr::Quote(inner) => quoted_to_value(inner),

        Expr::List(_) => Ok(Value::String(format_expr(expr))),

        Expr::RuntimeValue(val) => Ok(val.clone()),

        _ => Err(Error::Compile(format!("unsupported expression: {expr:?}"))),

}

fn quoted_to_value(inner: &Expr) -> Result<Value> {

    match inner {

        Expr::Symbol(s) => Ok(Value::Symbol(s.clone())),

        Expr::Bytes(b) => Ok(Value::Bytes(b.clone())),

        Expr::List(elems) => {

            let inner: Vec<_> = elems.iter().map(format_expr).collect();

            Ok(Value::String(format!("({})", inner.join(" "))))

}