Trait TupleCombinator 

pub trait TupleCombinator: Sized {
    type Tuple;

    // Required method
    fn transpose(self) -> Option<Self::Tuple>;

    // Provided methods
    fn map<U, F: FnOnce(Self::Tuple) -> U>(self, f: F) -> Option<U> { ... }
    fn expect(self, msg: &str) -> Self::Tuple { ... }
    fn unwrap(self) -> Self::Tuple { ... }
    fn and(self, optb: Option<Self::Tuple>) -> Option<Self::Tuple> { ... }
    fn and_then<U, F: FnOnce(Self::Tuple) -> Option<U>>(self, f: F) -> Option<U> { ... }
    fn filter<P: FnOnce(&Self::Tuple) -> bool>(
        self,
        predicate: P,
    ) -> Option<Self::Tuple> { ... }
    fn or(self, optb: Option<Self::Tuple>) -> Option<Self::Tuple> { ... }
    fn or_else<F: FnOnce() -> Option<Self::Tuple>>(
        self,
        f: F,
    ) -> Option<Self::Tuple> { ... }
    fn xor(self, optb: Option<Self::Tuple>) -> Option<Self::Tuple> { ... }
}

The traits that provides helper functions for tuples. This trait implementation mirros most of the methods defined in Option.

Required Associated Types

type Tuple

Required Methods

fn transpose(self) -> Option<Self::Tuple>

Transposes a tuple of Options into an Option of tuples. This function returns None if any of the Option is None.

let left = (Some("foo"), Some(123));
assert_eq!(left.transpose(), Some(("foo", 123)));

Provided Methods

fn map<U, F: FnOnce(Self::Tuple) -> U>(self, f: F) -> Option<U>

See Option::map.

Examples

let tuples = (Some("foo"), Some("bar"));
assert_eq!(tuples.map(|(a, b)| format!("{}{}", a, b)).unwrap(), "foobar");

fn expect(self, msg: &str) -> Self::Tuple

See Option::expect.

Examples

let tuples = (Some("foo"), Some(123));
assert_eq!(tuples.expect("should not panic"), ("foo", 123));

let tuples: (_, Option<i32>) = (Some("foo"), None);
tuples.expect("will panic");

fn unwrap(self) -> Self::Tuple

See Option::unwrap.

let tuples = (Some("foo"), Some(123));
assert_eq!(tuples.unwrap(), ("foo", 123));

This example will panic:

let tuples: (_, Option<i32>) = (Some("foo"), None);
tuples.unwrap();

fn and(self, optb: Option<Self::Tuple>) -> Option<Self::Tuple>

See Option::and.

let left = (Some("foo"), Some(123));
let right = Some(("bar", 456));
assert_eq!(left.and(right), right);

let left_none = (None, Some(123));
assert_eq!(left_none.and(right), None);

fn and_then<U, F: FnOnce(Self::Tuple) -> Option<U>>(self, f: F) -> Option<U>

See Option::and_then.

let tuples = (Some("foobar"), Some(123));
assert_eq!(tuples.and_then(|(a, b)| Some(a.len() + b)), Some(129));

assert_eq!(tuples.and_then(|(a, b)| if b % 2 != 1 { Some(b) } else { None }), None);

fn filter<P: FnOnce(&Self::Tuple) -> bool>( self, predicate: P, ) -> Option<Self::Tuple>

See Option::filter.

let tuples = (Some("foobar"), Some(123));
assert_eq!(tuples.filter(|(a, b)| b % 2 == 1), Some(("foobar", 123)));
assert_eq!(tuples.filter(|(a, b)| b % 2 != 1), None);

fn or(self, optb: Option<Self::Tuple>) -> Option<Self::Tuple>

See Option::or.

let left = (Some("foo"), Some(123));
let right = Some(("bar", 456));
assert_eq!(left.or(right), left.transpose());

let left_none = (None, Some(123));
assert_eq!(left_none.or(right), right);

fn or_else<F: FnOnce() -> Option<Self::Tuple>>( self, f: F, ) -> Option<Self::Tuple>

See Option::or_else.

let left = (Some("foo"), Some(123));
let right = Some(("bar", 456));
assert_eq!(left.or_else(|| right), left.transpose());
assert_eq!((None, Some(456)).or_else(|| right), right);

fn xor(self, optb: Option<Self::Tuple>) -> Option<Self::Tuple>

See Option::xor.

let left = (Some("foo"), Some(123));
let right = Some(("bar", 456));
assert_eq!(left.xor(None), left.transpose());
assert_eq!(None.xor(left.transpose()), left.transpose());
assert_eq!(left.xor(right), None);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>, Option<T4>, Option<T5>, Option<T6>, Option<T7>, Option<T8>, Option<T9>, Option<T10>)

type Tuple = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>, Option<T4>, Option<T5>, Option<T6>, Option<T7>, Option<T8>, Option<T9>)

type Tuple = (T1, T2, T3, T4, T5, T6, T7, T8, T9)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2, T3, T4, T5, T6, T7, T8> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>, Option<T4>, Option<T5>, Option<T6>, Option<T7>, Option<T8>)

type Tuple = (T1, T2, T3, T4, T5, T6, T7, T8)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2, T3, T4, T5, T6, T7> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>, Option<T4>, Option<T5>, Option<T6>, Option<T7>)

type Tuple = (T1, T2, T3, T4, T5, T6, T7)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2, T3, T4, T5, T6> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>, Option<T4>, Option<T5>, Option<T6>)

type Tuple = (T1, T2, T3, T4, T5, T6)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2, T3, T4, T5> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>, Option<T4>, Option<T5>)

type Tuple = (T1, T2, T3, T4, T5)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2, T3, T4> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>, Option<T4>)

type Tuple = (T1, T2, T3, T4)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2, T3> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>)

type Tuple = (T1, T2, T3)

fn transpose(self) -> Option<Self::Tuple>

impl<T1, T2> TupleCombinator for (Option<T1>, Option<T2>)

type Tuple = (T1, T2)

fn transpose(self) -> Option<Self::Tuple>

impl<T1> TupleCombinator for (Option<T1>,)

type Tuple = (T1,)

fn transpose(self) -> Option<Self::Tuple>

Implementors