Trait woah::prelude::Product

pub trait Product<A = Self> {
    fn product<I>(iter: I) -> Self
    where
        I: Iterator<Item = A>;
}

Trait to represent types that can be created by multiplying elements of an iterator.

This trait is used to implement Iterator::product(). Types which implement this trait can be generated by using the product() method on an iterator. Like FromIterator, this trait should rarely be called directly.

Required Methods

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = A>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

Implementations on Foreign Types

impl<'a, const LANES: usize> Product<&'a Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<usize, LANES> where
    I: Iterator<Item = &'a Simd<usize, LANES>>, 

impl<'a> Product<&'a i128> for i128

fn product<I>(iter: I) -> i128 where
    I: Iterator<Item = &'a i128>, 

impl Product<Wrapping<i64>> for Wrapping<i64>

fn product<I>(iter: I) -> Wrapping<i64> where
    I: Iterator<Item = Wrapping<i64>>, 

impl<const LANES: usize> Product<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i16, LANES> where
    I: Iterator<Item = Simd<i16, LANES>>, 

impl Product<Wrapping<i32>> for Wrapping<i32>

fn product<I>(iter: I) -> Wrapping<i32> where
    I: Iterator<Item = Wrapping<i32>>, 

impl<'a> Product<&'a f64> for f64

fn product<I>(iter: I) -> f64 where
    I: Iterator<Item = &'a f64>, 

impl Product<i64> for i64

fn product<I>(iter: I) -> i64 where
    I: Iterator<Item = i64>, 

impl<'a, const LANES: usize> Product<&'a Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i32, LANES> where
    I: Iterator<Item = &'a Simd<i32, LANES>>, 

impl<'a> Product<&'a Wrapping<isize>> for Wrapping<isize>

fn product<I>(iter: I) -> Wrapping<isize> where
    I: Iterator<Item = &'a Wrapping<isize>>, 

impl<const LANES: usize> Product<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<f32, LANES> where
    I: Iterator<Item = Simd<f32, LANES>>, 

impl<'a, const LANES: usize> Product<&'a Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<f32, LANES> where
    I: Iterator<Item = &'a Simd<f32, LANES>>, 

impl<'a> Product<&'a u16> for u16

fn product<I>(iter: I) -> u16 where
    I: Iterator<Item = &'a u16>, 

impl<'a> Product<&'a Wrapping<i64>> for Wrapping<i64>

fn product<I>(iter: I) -> Wrapping<i64> where
    I: Iterator<Item = &'a Wrapping<i64>>, 

impl Product<u16> for u16

fn product<I>(iter: I) -> u16 where
    I: Iterator<Item = u16>, 

impl<'a> Product<&'a u32> for u32

fn product<I>(iter: I) -> u32 where
    I: Iterator<Item = &'a u32>, 

impl<const LANES: usize> Product<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<isize, LANES> where
    I: Iterator<Item = Simd<isize, LANES>>, 

impl<'a> Product<&'a Wrapping<u8>> for Wrapping<u8>

fn product<I>(iter: I) -> Wrapping<u8> where
    I: Iterator<Item = &'a Wrapping<u8>>, 

impl Product<u8> for u8

fn product<I>(iter: I) -> u8 where
    I: Iterator<Item = u8>, 

impl<'a> Product<&'a Wrapping<u32>> for Wrapping<u32>

fn product<I>(iter: I) -> Wrapping<u32> where
    I: Iterator<Item = &'a Wrapping<u32>>, 

impl Product<u32> for u32

fn product<I>(iter: I) -> u32 where
    I: Iterator<Item = u32>, 

impl Product<i16> for i16

fn product<I>(iter: I) -> i16 where
    I: Iterator<Item = i16>, 

impl<'a> Product<&'a i32> for i32

fn product<I>(iter: I) -> i32 where
    I: Iterator<Item = &'a i32>, 

impl<'a> Product<&'a Wrapping<u64>> for Wrapping<u64>

fn product<I>(iter: I) -> Wrapping<u64> where
    I: Iterator<Item = &'a Wrapping<u64>>, 

impl Product<Wrapping<u16>> for Wrapping<u16>

fn product<I>(iter: I) -> Wrapping<u16> where
    I: Iterator<Item = Wrapping<u16>>, 

impl<'a> Product<&'a usize> for usize

