Enum Or4

pub enum Or4<T1, T2, T3, T4> {
    T1(T1),
    T2(T2),
    T3(T3),
    T4(T4),
}

Or4 is an enum representing a value that can be either of 4 types, T1 … T4.

Variants

T1(T1)

T2(T2)

T3(T3)

T4(T4)

Implementations

impl<T1, T2, T3, T4> Or4<T1, T2, T3, T4>

pub fn is_t1(&self) -> bool

Returns true if the enum is of type T1.

pub fn is_t2(&self) -> bool

Returns true if the enum is of type T2.

pub fn is_t3(&self) -> bool

Returns true if the enum is of type T3.

pub fn is_t4(&self) -> bool

Returns true if the enum is of type T4.

pub fn as_t1(self) -> Option<T1>

Converts the enum to an Option containing the T1 value, if it is of type T1.

pub fn as_t2(self) -> Option<T2>

Converts the enum to an Option containing the T2 value, if it is of type T2.

pub fn as_t3(self) -> Option<T3>

Converts the enum to an Option containing the T3 value, if it is of type T3.

pub fn as_t4(self) -> Option<T4>

Converts the enum to an Option containing the T4 value, if it is of type T4.

pub fn map_t1<F, B>(self, f: F) -> Or4<B, T2, T3, T4>

where F: FnOnce(T1) -> B,

Transforms the T1 value of the enum using a provided function, maintaining other types as is.

pub fn map_t2<F, B>(self, f: F) -> Or4<T1, B, T3, T4>

where F: FnOnce(T2) -> B,

Transforms the T2 value of the enum using a provided function, maintaining other types as is.

pub fn map_t3<F, B>(self, f: F) -> Or4<T1, T2, B, T4>

where F: FnOnce(T3) -> B,

Transforms the T3 value of the enum using a provided function, maintaining other types as is.

pub fn map_t4<F, B>(self, f: F) -> Or4<T1, T2, T3, B>

where F: FnOnce(T4) -> B,

Transforms the T4 value of the enum using a provided function, maintaining other types as is.

pub fn fold<T, F0, F1, F2, F3, F4>(self, f1: F1, f2: F2, f3: F3, f4: F4) -> T

where F1: FnOnce(T1) -> T, F2: FnOnce(T2) -> T, F3: FnOnce(T3) -> T, F4: FnOnce(T4) -> T,

Consolidates the Or4 enum into a single value of type T, by applying provided functions.

impl<T1, T2, T3, T4> Or4<T1, T2, T3, T4>

where T1: 'static, T2: 'static, T3: 'static, T4: 'static,

Extension to Or4 to check if the enum’s type matches a arbitrary type. Currently, these functions depend on the rustc intrinsics, and the constraints of the intrinsics require that the type must satisfy 'static'.

pub fn is_type<T: 'static>(&self) -> bool