Enum Or6

pub enum Or6<T1, T2, T3, T4, T5, T6> {
    T1(T1),
    T2(T2),
    T3(T3),
    T4(T4),
    T5(T5),
    T6(T6),
}

Or6 is an enum representing a value that can be either of 6 types, T1 … T6.

Variants

T1(T1)

T2(T2)

T3(T3)

T4(T4)

T5(T5)

T6(T6)

Implementations

impl<T1, T2, T3, T4, T5, T6> Or6<T1, T2, T3, T4, T5, T6>

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 is_t5(&self) -> bool

Returns true if the enum is of type T5.

pub fn is_t6(&self) -> bool

Returns true if the enum is of type T6.

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 as_t5(self) -> Option<T5>

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

pub fn as_t6(self) -> Option<T6>

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

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

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) -> Or6<T1, B, T3, T4, T5, T6>

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) -> Or6<T1, T2, B, T4, T5, T6>

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) -> Or6<T1, T2, T3, B, T5, T6>

where F: FnOnce(T4) -> B,

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

pub fn map_t5<F, B>(self, f: F) -> Or6<T1, T2, T3, T4, B, T6>

where F: FnOnce(T5) -> B,

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

pub fn map_t6<F, B>(self, f: F) -> Or6<T1, T2, T3, T4, T5, B>

where F: FnOnce(T6) -> B,

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

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

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

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

impl<T1, T2, T3, T4, T5, T6> Or6<T1, T2, T3, T4, T5, T6>

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

Extension to Or6 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