Chaining partial functions with match statements - scala

Question

I am trying to factor out common behaviour from long pattern matching statements to DRY my code out. The idea is to chain the common code in partial functions and have that evaluated by the match statement. My ideal is something like
type pf = PartialFunction[Int, String]
// Our common behaviour
val common: pf = {
case 0 ⇒ "zero"
case 1 ⇒ "one"
}
val a = 2
// speculative match statement with extended behaviour
val b = a match (common orElse {
case 2 ⇒ "two"
case 3 ⇒ "three"
case _ ⇒ "None"
})
Unfortunately, the argument to the match statement is apparently not a partial function. Obviously, the problem can be solved using partial functions, the code below doing the trick but I lose out on the conventional pattern match syntax:
val c: String = (common orElse {
case 2 ⇒ "two"
case 3 ⇒ "three"
case _ ⇒ "None"
}: pf)(a)
The example below is on the ugly side of what I am looking for. It compiles but fails with a scala.MatchError if the argument a is not defined in the common partial function.
val d = common(a) orElse (a match {
case 2 ⇒ "two"
case 3 ⇒ "three"
case _ ⇒ "None"
})
I am looking for the following answers:
Why is the argument to the match statement not translated into partial function?
Why does the ugly example above fail?
Is there a clever way to achieve the goal?

Answer 1

Match has not been generalized as for catch, most recently here:
https://github.com/scala/scala/pull/4334
where you can supply a partial function to a catch.
The catch is easy in that it must be a PartialFunction[Throwable, ?], but it's not obvious to me that pattern matches generalize in the same way. At issue are exhaustiveness checks, the expected type of the scrutinee, who knows what.

Answer 2

What's wrong with this...?
type Pfis = PartialFunction[Int, String]
val common: Pfis = {
case 0 ⇒ "zero"
case 1 ⇒ "one"
}
val a = 2
val other: Pfis = {
case 2 ⇒ "two"
case 3 ⇒ "three"
case _ ⇒ "None"
}
val b = ( common orElse other )( a )
// If you feel like using the "conventional match-case"
val f = common orElse other
val c = a match { case x => f( x ) }
Also, there is no such thing as conventional pattern matching syntax... match is a keyword which "can be thought to act" as a right-associative function which means that a match pf is very much same ( not really same... a match pf does not work) as pf.apply( a ) or just pf( a ).
Also, orElse is a used for functional-composition so basically, you compose a new partial-function by orElseing two partitial-functions. Then you call this new parital-function, the same way as you would use any partial-function.
I think, if you understand what orElse does... you will understand the answer to your second point. Well, it fails because you are applying the partial-function common for argument 2 and it is not defined at 2.
Also, one more thing... even if common was defined at a, you are doing something very wrong. Let me explain,
val t = 1
val d = common( t ) orElse ( t match {
case 2 ⇒ "two"
case 3 ⇒ "three"
case _ ⇒ "None"
})
// Now d is same as following,
val k = "one" orElse "None"
// Here, k and d both are actually PartialFunction[Int,Char] = <function1>
// basically, both k and d take an Int i as argument and return the ( character at index i in "one" ) orElse ( character at index i in "None" )
// So,
println( d( 2 ) )
// Will print - e
println( d( 3 ) )
// since "one" does not have index 3, it will return index 3 in "None"
// will print - e
println( d( 4 ) )
// None of "one" and "None" have index 4
// So, you will get - scala.MatchError: 4 (of class java.lang.Integer)