Enum librsnek::modules::builtins::types::Type

pub enum Type {
    Object(RefCountedValue<ObjectValue, RefCount>),
    None(RefCountedValue<NoneValue, RefCount>),
    Bool(RefCountedValue<BoolValue, RefCount>),
    Int(RefCountedValue<IntValue, RefCount>),
    Float(RefCountedValue<FloatValue, RefCount>),
    Iter(RefCountedValue<IteratorValue, RefCount>),
    Complex(RefCountedValue<ComplexValue, RefCount>),
    Str(RefCountedValue<StringValue, RefCount>),
    Bytes(RefCountedValue<StringValue, RefCount>),
    Dict(RefCountedValue<DictValue, RefCount>),
    Tuple(RefCountedValue<TupleValue, RefCount>),
    List(RefCountedValue<ListValue, RefCount>),
    Type(RefCountedValue<TypeValue, RefCount>),
    Function(RefCountedValue<FuncValue, RefCount>),
    Module(RefCountedValue<ObjectValue, RefCount>),
    Code(RefCountedValue<CodeValue, RefCount>),
    Frame(RefCountedValue<FrameValue, RefCount>),
    Set(RefCountedValue<SetValue, RefCount>),
    FrozenSet(RefCountedValue<FrozenSetValue, RefCount>),
    DictKey(DictKey),
}

Variants

Object(RefCountedValue<ObjectValue, RefCount>)None(RefCountedValue<NoneValue, RefCount>)Bool(RefCountedValue<BoolValue, RefCount>)Int(RefCountedValue<IntValue, RefCount>)Float(RefCountedValue<FloatValue, RefCount>)Iter(RefCountedValue<IteratorValue, RefCount>)Complex(RefCountedValue<ComplexValue, RefCount>)Str(RefCountedValue<StringValue, RefCount>)Bytes(RefCountedValue<StringValue, RefCount>)Dict(RefCountedValue<DictValue, RefCount>)Tuple(RefCountedValue<TupleValue, RefCount>)List(RefCountedValue<ListValue, RefCount>)Type(RefCountedValue<TypeValue, RefCount>)Function(RefCountedValue<FuncValue, RefCount>)Module(RefCountedValue<ObjectValue, RefCount>)Code(RefCountedValue<CodeValue, RefCount>)Frame(RefCountedValue<FrameValue, RefCount>)Set(RefCountedValue<SetValue, RefCount>)FrozenSet(RefCountedValue<FrozenSetValue, RefCount>)DictKey(DictKey)

Methods

impl Type

fn debug_name(&self) -> &str

Since we do not have actual type objects just statically map the names of

Trait Implementations

impl PartialEq for Type

fn eq(&self, rhs: &Type) -> bool

This method tests for self and other values to be equal, and is used

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for Type

fn assert_receiver_is_total_eq(&self)

impl Debug for Type

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for Type

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Iterator for Type

type Item = RtObject

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

Consumes the iterator, returning the last element.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator<Item = Self::Item>, 

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator, 

'Zips up' two iterators into a single iterator of pairs.

fn map<B, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> B, 

Takes a closure and creates an iterator which calls that closure on each

fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator which uses a closure to determine if an element

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<B>, 

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

Creates an iterator which gives the current iteration count as well as

fn peekable(self) -> Peekable<Self>

Creates an iterator which can use peek to look at the next element of

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator that [skip]s elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator that yields elements based on a predicate.

fn skip(self, n: usize) -> Skip<Self>

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

Creates an iterator that yields its first n elements.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    F: FnMut(&mut St, Self::Item) -> Option<B>, 

An iterator adaptor similar to [fold] that holds internal state and

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator, 

Creates an iterator that works like map, but flattens nested structure.

fn fuse(self) -> Fuse<Self>

Creates an iterator which ends after the first [None].

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item) -> (), 

Do something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

Borrows an iterator, rather than consuming it.

fn collect<B>(self) -> B where
    B: FromIterator<Self::Item>, 

Transforms an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B) where
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool, 

Consumes an iterator, creating two collections from it.

fn fold<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, Self::Item) -> B, 

An iterator adaptor that applies a function, producing a single, final value.

fn all<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

Searches for an element of an iterator that satisfies a predicate.

