"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; } } }