fn product<I>(iter: I) -> usize where
    I: Iterator<Item = &'a usize>, 

impl Product<Wrapping<u32>> for Wrapping<u32>

fn product<I>(iter: I) -> Wrapping<u32> where
    I: Iterator<Item = Wrapping<u32>>, 

impl<const LANES: usize> Product<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u32, LANES> where
    I: Iterator<Item = Simd<u32, LANES>>, 

impl<const LANES: usize> Product<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i8, LANES> where
    I: Iterator<Item = Simd<i8, LANES>>, 

impl<'a> Product<&'a u64> for u64

fn product<I>(iter: I) -> u64 where
    I: Iterator<Item = &'a u64>, 

impl<'a> Product<&'a Wrapping<u128>> for Wrapping<u128>

fn product<I>(iter: I) -> Wrapping<u128> where
    I: Iterator<Item = &'a Wrapping<u128>>, 

impl<'a> Product<&'a isize> for isize

fn product<I>(iter: I) -> isize where
    I: Iterator<Item = &'a isize>, 

impl<'a> Product<&'a Wrapping<usize>> for Wrapping<usize>

fn product<I>(iter: I) -> Wrapping<usize> where
    I: Iterator<Item = &'a Wrapping<usize>>, 

impl Product<Wrapping<i16>> for Wrapping<i16>

fn product<I>(iter: I) -> Wrapping<i16> where
    I: Iterator<Item = Wrapping<i16>>, 

impl Product<Wrapping<u64>> for Wrapping<u64>

fn product<I>(iter: I) -> Wrapping<u64> where
    I: Iterator<Item = Wrapping<u64>>, 

impl<const LANES: usize> Product<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u64, LANES> where
    I: Iterator<Item = Simd<u64, LANES>>, 

impl Product<u128> for u128

fn product<I>(iter: I) -> u128 where
    I: Iterator<Item = u128>, 

impl<'a, const LANES: usize> Product<&'a Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u16, LANES> where
    I: Iterator<Item = &'a Simd<u16, LANES>>, 

impl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u8, LANES> where
    I: Iterator<Item = &'a Simd<u8, LANES>>, 

impl<'a, const LANES: usize> Product<&'a Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i64, LANES> where
    I: Iterator<Item = &'a Simd<i64, LANES>>, 

impl Product<u64> for u64

fn product<I>(iter: I) -> u64 where
    I: Iterator<Item = u64>, 

impl<'a, const LANES: usize> Product<&'a Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i16, LANES> where
    I: Iterator<Item = &'a Simd<i16, LANES>>, 

impl<const LANES: usize> Product<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i32, LANES> where
    I: Iterator<Item = Simd<i32, LANES>>, 

impl Product<f64> for f64

fn product<I>(iter: I) -> f64 where
    I: Iterator<Item = f64>, 

impl<const LANES: usize> Product<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u8, LANES> where
    I: Iterator<Item = Simd<u8, LANES>>, 

impl<'a> Product<&'a Wrapping<u16>> for Wrapping<u16>

fn product<I>(iter: I) -> Wrapping<u16> where
    I: Iterator<Item = &'a Wrapping<u16>>, 

impl Product<Wrapping<u8>> for Wrapping<u8>

fn product<I>(iter: I) -> Wrapping<u8> where
    I: Iterator<Item = Wrapping<u8>>, 

impl Product<Wrapping<u128>> for Wrapping<u128>

fn product<I>(iter: I) -> Wrapping<u128> where
    I: Iterator<Item = Wrapping<u128>>, 

impl Product<Wrapping<i128>> for Wrapping<i128>

fn product<I>(iter: I) -> Wrapping<i128> where
    I: Iterator<Item = Wrapping<i128>>, 

impl Product<i128> for i128

fn product<I>(iter: I) -> i128 where
    I: Iterator<Item = i128>, 

impl<'a> Product<&'a i64> for i64

fn product<I>(iter: I) -> i64 where
    I: Iterator<Item = &'a i64>, 

impl<'a> Product<&'a Wrapping<i16>> for Wrapping<i16>

fn product<I>(iter: I) -> Wrapping<i16> where
    I: Iterator<Item = &'a Wrapping<i16>>, 

impl<'a> Product<&'a f32> for f32

fn product<I>(iter: I) -> f32 where
    I: Iterator<Item = &'a f32>, 

