Method eval

src/exp.rs:84–795

(self, helper: &MyHelper)

        )
    }
    pub fn eval(self, helper: &MyHelper) -> Result<IDLValue> {
        Ok(match self {
            Exp::Path(id, path) => {
                let v = helper
                    .env
                    .0
                    .get(&id)
                    .ok_or_else(|| anyhow!("Undefined variable {}", id))?
                    .clone();
                project(helper, v, path)?
            }
            Exp::AnnVal(v, ty) => {
                let arg = v.eval(helper)?;
                cast_type(arg, &ty).with_context(|| format!("casting to type {ty} fails"))?
            }
            Exp::Fail(v) => match v.eval(helper) {
                Err(e) => IDLValue::Text(e.to_string()),
                Ok(_) => return Err(anyhow!("Expects an error state")),
            },
            Exp::Apply(func, exps) => {
                use crate::account_identifier::*;

                // functions that cannot evaluate arguments first
                match func.as_str() {
                    "ite" => {
                        if exps.len() != 3 {
                            return Err(anyhow!(
                                "ite expects a bool, true branch and false branch"
                            ));
                        }
                        return Ok(match exps[0].clone().eval(helper)? {
                            IDLValue::Bool(true) => exps[1].clone().eval(helper)?,
                            IDLValue::Bool(false) => exps[2].clone().eval(helper)?,
                            _ => {
                                return Err(anyhow!(
                                    "ite expects the first argument to be a boolean expression"
                                ));
                            }
                        });
                    }
                    "exist" => {
                        if exps.len() != 1 {
                            return Err(anyhow!("exist expects an expression"));
                        }
                        return Ok(match exps[0].clone().eval(helper) {
                            Ok(_) => IDLValue::Bool(true),
                            Err(_) => IDLValue::Bool(false),
                        });
                    }
                    "export" => {
                        use std::io::{BufWriter, Write};
                        if exps.len() <= 1 {
                            return Err(anyhow!("export expects at least two arguments"));
                        }
                        let path = exps[0].clone().eval(helper)?;
                        let IDLValue::Text(path) = path else {
                            return Err(anyhow!("export expects first argument to be a file path"));
                        };