Compose partial functions

Question

I have two PartialFunctions f and g. They have no side effects and are quick to execute. What's the best way to compose them into another partial function h such that h.isDefinedAt(x) iff f.isDefinedAt(x) && g.isDefinedAt(f(x))?

It's also OK if h is a function returning an Option rather than a partial function.

I'm disappointed that f andThen g does not do what I want:

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)

possible duplicate of [Chaining PartialFunctions with andThen in Scala](http://stackoverflow.com/questions/21041626/chaining-partialfunctions-with-andthen-in-scala) — DNA, Apr 12 '14 at 00:37
I saw the above question, but I'm hoping there's a more elegant way than a 10 LOC implicit class — tba, Apr 12 '14 at 00:39

DNA · Accepted Answer · 2014-04-12T10:32:24.000

Here's a shorter way than the linked question, taken from this thread:

  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

This can also be wrapped up as an implicit class, of course:

  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

Tesseract · Answer 2 · 2014-04-12T00:48:49.283

-5

val h = f.mapValues(g)

But that only works for maps. I don't think there is a short way of doing that for any kind of partial function, you'll just have to create a new PartialFunction object manually.

edit: I see my above code is not what you wanted. But maybe this is better

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

edited Apr 12 '14 at 00:48

answered Apr 12 '14 at 00:36

Tesseract

8,049
2
20
37

In the question, f and g are partial functions that must be composed. Particularly, he wonders why (f andThen g) is defined for b, but gives and error when executed. Take a look at: http://twitter.github.io/scala_school/pattern-matching-and-functional-composition.html – Vinicius Miana Apr 16 '14 at 06:40

Compose partial functions

2 Answers2

Linked