编写分部函数

Question

我有两个PartialFunction f和g。它们没有副作用，而且执行起来很快。将它们组合成另一个偏函数h的最佳方法是什么h.isDefinedAt(x)是否等于f.isDefinedAt(x) && g.isDefinedAt(f(x))？

如果h是返回Option的函数，而不是部分函数，也可以。

我很失望f andThen g没有做我想做的事：

scala> val f = Map("a"->1, "b"->2)
f: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)
scala> val g = Map(1->'c', 3->'d')
g: scala.collection.immutable.Map[Int,Char] = Map(1 -> c, 3 -> d)
scala> (f andThen g).isDefinedAt("b")
res3: Boolean = true
scala> (f andThen g).lift("b")
java.util.NoSuchElementException: key not found: 2
    at scala.collection.MapLike$class.default(MapLike.scala:228)

Answer 1

这里有一个比链接问题更短的方法，取自这个线程：

  val f = Map("a" -> 1, "b" -> 2)                 
  val g = Map(1 -> 'c', 3 -> 'd')                 
  def andThenPartial[A, B, C](pf1: PartialFunction[A, B], pf2: PartialFunction[B, C]): PartialFunction[A, C] = {
    Function.unlift(pf1.lift(_) flatMap pf2.lift)
  }                                               
  val h = andThenPartial(f, g)            //> h  : PartialFunction[String,Char]
  h.isDefinedAt("a")                      //> res2: Boolean = true
  h.isDefinedAt("b")                      //> res3: Boolean = false
  h.lift("a")                             //> res4: Option[Char] = Some(c)
  h.lift("b")                             //> res5: Option[Char] = None

当然，这也可以封装为一个隐式类：

  implicit class ComposePartial[A, B](pf: PartialFunction[A, B]) {
    def andThenPartial[C](that: PartialFunction[B, C]): PartialFunction[A, C] =
      Function.unlift(pf.lift(_) flatMap that.lift)
  }
  val h2 = f andThenPartial g         //> h2  : PartialFunction[String,Char]
  h2.isDefinedAt("a")                 //> res6: Boolean = true
  h2.isDefinedAt("b")                 //> res7: Boolean = false
  h2.lift("a")                        //> res8: Option[Char] = Some(c)
  h2.lift("b")                        //> res9: Option[Char] = None

Answer 2

val h = f.mapValues(g)

但这只适用于地图。我认为对于任何类型的分部函数来说，没有一种简单的方法可以做到这一点，您只需要手动创建一个新的PartialFunction对象。

编辑：我看到我上面的代码不是你想要的。但也许这是更好的

val h = f.collect { case (k, v) if(g.contains(v)) => (k, g(v)) }