Enum Either

pub enum Either<A, B> {
    A(A),
    B(B),
}

Variants

A(A)

B(B)

Trait Implementations

impl<A: AsRef<PyObject>, B: AsRef<PyObject>> AsRef<PyObject> for Either<A, B>

fn as_ref(&self) -> &PyObject

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Borrow<PyObject>, B: Borrow<PyObject>> Borrow<PyObject> for Either<A, B>

fn borrow(&self) -> &PyObject

Immutably borrows from an owned value.

impl<A: Into<PyObjectRef>, B: Into<PyObjectRef>> From<Either<A, B>> for PyObjectRef

fn from(value: Either<A, B>) -> Self

Converts to this type from the input type.

impl<A: ToPyObject, B: ToPyObject> ToPyObject for Either<A, B>

fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef

impl<A: Traverse, B: Traverse> Traverse for Either<A, B>

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>)

impl traverse() with caution! Following those guideline so traverse doesn’t cause memory error!:

impl<A, B> TryFromObject for Either<A, B>

where A: TryFromObject, B: TryFromObject,

This allows a builtin method to accept arguments that may be one of two types, raising a TypeError if it is neither.

Example

use rustpython_vm::VirtualMachine;
use rustpython_vm::builtins::{PyStrRef, PyIntRef};
use rustpython_vm::function::Either;

fn do_something(arg: Either<PyIntRef, PyStrRef>, vm: &VirtualMachine) {
    match arg {
        Either::A(int)=> {
            // do something with int
        }
        Either::B(string) => {
            // do something with string
        }
    }
}

fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self>

Attempt to convert a Python object to a value of this type.