我将在下面给出一些提示和实现，因此如果您想自己制定解决方案，可能需要覆盖屏幕。
免责声明：这只是我想到的第一种方法，而且我对 scalaz-stream API 的熟悉程度有点生疏，因此可能有更好的方法来实现此操作，这在某些可怕的情况下可能完全错误方式等。
提示 1
您可以在下一次递归调用中传递它们，而不是尝试“取消消耗”丢失的元素。
提示 2
您可以通过指明最后输掉的一方来避免累积多个失败元素。
提示 3
当我使用 Scalaz 流时，我经常发现首先使用普通集合来勾勒出一个实现更容易。这是列表所需的辅助方法：
/**
* @param p if true, the first of the pair wins
*/
def mergeListsWithHeld[A](p: (A, A) => Boolean)(held: Either[A, A])(
ls: List[A],
rs: List[A]
): List[A] = held match {
// Right is the current winner.
case Left(l) => rs match {
// ...but it's empty.
case Nil => l :: ls
// ...and it's still winning.
case r :: rt if p(r, l) => r :: mergeListsWithHeld(p)(held)(ls, rt)
// ...upset!
case r :: rt => l :: mergeListsWithHeld(p)(Right(r))(ls, rt)
}
// Left is the current winner.
case Right(r) => ls match {
case Nil => r :: rs
case l :: lt if p(l, r) => l :: mergeListsWithHeld(p)(held)(lt, rs)
case l :: lt => r :: mergeListsWithHeld(p)(Left(l))(lt, rs)
}
}
假设我们手头已经有一个失败的元素，但现在我们可以编写我们真正想要使用的方法：
def mergeListsWith[A](p: (A, A) => Boolean)(ls: List[A], rs: List[A]): List[A] =
ls match {
case Nil => rs
case l :: lt => rs match {
case Nil => ls
case r :: rt if p(l, r) => l :: mergeListsWithHeld(p)(Right(r))(lt, rt)
case r :: rt => r :: mergeListsWithHeld(p)(Left(l))(lt, rt)
}
}
然后：
scala> org.scalacheck.Prop.forAll { (ls: List[Int], rs: List[Int]) =>
| mergeListsWith[Int](_ < _)(ls.sorted, rs.sorted) == (ls ++ rs).sorted
| }.check
+ OK, passed 100 tests.
好的，看起来不错。我们可以为列表编写更好的方法，但这个实现与我们需要为 Process 做的形式相匹配。
实施
这里或多或少等同于 scalaz-stream：
import scalaz.{ -\/, \/, \/- }
import scalaz.stream.Process.{ awaitL, awaitR, emit }
import scalaz.stream.{ Process, Tee, tee }
def mergeWithHeld[A](p: (A, A) => Boolean)(held: A \/ A): Tee[A, A, A] =
held.fold(_ => awaitR[A], _ => awaitL[A]).awaitOption.flatMap {
case None =>
emit(held.merge) ++ held.fold(_ => tee.passL, _ => tee.passR)
case Some(next) if p(next, held.merge) =>
emit(next) ++ mergeWithHeld(p)(held)
case Some(next) =>
emit(held.merge) ++ mergeWithHeld(p)(
held.fold(_ => \/-(next), _ => -\/(next))
)
}
def mergeWith[A](p: (A, A) => Boolean): Tee[A, A, A] =
awaitL[A].awaitOption.flatMap {
case None => tee.passR
case Some(l) => awaitR[A].awaitOption.flatMap {
case None => emit(l) ++ tee.passL
case Some(r) if p(l, r) => emit(l) ++ mergeWithHeld(p)(\/-(r))
case Some(r) => emit(r) ++ mergeWithHeld(p)(-\/(l))
}
}
让我们再检查一遍：
scala> org.scalacheck.Prop.forAll { (ls: List[Int], rs: List[Int]) =>
| Process.emitAll(ls.sorted).tee(Process.emitAll(rs.sorted))(
| mergeWith(_ < _)
| ).toList == (ls ++ rs).sorted
| }.check
+ OK, passed 100 tests.
如果不进行更多测试，我不会将其投入生产，但它看起来很有效。