您可以使用cats.Eval使昂贵的计算变得懒惰和可记忆，使用.map创建Eval，并在.collect中提取.value（如果需要，最多计算一次

values.map { value =>
  val expensiveCheck1 = Eval.later { prettyExpensiveFunc(value) }
  val expensiveCheck2 = Eval.later { anotherExpensiveFunc(value) }
  (value, expensiveCheck1, expensiveCheck2)
}.collect {
  case (value, lazyResult1, _) if lazyResult1.value > 0 => ...
  case (value, _, lazyResult2) if lazyResult2.value > 0 => ...
  case (value, lazyResult1, lazyResult2) if lazyResult1.value > lazyResult2.value => ...
  ...
}

如果不创建一些惰性评估的实现，我看不到一种方法来做你想做的事情，如果你必须使用一个，你最好使用现有的一个，而不是自己滚动一个。
如果你还没有注意到的话，编辑一下，你并没有因为在这里使用元组而失去模式匹配的能力：

values.map {
  // originial value -> lazily evaluated memoized expensive calculation
  case a @ Some(Right((x, y)) => a -> Some(Eval.later(prettyExpensiveFunc(x, y)))
  case a                      => a -> None
}.collect {
  // match type and calculation
  ...
  case (Some(Right((x, y))), Some(lazyResult)) if lazyResult.value > 0 => ...
  ...
}

为什么不先对每个元素运行这个函数，然后再处理元组呢？

Seq(1,2,3,4,5).map(e => (e, prettyExpensiveFunc(e))).collect {
  case ...
  case (x, y) if y => y
}

我尝试了自己的匹配器和效果是某种程度上可以，但不完美。我的matcher是untyped的，要使它完全类型化有点难看。

class Matcher[T,E](f:PartialFunction[T, E]) {
  def unapply(z: T): Option[E] = if (f.isDefinedAt(z)) Some(f(z)) else None
}

def newMatcherAny[E](f:PartialFunction[Any, E]) = new Matcher(f)
def newMatcher[T,E](f:PartialFunction[T, E]) = new Matcher(f)

def prettyExpensiveFunc(x:Int) = {println(s"-- prettyExpensiveFunc($x)"); x%2+x*x}

val x = Seq(
  Some(Right(22)),
  Some(Right(10)), 
  Some(Left("Oh now")), 
  None
)
val PersonAgeRank = newMatcherAny { case Some(Right(x:Int)) => (x, prettyExpensiveFunc(x)) }

x.collect { 
  case PersonAgeRank(age, rank) if rank > 100 => println("age:"+age + " rank:" + rank) 
}

https://scalafiddle.io/sf/hFbcAqH/3