Method as_number

crates/vm/src/builtins/set.rs:824–936

()

impl AsNumber for PySet {
    fn as_number() -> &'static PyNumberMethods {
        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
            // Binary ops check both operands are sets (like CPython's set_sub, etc.)
            // This is needed because __rsub__ swaps operands: a.__rsub__(b) calls subtract(b, a)
            subtract: Some(|a, b, vm| {
                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
                    return Ok(vm.ctx.not_implemented());
                }
                if let Some(a) = a.downcast_ref::<PySet>() {
                    a.__sub__(b.to_owned(), vm).to_pyresult(vm)
                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                    // When called via __rsub__, a might be PyFrozenSet
                    a.__sub__(b.to_owned(), vm)
                        .map(|r| {
                            r.map(|s| PySet {
                                inner: s.inner.clone(),
                            })
                        })
                        .to_pyresult(vm)
                } else {
                    Ok(vm.ctx.not_implemented())
                }
            }),
            and: Some(|a, b, vm| {
                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
                    return Ok(vm.ctx.not_implemented());
                }
                if let Some(a) = a.downcast_ref::<PySet>() {
                    a.__and__(b.to_owned(), vm).to_pyresult(vm)
                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                    a.__and__(b.to_owned(), vm)
                        .map(|r| {
                            r.map(|s| PySet {
                                inner: s.inner.clone(),
                            })
                        })
                        .to_pyresult(vm)
                } else {
                    Ok(vm.ctx.not_implemented())
                }
            }),
            xor: Some(|a, b, vm| {
                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
                    return Ok(vm.ctx.not_implemented());
                }
                if let Some(a) = a.downcast_ref::<PySet>() {
                    a.__xor__(b.to_owned(), vm).to_pyresult(vm)
                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                    a.__xor__(b.to_owned(), vm)
                        .map(|r| {
                            r.map(|s| PySet {
                                inner: s.inner.clone(),
                            })
                        })
                        .to_pyresult(vm)
                } else {
                    Ok(vm.ctx.not_implemented())
                }