Function project

src/selector.rs:33–150

(helper: &MyHelper, value: IDLValue, path: Vec<Selector>)

    }
}
pub fn project(helper: &MyHelper, value: IDLValue, path: Vec<Selector>) -> Result<IDLValue> {
    let mut result = value;
    for head in path.into_iter() {
        match (result, head) {
            (IDLValue::Opt(opt), Selector::Option) => result = *opt,
            (IDLValue::Blob(b), Selector::Index(e)) => {
                let idx = as_u32(&e.eval(helper)?)?;
                result = IDLValue::Nat8(
                    *b.get(idx as usize)
                        .ok_or_else(|| anyhow!("idx out of bound"))?,
                )
            }
            (IDLValue::Vec(mut vs), Selector::Index(e)) => {
                let idx = as_u32(&e.eval(helper)?)? as usize;
                if idx < vs.len() {
                    result = vs.swap_remove(idx);
                } else {
                    return Err(anyhow!("{} out of bound {}", idx, vs.len()));
                }
            }
            (IDLValue::Text(s), Selector::Index(e)) => {
                let idx = as_u32(&e.eval(helper)?)? as usize;
                if idx < s.len() {
                    result = IDLValue::Text(s.chars().nth(idx).unwrap().to_string());
                } else {
                    return Err(anyhow!("{} out of bound {}", idx, s.len()));
                }
            }
            (IDLValue::Blob(b), Selector::Map(func)) => {
                let vs = b.into_iter().map(IDLValue::Nat8).collect();
                result = IDLValue::Vec(map(helper, vs, &func)?);
            }
            (IDLValue::Vec(vs), Selector::Map(func)) => {
                result = IDLValue::Vec(map(helper, vs, &func)?);
            }
            (IDLValue::Blob(b), Selector::Filter(func)) => {
                let vs = b.into_iter().map(IDLValue::Nat8).collect();
                result = IDLValue::Vec(filter(helper, vs, &func)?);
            }
            (IDLValue::Vec(vs), Selector::Filter(func)) => {
                result = IDLValue::Vec(filter(helper, vs, &func)?);
            }
            (IDLValue::Blob(b), Selector::Fold(init, func)) => {
                let vs = b.into_iter().map(IDLValue::Nat8).collect();
                result = fold(helper, init, vs, &func)?;
            }
            (IDLValue::Vec(vs), Selector::Fold(init, func)) => {
                result = fold(helper, init, vs, &func)?;
            }
            (IDLValue::Blob(b), Selector::Size) => {
                result = IDLValue::Nat(b.len().into());
            }
            (IDLValue::Vec(vs), Selector::Size) => {
                result = IDLValue::Nat(vs.len().into());
            }
            (IDLValue::Record(fs), Selector::Map(func)) => {
                let vs = from_fields(fs);
                let res = map(helper, vs, &func)?;