Можно ли сопоставить шаблон с параметром по имени без его оценки?

Играл с Lazy Structure Stream, как показано ниже

import Stream._

sealed trait Stream[+A] {
    ..
    def toList: List[A] = this match {
        case Empty => Nil
        case Cons(h, t) => println(s"${h()}::t().toList"); h()::t().toList
    }
    def foldRight[B](z: B) (f: ( A, => B) => B) : B = this match {
        case Empty => println(s"foldRight of Empty return $z"); z
        case Cons(h, t) => println(s"f(${h()}, t().foldRight(z)(f))"); f(h(), t().foldRight(z)(f))
    }
    ..
}
case object Empty extends Stream[Nothing]
case class Cons[+A](h: () => A, t: () => Stream[A]) extends Stream[A]

object Stream {

    def cons[A](h: => A, t: => Stream[A]): Stream[A] = {
        lazy val hd = h
        lazy val tl = t
        Cons[A](() => hd, () => tl)
    }

    def empty[A]: Stream[A] = Empty

    def apply[A](la: A*): Stream[A] = la match {
        case list if list.isEmpty => empty[A]
        case _ => cons(la.head, apply(la.tail:_*))
    }

}

Для функции takeWhile через foldRight я изначально написал:

def takeWhileFoldRight_0(p: A => Boolean) : Stream[A] = {
        foldRight(empty[A]) {
                case (a, b) if p(a) => println(s"takeWhileFoldRight cons($a, b) with p(a) returns: cons($a, b)"); cons(a, b)
                case (a, b) if !p(a) => println(s"takeWhileFoldRight cons($a, b) with !p(a) returns: empty[A]"); empty[A]
            }
        }

Который при вызове:

Stream(4,5,6).takeWhileFoldRight_0(_%2 == 0).toList

приводит к следующей трассировке:

f(4, t().foldRight(z)(f))
f(5, t().foldRight(z)(f))
f(6, t().foldRight(z)(f))
foldRight of Empty return Empty
takeWhileFoldRight cons(6, b) with p(a) returns: cons(6, b)
takeWhileFoldRight cons(5, b) with !p(a) returns: empty[A]
takeWhileFoldRight cons(4, b) with p(a) returns: cons(4, b)
4::t().toList
res2: List[Int] = List(4)

Затем задавая вопросы и задавая вопросы, я понял, что, возможно, это был метод неприменения в сопоставлении с образцом, который оценивает с нетерпением.

Поэтому я изменился на

def takeWhileFoldRight(p: A => Boolean) : Stream[A] = {
        foldRight(empty[A]) { (a, b) =>
            if (p(a)) cons(a, b) else empty[A]
        }
    }

который при вызове

Stream(4,5,6).takeWhileFoldRight(_%2 == 0).toList

приводит к следующей трассировке:

f(4, t().foldRight(z)(f))
4::t().toList
f(5, t().foldRight(z)(f))
res1: List[Int] = List(4)

Отсюда мой вопрос:

Есть ли способ восстановить силу сопоставления с образцом при работе с параметром по имени?

Другими словами, случай, когда я сопоставляю параметры по имени, не оценивая их с нетерпением?

Или мне нужно перейти к набору уродливых вложенных if :p в таком сценарии