fn zip_eq<X>(self, other: X) -> Zip<Self, X::Iter>
    where
        X: IntoParallelIterator<'a>,
        X::Iter: IndexedParallelIterator<'a>,
    {
        let other = other.into_par_iter();

        assert_eq!(
            self.len_hint(),
            other.len_hint(),
            "Iterators of 'zip_eq' operation must hae the same length!"
        );

        Zip::new(self, other)
    }
/// The same as `Zip`, but requires that both iterators have the same length.
///
/// # Panics
/// Will panic if `self` and `other` are not the same length.
///
/// ```should_panic
/// use asparit::*;
///
/// let one = [1u8];
/// let two = [2u8, 2];
/// let one_iter = one.par_iter();
/// let two_iter = two.par_iter();
///
/// // this will panic
/// let zipped: Vec<(&u8, &u8)> = one_iter.zip_eq(two_iter).collect().exec();
///
/// // we should never get here
/// assert_eq!(1, zipped.len());
/// ```
The same as `Zip`, but requires that both iterators have the same length.
The same as ` Zip ` but requires that both iterators have the same length .
fn zip_eq<X>(self, other: X) -> Zip<Self, X::Iter>
    where
        X: IntoParallelIterator<'a>,
        X::Iter: IndexedParallelIterator<'a>,
    {
        let other = other.into_par_iter();
        assert_eq!(
            self.len_hint(),
            other.len_hint(),
            "Iterators of 'zip_eq' operation must hae the same length!"
        );
        Zip::new(self, other)
    }
fn zip_eq < X > ( self , other : X ) -> Zip < Self , X :: Iter > where X : IntoParallelIterator < ' a > , X :: Iter : IndexedParallelIterator < ' a > , { let other = other . into_par_iter ( ) ; assert_eq ! ( self len_hint ( ) other len_hint ( ) " " ) ; Zip :: new ( self , other ) }
The same as `Zip`, but requires that both iterators have the same length.
The same as ` Zip ` but requires that both iterators have the same length .
self
other
X
self
other
X
panics
Will panic if `self` and `other` are not the same length.

```should_panic
use asparit::*.



this will panic
let zipped: Vec<(&u8, &u8)> = one_iter.zip_eq(two_iter).collect().exec().

we should never get here
assert_eq!(1, zipped.len());
```
Will panic if ` self ` and ` other ` are not the same length . ` ` ` should_panic use asparit :: * . this will panic let zipped : Vec< ( &u8 &u8 ) > = one_iter . zip_eq ( two_iter ) . collect () . exec () . we should never get here assert_eq! ( 1 zipped . len () ) ; ` ` `