fn position<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool, 

Searches for an element in an iterator, returning its index.

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: ExactSizeIterator + DoubleEndedIterator, 

Searches for an element in an iterator from the right, returning its

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the maximum value from the

fn max_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the maximum value with respect to the

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the minimum value from the

fn min_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the minimum value with respect to the

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedIterator, 

Reverses an iterator's direction.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Iterator<Item = (A, B)>, 

Converts an iterator of pairs into a pair of containers.

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone, 

Creates an iterator which [clone]s all of its elements.

fn cycle(self) -> Cycle<Self> where
    Self: Clone, 

Repeats an iterator endlessly.

fn sum<S>(self) -> S where
    S: Sum<Self::Item>, 

Sums the elements of an iterator.

fn product<P>(self) -> P where
    P: Product<Self::Item>, 

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord, 

Lexicographically compares the elements of this Iterator with those

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Lexicographically compares the elements of this Iterator with those

fn eq<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are equal to those of

fn ne<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are unequal to those of

fn lt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

fn le<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

fn gt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

fn ge<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically

impl Hash for Type

fn hash<H: Hasher>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl SelfRef for Type

fn strong_count(&self) -> Integer

fn weak_count(&self) -> Integer

fn set(&self, objref: &RtObject)

fn get(&self) -> WeakRtObject

fn upgrade(&self) -> Result<RtObject, Error>

impl PyAPI for Type

impl GetAttr for Type

