如何编写“orElse”的懒惰，可变参数版本

Question

是否可以从Option中编写一个广义的orElse方法，该方法需要可变数目的参数？也就是说，不是，：

lazy val o1 = { println("foo"); None } 
lazy val o2 = { println("bar"); Some("bar") } 
lazy val o3 = { println("baz"); Some("baz") } 
// ... 
o1 orElse o2 orElse o3 // orElse ... 

你可以使用：

orElse(o1, o2, o3) //, ... 

Answer 1

按照The Scala Language Specification（4.6函数的声明和定义）不能定义可变参数的名称参数：

ParamType ::= Type 
| ‘=>’ Type 
| Type ‘*’ 

scala> def orElse(x : (=> String)*) 
<console>:1: error: no by-name parameter type allowed here 
     def orElse(x : (=> String)*) 

您可以用函数和隐式类型转换代替惰性arg：

def orElse[T](x : (()=> Option[T])*) : Option[T] = 
    if(x.isEmpty) None else x.first.apply.orElse(orElse((x drop 1) :_*)) 
implicit def anyToFun0[T](t : => T) : (() => T) =() => t 
orElse(o1, o2, o3) 

Answer 2

我发现这个问题有点迟了:)。一种可能性是用辅助函数来包装=> A成一个辅助类一起，以简化其创作：

import scala.language.implicitConversions 

class Helper[+A](value: => A) extends Function0[A] { 
    override def apply(): A = value; 
} 
object Helper { 
    def unapply[A](h: Helper[A]): Option[A] = Some(h()); 
} 
implicit def toHelper[A](body: => A) = new Helper(body); 

不是必需的提取，它只是允许在助手容易匹配。然后，我们可以写

def orElse[A](xs: Helper[Option[A]]*): Option[A] = 
    xs.collectFirst[A]({ 
    case Helper(Some(r)) => r; 
    }) 

lazy val o1 = { println("foo"); None } 
lazy val o2 = { println("bar"); Some("bar") } 
lazy val o3 = { println("baz"); Some("baz") } 

orElse(o1, o2, o3) //, ... 

这仅仅是一个简单的解决方案，更现实的是

def orElse[A](x: Option[A], xs: Helper[Option[A]]*): Option[A] 

与更有效的实现。

---

中已经有Scalaz类似Helper一类，称为Name与实施Need，确保身体被评为最多一次。所以与斯卡拉斯，它可以实现为

import scala.language.implicitConversions 
import scalaz._ 
import scalaz.Scalaz._ 

implicit def toNeed[A](body: => A): Name[A] = Need(body); 

def orElse[A](xs: Name[Option[A]]*): Option[A] = 
    xs.collectFirst[A]({ 
    case Name(Some(r)) => r; 
    }) 

lazy val o1 = { println("foo"); None } 
lazy val o2 = { println("bar"); Some("bar") } 
lazy val o3 = { println("baz"); Some("baz") } 

orElse(o1, o2, o3) //, ...