[−][src]Trait tuple_combinator::TupleCombinator

pub trait TupleCombinator: Sized {
    type Tuple;
    fn transpose(self) -> Option<Self::Tuple>;

    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.

Associated Types

type Tuple

Loading content...

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)));
Loading content...

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);
Loading content...

Implementations on Foreign Types

impl<T1> TupleCombinator for (Option<T1>,)[src]

type Tuple = (T1,)

impl<T1, T2> TupleCombinator for (Option<T1>, Option<T2>)[src]

type Tuple = (T1, T2)

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

type Tuple = (T1, T2, T3)

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

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

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

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

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

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

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

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

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>)[src]

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

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>)[src]

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

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>)[src]

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

Loading content...

Implementors

Loading content...