"Compares corresponding elements of the given streams using 
 the given [[binary predicate function|comparing]]. Two 
 elements are considered _corresponding_ if they occupy the
 same position in their respective streams. Returns `true` 
 if and only if:
 
 - the two streams have the same number of elements, and 
 - if the predicate is satisfied for every pair of 
   corresponding elements.
 
 Returns `false` otherwise. If both streams are empty, 
 return `true`.
 
 For example:
 
     corresponding({ 1, 2, 3, 4 }, 1:4)
 
 and:
 
     corresponding({ 1, 2, 3, 4 }, \"1234\", 
            (Integer i, Character c) => i.string==c.string)
 
 both evaluate to `true`."​
​see (`function everyPair`, 
     `function compareCorresponding`)
​tagged("Comparisons", "Streams")
​since("1.1.0")
​shared Boolean corresponding<First,Second>(
    {First*} firstIterable, {Second*} secondIterable,
    "The predicate function that compares an element of the
     [[first stream|firstIterable]] with the corresponding 
     element of the [[second stream|secondIterable]].
     
     By default, the elements are compared by a predicate
     function that returns `true` if and only if the 
     elements are [[equal|Object.equals]] or both `null`."​
    Boolean comparing(First first, Second second)
            => if (exists first, exists second) 
                    then first==second​
                    else !first exists && 
                         !second exists) {
    value firstIter = firstIterable.iterator();
    value secondIter = secondIterable.iterator();
    while (true) {
        value first = firstIter.next();
        value second = secondIter.next();
        if (!is Finished first, !is Finished second) {
            if (!comparing(first, second)) {
                return false;
            }
        }
        else {
            return first is Finished && second is Finished;
        }
    }
}
​
"Compares corresponding elements of the given streams using 
 the given [[comparison function|comparing]]. Two elements 
 are considered _corresponding_ if they occupy the same 
 position in their respective streams. Returns:
 
 - the result of the given comparison for the earliest pair
   of corresponding elements whose comparison does not 
   evaluate to [[equal]], or, otherwise, if every comparison 
   of corresponding pairs of elements produces `equal`,
 - [[smaller]], if the first stream produces fewer elements 
   than the second stream, 
 - [[larger]], if the first stream produces more elements 
   than the second stream, or
 - [[equal]] if the two streams produce the same number of 
   elements.
 
 If both streams are empty, return `equal`.
 
 For example:
 
     compareCorresponding({ 1, 2, 2, 5 }, 1:4,
            (Integer i, Integer j) => i<=>j)
 
 and:
 
     compareCorresponding({ 1, 2, 3 }, 1:4,
            (Integer i, Integer j) => i<=>j)
 
 both evaluate to `smaller`."​
​see (`function corresponding`)
​tagged("Comparisons", "Streams")
​since("1.3.0")
​shared Comparison compareCorresponding<First,Second>(
    {First*} firstIterable, {Second*} secondIterable,
    "The comparison function that compares an element of the
     [[first stream|firstIterable]] with the corresponding 
     element of the [[second stream|secondIterable]]."​
    Comparison comparing(First first, Second second)) {
    value firstIter = firstIterable.iterator();
    value secondIter = secondIterable.iterator();
    while (true) {
        value first = firstIter.next();
        value second = secondIter.next();
        if (!is Finished first, !is Finished second) {
            value comp = comparing(first, second);
            if (comp!=equal) {
                return comp;
            }
        }
        else {
            value firstFinished = first is Finished;
            value secondFinished = second is Finished;
            return if (firstFinished && !secondFinished) 
                    then smaller​
              else if (!firstFinished && secondFinished) 
                    then larger​
              else equal;
        }
    }
}
​
​