impl<'a> Product<&'a u8> for u8

fn product<I>(iter: I) -> u8 where
    I: Iterator<Item = &'a u8>, 

impl Product<f32> for f32

fn product<I>(iter: I) -> f32 where
    I: Iterator<Item = f32>, 

impl<'a> Product<&'a Wrapping<i8>> for Wrapping<i8>

fn product<I>(iter: I) -> Wrapping<i8> where
    I: Iterator<Item = &'a Wrapping<i8>>, 

impl<'a, const LANES: usize> Product<&'a Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i8, LANES> where
    I: Iterator<Item = &'a Simd<i8, LANES>>, 

impl Product<Wrapping<i8>> for Wrapping<i8>

fn product<I>(iter: I) -> Wrapping<i8> where
    I: Iterator<Item = Wrapping<i8>>, 

impl<'a> Product<&'a i8> for i8

fn product<I>(iter: I) -> i8 where
    I: Iterator<Item = &'a i8>, 

impl<'a> Product<&'a Wrapping<i128>> for Wrapping<i128>

fn product<I>(iter: I) -> Wrapping<i128> where
    I: Iterator<Item = &'a Wrapping<i128>>, 

impl<'a, const LANES: usize> Product<&'a Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<f64, LANES> where
    I: Iterator<Item = &'a Simd<f64, LANES>>, 

impl<const LANES: usize> Product<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<usize, LANES> where
    I: Iterator<Item = Simd<usize, LANES>>, 

impl<T, U> Product<Option<U>> for Option<T> where
    T: Product<U>, 

fn product<I>(iter: I) -> Option<T> where
    I: Iterator<Item = Option<U>>, 

Takes each element in the Iterator: if it is a None, no further elements are taken, and the None is returned. Should no None occur, the product of all elements is returned.

impl Product<Wrapping<usize>> for Wrapping<usize>

fn product<I>(iter: I) -> Wrapping<usize> where
    I: Iterator<Item = Wrapping<usize>>, 

impl<'a> Product<&'a u128> for u128

fn product<I>(iter: I) -> u128 where
    I: Iterator<Item = &'a u128>, 

impl Product<i8> for i8

fn product<I>(iter: I) -> i8 where
    I: Iterator<Item = i8>, 

impl Product<i32> for i32

fn product<I>(iter: I) -> i32 where
    I: Iterator<Item = i32>, 

impl Product<Wrapping<isize>> for Wrapping<isize>

fn product<I>(iter: I) -> Wrapping<isize> where
    I: Iterator<Item = Wrapping<isize>>, 

impl<const LANES: usize> Product<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<i64, LANES> where
    I: Iterator<Item = Simd<i64, LANES>>, 

impl<'a, const LANES: usize> Product<&'a Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u32, LANES> where
    I: Iterator<Item = &'a Simd<u32, LANES>>, 

impl<'a> Product<&'a Wrapping<i32>> for Wrapping<i32>

fn product<I>(iter: I) -> Wrapping<i32> where
    I: Iterator<Item = &'a Wrapping<i32>>, 

impl<'a, const LANES: usize> Product<&'a Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u64, LANES> where
    I: Iterator<Item = &'a Simd<u64, LANES>>, 

impl Product<usize> for usize

fn product<I>(iter: I) -> usize where
    I: Iterator<Item = usize>, 

impl<const LANES: usize> Product<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<u16, LANES> where
    I: Iterator<Item = Simd<u16, LANES>>, 

impl<'a, const LANES: usize> Product<&'a Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<isize, LANES> where
    I: Iterator<Item = &'a Simd<isize, LANES>>, 

impl Product<isize> for isize

fn product<I>(iter: I) -> isize where
    I: Iterator<Item = isize>, 

impl<'a> Product<&'a i16> for i16

fn product<I>(iter: I) -> i16 where
    I: Iterator<Item = &'a i16>, 

impl<const LANES: usize> Product<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I>(iter: I) -> Simd<f64, LANES> where
    I: Iterator<Item = Simd<f64, LANES>>, 

Implementors

impl<T, U, E> Product<Result<U, E>> for woah::prelude::StdResult<T, E> where
    T: Product<U>, 

impl<T, U, L, F> Product<Result<U, L, F>> for woah::Result<T, L, F> where
    T: Product<U>,