Trait tuple_map::TupleMap2 [−] [src]

pub trait TupleMap2 {
    type Item;
    fn all<F>(self, f: F) -> bool
    where
        F: FnMut(Self::Item) -> bool;

    fn any<F>(self, f: F) -> bool
    where
        F: FnMut(Self::Item) -> bool;

    fn by_ref(&self) -> (&Self::Item, &Self::Item);

    fn by_ref_mut(&mut self) -> (&mut Self::Item, &mut Self::Item);

    fn find<F>(self, f: F) -> Option<Self::Item>
    where
        F: FnMut(&Self::Item) -> bool;

    fn fold<B, F>(self, init: B, f: F) -> B
    where
        F: FnMut(B, Self::Item) -> B;

    fn for_each<F>(self, f: F)
    where
        F: FnMut(Self::Item);

    fn id(self) -> (Self::Item, Self::Item);

    fn into_vec(self) -> Vec<Self::Item>;

    fn map<B, F>(self, f: F) -> (B, B)
    where
        F: FnMut(Self::Item) -> B;

    fn nth(self, i: usize) -> Option<Self::Item>;

    fn same(self) -> bool
    where
        Self::Item: PartialEq;

    fn same_as(self, i: Self::Item) -> bool
    where
        Self::Item: PartialEq;

    fn sum(self) -> Self::Item
    where
        Self::Item: AddAssign;

    fn product(self) -> Self::Item
    where
        Self::Item: MulAssign;

    fn zip<U, B>(self, other: U) -> ((Self::Item, B), (Self::Item, B))
    where
        U: TupleMap2<Item = B>;

    fn zipf<U, I, F, B>(self, other: U, f: F) -> (B, B)
    where
        U: TupleMap2<Item = I>,
        F: FnMut(Self::Item, I) -> B;

    fn cloned(&self) -> (Self::Item, Self::Item)
    where
        Self::Item: Clone,
    { ... }

    fn add<U, I, B>(self, other: U) -> (B, B)
    where
        U: TupleMap2<Item = I>,
        Self::Item: Add<I, Output = B>,
        Self: Sized,
    { ... }

    fn sub<U, I, B>(self, other: U) -> (B, B)
    where
        U: TupleMap2<Item = I>,
        Self::Item: Sub<I, Output = B>,
        Self: Sized,
    { ... }

    fn mul<U, I, B>(self, other: U) -> (B, B)
    where
        U: TupleMap2<Item = I>,
        Self::Item: Mul<I, Output = B>,
        Self: Sized,
    { ... }

    fn div<U, I, B>(self, other: U) -> (B, B)
    where
        U: TupleMap2<Item = I>,
        Self::Item: Div<I, Output = B>,
        Self: Sized,
    { ... }
}

Associated Types

Required Methods

Checks if every element of tuple matches a predicate, like std::iter::Iterator::all.

This method take a closure returns true or false, and tries to apply this closure to all elements of tuple. If and only if all of them returns true, this method return true.

Examples

ⓘThis example is not tested
let a = (3, 9, 12, ...);
assert!(a.all(|x| x % 3 == 0));
assert!(!a.all(|x| x % 4 == 0));

Checks if any element of tuple matches a predicate, like std::iter::Iterator::any.

This method take a closure returns true or false, and tries to apply this closure to all elements of tuple. If any of them returns true, this method return true.

Examples

ⓘThis example is not tested
let a = (3, 9, 12, ...);
assert!(a.any(|x| x % 4 == 0));
assert!(!a.any(|x| x % 7 == 0));

Takes &(a, a, a, ...) and returns (&a, &a, &a, ...)

Examples

ⓘThis example is not tested
let a = (3, 3, 3, ...);
assert_eq!(a.by_ref(), (&3, &3, &3, ...));

Takes &mut (a, a, a, ...) and returns (&mut a, &mut a, &mut a, ...)

Examples

ⓘThis example is not tested
let a = (3, 3, 3, ...);
assert_eq!(a.by_ref(), (&mut 3, &mut 3, &mut 3, ...));

Find the leftest element which satisfies f and returns it.

