use super::Iterator;
/// Compare `a` and `b` for equality using `Eq`
- pub fn equals<A, T, S>(mut a: T, mut b: S) -> bool where
+ pub fn equals<A, L, R>(mut a: L, mut b: R) -> bool where
A: Eq,
- T: Iterator<Item=A>,
- S: Iterator<Item=A>,
+ L: Iterator<Item=A>,
+ R: Iterator<Item=A>,
{
loop {
match (a.next(), b.next()) {
}
/// Order `a` and `b` lexicographically using `Ord`
- pub fn cmp<A, T, S>(mut a: T, mut b: S) -> cmp::Ordering where
+ pub fn cmp<A, L, R>(mut a: L, mut b: R) -> cmp::Ordering where
A: Ord,
- T: Iterator<Item=A>,
- S: Iterator<Item=A>,
+ L: Iterator<Item=A>,
+ R: Iterator<Item=A>,
{
loop {
match (a.next(), b.next()) {
}
/// Order `a` and `b` lexicographically using `PartialOrd`
- pub fn partial_cmp<A, T, S>(mut a: T, mut b: S) -> Option<cmp::Ordering> where
- A: PartialOrd,
- T: Iterator<Item=A>,
- S: Iterator<Item=A>,
+ pub fn partial_cmp<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> Option<cmp::Ordering> where
+ L::Item: PartialOrd<R::Item>
{
loop {
match (a.next(), b.next()) {
}
/// Compare `a` and `b` for equality (Using partial equality, `PartialEq`)
- pub fn eq<A, B, L, R>(mut a: L, mut b: R) -> bool where
- A: PartialEq<B>,
- L: Iterator<Item=A>,
- R: Iterator<Item=B>,
+ pub fn eq<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
+ L::Item: PartialEq<R::Item>,
{
loop {
match (a.next(), b.next()) {
}
/// Compare `a` and `b` for nonequality (Using partial equality, `PartialEq`)
- pub fn ne<A, B, L, R>(mut a: L, mut b: R) -> bool where
- A: PartialEq<B>,
- L: Iterator<Item=A>,
- R: Iterator<Item=B>,
+ pub fn ne<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
+ L::Item: PartialEq<R::Item>,
{
loop {
match (a.next(), b.next()) {
}
/// Return `a` < `b` lexicographically (Using partial order, `PartialOrd`)
- pub fn lt<A, T, S>(mut a: T, mut b: S) -> bool where
- A: PartialOrd,
- T: Iterator<Item=A>,
- S: Iterator<Item=A>,
+ pub fn lt<R: Iterator, L: Iterator>(mut a: L, mut b: R) -> bool where
+ L::Item: PartialOrd<R::Item>,
{
loop {
match (a.next(), b.next()) {
}
/// Return `a` <= `b` lexicographically (Using partial order, `PartialOrd`)
- pub fn le<A, T, S>(mut a: T, mut b: S) -> bool where
- A: PartialOrd,
- T: Iterator<Item=A>,
- S: Iterator<Item=A>,
+ pub fn le<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
+ L::Item: PartialOrd<R::Item>,
{
loop {
match (a.next(), b.next()) {
}
/// Return `a` > `b` lexicographically (Using partial order, `PartialOrd`)
- pub fn gt<A, T, S>(mut a: T, mut b: S) -> bool where
- A: PartialOrd,
- T: Iterator<Item=A>,
- S: Iterator<Item=A>,
+ pub fn gt<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
+ L::Item: PartialOrd<R::Item>,
{
loop {
match (a.next(), b.next()) {
}
/// Return `a` >= `b` lexicographically (Using partial order, `PartialOrd`)
- pub fn ge<A, T, S>(mut a: T, mut b: S) -> bool where
- A: PartialOrd,
- T: Iterator<Item=A>,
- S: Iterator<Item=A>,
+ pub fn ge<L: Iterator, R: Iterator>(mut a: L, mut b: R) -> bool where
+ L::Item: PartialOrd<R::Item>,
{
loop {
match (a.next(), b.next()) {