Method truthy

compiler/src/modules/vm/ops.rs:94–128

(&self, v: Val)

impl<'a> VM<'a> {
    pub fn truthy(&self, v: Val) -> bool {
        if v.is_none() || v.is_false() { return false; }
        if v.is_true() { return true; }
        if v.is_int() { return v.as_int() != 0; }
        if v.is_float() { return v.as_float() != 0.0; }
        match self.heap.get(v) {
            HeapObj::Str(s) => !s.is_empty(),
            HeapObj::Bytes(b) => !b.is_empty(),
            HeapObj::LongInt(i) => *i != 0,
            HeapObj::List(l) => !l.borrow().is_empty(),
            HeapObj::Tuple(t) => !t.is_empty(),
            HeapObj::Dict(d) => !d.borrow().is_empty(),
            HeapObj::Set(s) => !s.borrow().is_empty(),
            HeapObj::FrozenSet(s) => !s.is_empty(),
            HeapObj::Range(s,e,st) => if *st > 0 { s < e } else { s > e },
            HeapObj::Type(_) => true,
            HeapObj::Func(_, _, _) => true,
            HeapObj::Slice(..) => true,
            HeapObj::BoundMethod(..) => true,
            HeapObj::NativeFn(_) => true,
            HeapObj::Class(..) => true,
            HeapObj::BoundUserMethod(..) => true,
            HeapObj::Super(..) => true,
            HeapObj::Property(..) => true,
            HeapObj::PropertySetter(..) => true,
            HeapObj::StaticMethod(..) => true,
            HeapObj::Instance(..) => true,
            HeapObj::Coroutine(..) => true,
            HeapObj::Module(..) => true,
            HeapObj::Extern(_) => true,
            HeapObj::ExcInstance(..) => true,
            HeapObj::Ellipsis => true,
            HeapObj::NotImplemented => true,
        }
    }

    pub fn bitwise_op(&mut self, a: Val, b: Val, op: impl Fn(i128, i128) -> i128) -> Result<Val, VmErr> {
        let ai = as_i128(a, &self.heap).ok_or(cold_type("bitwise op requires integer operands"))?;