Example

ⓘThis example is not tested
let mut a = (3, 3, 5, 3, ...);
if let Some(x) = a.by_ref_mut().find(|&&mut x| x == 5) {
    *x = 3
}
assert!(a.same());

Takes a closure f and applies it to all elements to tuple, and produce single value. This is similar to std::iter::Iterator::fold

Example

ⓘThis example is not tested
let a = (3, 4, 5, ...)
let sum = a.fold(0, |sum, x| sum + x);

Takes a closure f and applies it to all elements to tuple. f can cause side effect(because it's FnMut), but this method return nothing. Similar to std::iter::Iterator::for_each

Example

ⓘThis example is not tested
let a = (3, 4, 5, ...);
let mut sum = 0;
a.for_each(|x| sum += x);

return Self. It's not intended to used by user.

Convert tuple into Vec.

Example

ⓘThis example is not tested
let a = (3, 4, 5, ...)
assert_eq(a.into_vec(), vec![3, 4, 5, ...])

Takes a closure f and (a, a, a, ...), then returns (f(a), f(a), f(a), ...). Similar to std::iter::Iterator::map.

Example

ⓘThis example is not tested
let a = (3, 4, 5, ...);
assert_eq!(a.map(|x| x * 2), (6, 8, 10, ...));

return nth element in the tuple.

Example

ⓘThis example is not tested
let a = (3, 4, 5, ..);
assert_eq!(a.nth(2), Some(5));

Checks if all elements of the tuple is same.

Example

ⓘThis example is not tested
let a = (3, 3, 3, ...);
assert!(a.same());

Takes i and checks if all elements of the tuple is same as i.

Example

ⓘThis example is not tested
let a = (3, 3, 3, ...);
assert!(a.same_as(3));

Takes (a, b, c, ...) then returns a + b + c ...

Takes (a, b, c, ...) then returns a + b + c ...

Takes (a, a, a, ...) and (b, b, b, ...) then returns ((a, b), (a, b), (a, b), ...)

Example

ⓘThis example is not tested
let a = (3, 4, 5, ...);
let b = ('a', 'b', 'c', ...);
assert_eq!(a.zip(b), ((3, 'a'), (4, 'b'), (5, 'c'), ...));

Takes (a, a, a, ...) and (b, b, b, ...) and closure f, then returns (f(a, b), f(a, b), f(a, b), ...)

Example

ⓘThis example is not tested
let a = (3, 4, 5, ...);
let b = ('a', 'b', 'c', ...);
assert_eq!(
    a.zipf(b, |x, y| format!("{}{}", x, y)),
    ("3a", "4b", "5c", ...).map(|x| x.to_owned())
);

Provided Methods

Takes &(a, a, a, ...) and returns (a, a, a, ...)

Examples

ⓘThis example is not tested
let a = (3, 3, 3, ..,);
assert_eq!(a, a.clone());

Takes (a, a, a, ...) and (b, b, b, ...), then returns (a + b, a + b, a + b, ...)

Example

ⓘThis example is not tested
let a = (3, 4, 5, ...);
let b = (7, 8, 9, ....)
assert_eq!(a.add(b), (10, 12, 14, ...));

Takes (a, a, a, ...) and (b, b, b, ...), then returns (a - b, a - b, a - b, ...)

Example

ⓘThis example is not tested
let a = (7, 8, 9, ....);
let b = (3, 4, 5, ....);
assert!(a.sub(b).same());

Takes (a, a, a, ...) and (b, b, b, ...), then returns (a * b, a * b, a * b, ...)

Example

ⓘThis example is not tested
let a = (7, 8, 9, ....);
let b = (3, 4, 5, ....);
assert_eq!(a.mul(b), (21, 32, 45, ...));

Takes (a, a, a, ...) and (b, b, b, ...), then returns (a * b, a * b, a * b, ...)

Example

ⓘThis example is not tested
let a = (6, 8, 10, ....);
let b = (3, 4, 5, ....);
assert!(a.div(b).same());

Implementations on Foreign Types

impl<T> TupleMap2 for (T, T)
[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

[src]

Implementors