fn op_getattr(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_getattr(&self, name: &Type) -> Result<RtObject, Error>

Native API Method $pyname

impl SetAttr for Type

fn op_setattr(
    &self,
    rt: &Runtime,
    name: &RtObject,
    value: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_setattr(&self, name: &Type, value: &Type) -> Result<None, Error>

Native API Method $pyname

impl Id for Type

fn op_id(&self, rt: &Runtime) -> Result<RtObject, Error>

fn native_id(&self) -> ObjectId

impl Is for Type

fn op_is(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

fn native_is(&self, rhs: &Type) -> Result<Boolean, Error>

impl IsNot for Type

fn op_is_not(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

fn native_is_not(&self, rhs: &Type) -> Result<Boolean, Error>

impl Hashed for Type

fn op_hash(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_hash(&self) -> Result<HashId, Error>

Native API Method $pyname

impl StringCast for Type

fn op_str(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_str(&self) -> Result<String, Error>

Native API Method $pyname

impl BytesCast for Type

fn op_bytes(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_bytes(&self) -> Result<Bytes, Error>

Native API Method $pyname

impl StringFormat for Type

fn op_format(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_format(&self) -> Result<String, Error>

Native API Method $pyname

impl StringRepresentation for Type

fn op_repr(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_repr(&self) -> Result<String, Error>

Native API Method $pyname

impl Equal for Type

fn op_eq(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Default implementation of equals fallsbacks to op_is.

fn native_eq(&self, rhs: &Type) -> Result<Boolean, Error>

Default implementation of equals fallsbacks to op_is.

impl NotEqual for Type

fn op_ne(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Default implementation of equals fallsbacks to !op_is

fn native_ne(&self, rhs: &Type) -> Result<Boolean, Error>

Default implementation of equals fallsbacks to op_is.

impl LessThan for Type

fn op_lt(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_lt(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl LessOrEqual for Type

fn op_le(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_le(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl GreaterOrEqual for Type

fn op_ge(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ge(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl GreaterThan for Type

fn op_gt(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_gt(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl BooleanCast for Type

fn op_bool(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_bool(&self) -> Result<Boolean, Error>

Native API Method $pyname

impl IntegerCast for Type

fn op_int(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_int(&self) -> Result<Integer, Error>

Native API Method $pyname

impl FloatCast for Type

fn op_float(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_float(&self) -> Result<Float, Error>

Native API Method $pyname

impl ComplexCast for Type

fn op_complex(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_complex(&self) -> Result<Complex, Error>

Native API Method $pyname

impl Index for Type

fn op_index(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_index(&self) -> Result<Integer, Error>

Native API Method $pyname

impl NegateValue for Type

fn op_neg(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_neg(&self) -> Result<Number, Error>

Native API Method $pyname

impl AbsValue for Type

fn op_abs(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_abs(&self) -> Result<Number, Error>

Native API Method $pyname

impl PositiveValue for Type

fn op_pos(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_pos(&self) -> Result<Number, Error>

Native API Method $pyname

impl InvertValue for Type

fn op_invert(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_invert(&self) -> Result<Number, Error>

Native API Method $pyname

impl Add for Type

fn op_add(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_add(&self, rhs: &Type) -> Result<Native, Error>

Native API Method $pyname

impl BitwiseAnd for Type

fn op_and(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_and(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl DivMod for Type

fn op_divmod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_divmod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl FloorDivision for Type

fn op_floordiv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_floordiv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl LeftShift for Type

fn op_lshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_lshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Modulus for Type

fn op_mod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_mod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Multiply for Type

fn op_mul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_mul(&self, rhs: &Type) -> Result<Native, Error>

Native API Method $pyname

impl MatrixMultiply for Type

fn op_matmul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_matmul(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl BitwiseOr for Type

fn op_or(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_or(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Pow for Type

fn op_pow(
    &self,
    rt: &Runtime,
    power: &RtObject,
    modulus: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_pow(&self, power: &Type, modulus: &Type) -> Result<Type, Error>

Native API Method $pyname

impl RightShift for Type

fn op_rshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Subtract for Type

fn op_sub(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_sub(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl TrueDivision for Type

fn op_truediv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_truediv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl XOr for Type

fn op_xor(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_xor(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceAdd for Type

fn op_iadd(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_iadd(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceBitwiseAnd for Type

fn op_iand(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_iand(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceDivMod for Type

fn op_idivmod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_idivmod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceFloorDivision for Type

fn op_ifloordiv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ifloordiv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceLeftShift for Type

fn op_ilshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ilshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceModulus for Type

fn op_imod(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_imod(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceMultiply for Type

fn op_imul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_imul(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceMatrixMultiply for Type

fn op_imatmul(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_imatmul(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceBitwiseOr for Type

fn op_ior(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ior(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlacePow for Type

fn op_ipow(
    &self,
    rt: &Runtime,
    power: &RtObject,
    modulus: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ipow(&self, power: &Type, modulus: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceRightShift for Type

fn op_irshift(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_irshift(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceSubtract for Type

fn op_isub(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_isub(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceTrueDivision for Type

fn op_itruediv(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_itruediv(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl InPlaceXOr for Type

fn op_ixor(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ixor(&self, rhs: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Contains for Type

fn op_contains(&self, rt: &Runtime, rhs: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_contains(&self, rhs: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl Iter for Type

fn op_iter(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_iter(&self) -> Result<Iterator, Error>

Native API Method $pyname

impl Call for Type

fn op_call(
    &self,
    rt: &Runtime,
    pos_args: &RtObject,
    starargs: &RtObject,
    kwargs: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_call(
    &self,
    pos_args: &Type,
    starargs: &Type,
    kwargs: &Type
) -> Result<Type, Error>

Native API Method $pyname

impl Length for Type

fn op_len(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_len(&self) -> Result<Integer, Error>

Native API Method $pyname

impl Next for Type

fn op_next(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_next(&self) -> Result<RtObject, Error>

Native API Method $pyname

impl GetItem for Type

fn op_getitem(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_getitem(&self, name: &Type) -> Result<RtObject, Error>

Native API Method $pyname

impl SetItem for Type

fn op_setitem(
    &self,
    rt: &Runtime,
    name: &RtObject,
    item: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_setitem(&self, name: &Type, item: &Type) -> Result<None, Error>

Native API Method $pyname

impl DeleteItem for Type

fn op_delitem(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_delitem(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Count for Type

fn meth_count(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_count(&self, name: &Type) -> Result<Integer, Error>

Native API Method $pyname

impl Append for Type

fn meth_append(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_append(&self, name: &Type) -> Result<None, Error>

Native API Method $pyname

impl Extend for Type

fn meth_extend(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_extend(&self, name: &Type) -> Result<None, Error>

Native API Method $pyname

impl Pop for Type

fn meth_pop(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_pop(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Remove for Type

fn meth_remove(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_remove(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl IsDisjoint for Type

fn meth_isdisjoint(
    &self,
    rt: &Runtime,
    name: &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_isdisjoint(&self, name: &Type) -> Result<Boolean, Error>

Native API Method $pyname

impl AddItem for Type

fn meth_add(&self, rt: &Runtime, name: &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_add(&self, name: &Type) -> Result<Type, Error>

Native API Method $pyname

impl Keys for Type

fn meth_keys(&self, rt: &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_keys(&self) -> Result<Tuple, Error>

Native API Method $pyname

impl Await for Type

fn op_await(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_await(&self) -> Result<Type, Error>

Native API Method $pyname

impl Clear for Type

fn meth_clear(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_clear(&self) -> Result<Type, Error>

Native API Method $pyname

impl Close for Type

fn meth_close(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_close(&self) -> Result<Type, Error>

Native API Method $pyname

impl DelAttr for Type

fn op_delattr(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_delattr(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Delete for Type

fn op_del(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_del(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl DescriptorGet for Type

fn op_get(&self, &Runtime, &RtObject, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_get(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl DescriptorSet for Type

fn op_set(&self, &Runtime, &RtObject, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_set(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl DescriptorSetName for Type

fn op_set_name(&self, &Runtime, &RtObject, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_set_name(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Discard for Type

fn meth_discard(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_discard(&self) -> Result<Type, Error>

Native API Method $pyname

impl Enter for Type

fn op_enter(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_enter(&self) -> Result<Type, Error>

Native API Method $pyname

impl Exit for Type

fn op_exit(
    &self,
    &Runtime,
    &RtObject,
    &RtObject,
    &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_exit(&self, &Type, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Get for Type

fn meth_get(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_get(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl GetAttribute for Type

fn op_getattribute(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_getattribute(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Init for Type

fn op_init(
    &mut self,
    rt: &Runtime,
    named_args: &RtObject,
    args: &RtObject,
    kwargs: &RtObject
) -> Result<RtObject, Error>

fn native_init(
    &mut self,
    named_args: &Type,
    args: &Type,
    kwargs: &Type
) -> Result<None, Error>

impl Items for Type

fn meth_items(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_items(&self) -> Result<Type, Error>

Native API Method $pyname

impl LengthHint for Type

fn op_length_hint(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_length_hint(&self) -> Result<Integer, Error>

Native API Method $pyname

impl New for Type

fn op_new(
    &self,
    &Runtime,
    &RtObject,
    &RtObject,
    &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_new(&self, &Type, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl PopItem for Type

fn meth_popitem(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_popitem(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedAdd for Type

fn op_radd(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_radd(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedBitwiseAnd for Type

fn op_rand(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rand(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedBitwiseOr for Type

fn op_ror(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_ror(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedDivMod for Type

fn op_rdivmod(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rdivmod(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedFloorDivision for Type

fn op_rfloordiv(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rfloordiv(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedLeftShift for Type

fn op_rlshift(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rlshift(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedMatrixMultiply for Type

fn op_rmatmul(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rmatmul(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedModulus for Type

fn op_rmod(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rmod(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedMultiply for Type

fn op_rmul(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rmul(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedPow for Type

fn op_rpow(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rpow(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedRightShift for Type

fn op_rrshift(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rrshift(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedSubtract for Type

fn op_rsub(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rsub(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedTrueDivision for Type

fn op_rtruediv(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rtruediv(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl ReflectedXOr for Type

fn op_rxor(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_rxor(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Reversed for Type

fn op_reversed(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_reversed(&self) -> Result<Type, Error>

Native API Method $pyname

impl Rounding for Type

fn op_round(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_round(&self) -> Result<Number, Error>

Native API Method $pyname

impl Send for Type

fn meth_send(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_send(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl SetDefault for Type

fn meth_setdefault(
    &self,
    &Runtime,
    &RtObject,
    &RtObject
) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_setdefault(&self, &Type, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Throw for Type

fn meth_throw(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_throw(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Update for Type

fn meth_update(&self, &Runtime, &RtObject) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_update(&self, &Type) -> Result<Type, Error>

Native API Method $pyname

impl Values for Type

fn meth_values(&self, &Runtime) -> Result<RtObject, Error>

Runtime API Method $pyname

fn native_meth_values(&self) -> Result<Type, Error>

Native API Method $pyname