Collect results of multiple partial functions at single value?

Question

Suppose I have some partial functions that may have overlapping domains:

val funcs: Seq[PartialFunction[Any, Int]] = Vector(
{ case i: Int if i % 2 == 0 => i*2 }
,
{ case i: Int if i % 2 == 1 => i*3 }
,
{ case i: Int if i % 6 == 0 => i*5 }
)

I want to apply them to a value and collect the results for any that are defined at that val. I thought there would be an elegant way to use collect for this but the best I've been able to do is

val num = 66
funcs.collect { case func if func.isDefinedAt(num) => func(num) }
// or 
funcs.filter(_.isDefinedAt(num)).map(_(num))

This doesn't seem clean. Is there some way to use the builtin case mechanism to test definedness and evaluate at the same time, maybe by currying them against the test value or something like that?

Answer 1

Partial functions have a lift method that is Some(res) if the PF is defined and None if not defined. Also with the use of flatMap we can essentially ignore the Nones and grab only the Some values.

funcs.flatMap { func => func.lift(num) }

Or compressed if you enjoy that sort of stuff:

funcs.flatMap(_.lift(num))

Answer 2

to test definedness and evaluate at the same time

That is applyOrElse. It's used by collect and lift to avoid the double-evaluation.

This recursive version says, Apply the next function and use it to build the result, or else just continue and build the rest of the result.

def f(ff: List[PartialFunction[Any, Int]]): List[Int] = ff match {
  case hd :: tail => hd.applyOrElse(num, (_: Any) => return f(tail)) :: f(tail)
  case _ => Nil
}

It's the first time I've ever used return in Scala. I had to look it up in the index.

This manual construction avoids some object creation in Lifted, the Option and adapting the Option.

scala> :pa
// Entering paste mode (ctrl-D to finish)

val funcs: Seq[PartialFunction[Any, Int]] = Vector(
{ case i: Int if i % 2 == 0 => i*2 }
,
{ case i: Int if i % 2 == 1 => i*3 }
,
{ case i: Int if i % 6 == 0 => i*5 }
)
val num = 66

def f(ff: List[PartialFunction[Any, Int]]): List[Int] = ff match {
  case hd :: tail => hd.applyOrElse(num, (_: Any) => return f(tail)) :: f(tail)
  case _ => Nil
}

// Exiting paste mode, now interpreting.

funcs: Seq[PartialFunction[Any,Int]] = Vector(<function1>, <function1>, <function1>)
num: Int = 66
f: (ff: List[PartialFunction[Any,Int]])List[Int]

scala> f(funcs.toList)
res0: List[Int] = List(132, 330)

scala> funcs flatMap (_ lift num)
res1: Seq[Int] = Vector(132, 330)

The second version just uses a flag for the same idea.

scala> :pa
// Entering paste mode (ctrl-D to finish)

def f(ff: List[PartialFunction[Any, Int]]): List[Int] = ff match {
  case hd :: tail =>
    var ok = true
    val x  = hd.applyOrElse(num, (_: Any) => { ok = false ; 0 })
    if (ok) x :: f(tail) else f(tail)
  case _ => Nil
}

// Exiting paste mode, now interpreting.

f: (ff: List[PartialFunction[Any,Int]])List[Int]

scala> f(funcs.toList)
res2: List[Int] = List(132, 330)