相关疑难解决方法(0)

只要我们有一个PartialFunction[X,R]很容易将它转换为返回的函数Option[R],例如

def pfToOptf[X, R](f: PartialFunction[X,R])(x: X) =
    if (f.isDefinedAt(x)) Some(f(x))
    else None

但是,如果任务相反,那该怎么办:假设我有一个函数作为参数f获取X并返回Option[R]结果.我想做出一个PartialFunction[X,R].什么是最好的方法？

我想出来的东西看起来很丑陋我的口味:

def optfToPf[X,R](f: X => Option[R]) : PartialFunction[X,R] = {
    object extractor {
        def unapply(x: X): Option[R] = f(x)
    }

    { case extractor(r) => r }
}

我错过了一些更好的方法吗？

PartialFunction的lift方法将PartialFunction转换为Function返回Option结果.

是否有相反的操作,将a Function1[A, Option[B]]变为PartialFunction[A, B]？

这是我一段时间都想知道的事情.我看到这种模式很多:

if (pf.isDefinedAt(in)) pf(in)

通过将其分解为两个单独的调用,在#isDefinedAt中计算的所有模式也将在#apply中进行评估.例如:

object Ex1 {
  def unapply(in: Int) : Option[String] = {
    println("Ex1")
    if (in == 1) Some("1") else None
  }
}

object Ex2 {
  def unapply(in: Int) : Option[String] = {
    println("Ex2")
    if (in == 2) Some("2") else None
  }
}

val pf : PartialFunction[Int,String] = {
  case Ex1(result) => result
  case Ex2(result) => result
}

val in = 2

if (pf.isDefinedAt(in)) pf(in)

哪个打印

Ex1
Ex2
Ex1
Ex2
res52: Any = 2

在最坏的情况下,您的模式最后匹配,在调用PartialFunction时,您已经两次评估了模式/提取器.当匹配不仅仅是简单的类或列表模式匹配的自定义提取器时,这可能会变得低效(例如,如果您有一个解析XML文档并返回一些值对象的提取器)

PartialFunction#lift遭受同样的双重评估:

scala> pf.lift(2) …

很有可能要知道函数是否在某个时刻定义,计算其价值的重要部分必须完成.在PartialFunction,在实现时isDefined和apply,这两种方法将不得不这样做.怎么办这个常见的工作成本很高？

有可能缓存其结果,希望在isDefined之后调用apply.绝对丑陋.

我经常希望那PartialFunction[A,B]是Function[A, Option[B]],这显然是同构的.或许,可能还有另一种方法PartialFunction,比方说applyOption(a: A): Option[B].对于一些mixins,实现者可以选择实现isDefined和apply或applyOption.或者所有这些都是安全的,性能明智.isDefined在呼叫申请之前进行测试的客户将被鼓励使用applyOption.

但事实并非如此.库中的一些主要方法,其中包括collect集合中的一些PartialFunction.是否有一种干净(或不那么干净)的方式来避免支付isDefined和apply之间重复的计算？

另外,applyOption(a: A): Option[B]方法合理吗？在未来的版本中添加它听起来可行吗？它值得吗？

我偶尔会遇到以下模式,我基本上有一个PartialFunction[SomeType,AnotherType],并希望将其视为一个Function[SomeType,Option[AnotherType],例如:

def f(s:SomeType):Option[AnotherType] = s match {
  case s1:SubType1 => Some(AnotherType(s1.whatever))
  case s2:SubType2 => Some(AnotherType(s2.whatever))
  case _ => None
}

有没有办法以避免默认情况并将结果包装在Some定义位置的方式编写上述函数？到目前为止我提出的最好的是:

def f(s:SomeType):Option[AnotherType] = pf.lift(s)
def pf:PartialFunction[SomeType,AnotherType] = {
  case s1:SubType1 => AnotherType(s1.whatever)
  case s2:SubType2 => AnotherType(s2.whatever)
}

有没有办法在没有定义中间函数的情况下做到这一点？我已经尝试了以下几行,但还没有任何东西可以编译:

def f:Function[SomeType,Option[AnotherType]] = {
  case s1:SubType1 => AnotherType(s1.whatever)
  case s2:SubType2 => AnotherType(s2.whatever)
}.lift