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", so this trait is not object safe.

Implementations on Foreign Types

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

type Tuple = (T1,)

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, T2, T3> TupleCombinator for (Option<T1>, Option<T2>, Option<T3>)

type Tuple = (T1, T2, T3)

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, 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, 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, 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, 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, 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, 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>

Implementors