Back2Basics: Understanding Partial Function – #2

In previous blog Understanding Partial Functions – #1, we have talked about what is partial function and how they are different from regular functions. In this blog, we will explore more about the partial function.

We have talked about how we can define partial functions having one argument. But what to do if we have to pass more than one argument.

Let’s try defining divide method which takes two arguments, as a partial function,

scala> val divide: PartialFunction[Double, Double, Double] = {
    | case (dividend, divisor) if divisor != 0 => dividend / divisor
    | }
:11: error: wrong number of type arguments for PartialFunction, should be 2
val divide: PartialFunction[Double, Double, Double] = {
^
:12: error: value / is not a member of Any
case (dividend, divisor) if divisor != 0 => dividend / divisor
^

Compiler blows up. So how to receive more than one arguments? Since the partial function of the type, PartialFunction[A, B] where A is the return type of argument and B is the return type of returned value from partial function. So, we could treat more than one argument as a tuple.

scala> val divide: PartialFunction[(Double, Double), Double] = {
    | case (dividend, divisor) if divisor != 0 => dividend / divisor
    | }
divide: PartialFunction[(Double, Double),Double] = <Function1>

It worked. So we can pass more than one arguments as a tuple to a partial function.

Suppose we have a problem that first evaluates the division of two numbers and then calculate the square root of them. It would be a bigger partial function.  We can use lots of utility methods to create bigger partial functions using smaller partial functions. Let’s see  first create square root as a partial function,

scala> val squareRoot: PartialFunction[Double, Double] = {
    | case x if x > 0 => scala.math.sqrt(x)
    | }
squareRoot: PartialFunction[Double,Double] = <Function1>

We can perform required calculation like:

scala> val temp = divide(50,2)
temp: Double = 25.0

scala> squareRoot(temp)
res2: Double = 5.0

This works but it neither looks expressive nor it is composable. We have methods andThen and compose which can help us composing bigger partial functions using smaller partial functions.

Let’s give it a try,

scala> divide.andThen(squareRoot)(50,2)
res10: Double = 5.0

scala> squareRoot.compose(divide)(50,2)
res11: Double = 5.0

It looks more elegant.  We can make code more expressive, concise and composable using andThen and compose.

What is the difference between them?

andThen:  It first evaluates left and then the right partial function. Second, it returns partial function.

scala> divide.andThen(squareRoot)
res12: PartialFunction[(Double, Double),Double] = <Function1>

compose:  It first evaluates right and then left partial function. Second, it returns a function instead of partial function.

scala> squareRoot.compose(divide)
res13: ((Double, Double)) => Double = scala.Function1$$Lambda$1392/930603925@72bf66c7

Now we will talk about other functions we can use with partial functions i.e applyOrElse, lift functions.

We have seen that when we provide invalid input to square root function, it gives us NaN. So properly handling it, we first query it and then apply the function if input is valid. We can have alternate way to do same thing using applyOrElse instead of apply.

applyOrElse: We are saying if input is in domain, apply it else apply the alternate method. So applyOrElse takes an input and function for else part. Here we are going to return zero for all invalid inputs.

scala> squareRoot.applyOrElse(16.0, (x: Double) => 0.0)
res34: Double = 4.0

scala> squareRoot.applyOrElse(0.0, (x: Double) => 0.0)
res35: Double = 0.0

There is another function lift which lifts up partial function to a regular function. Partial function is applied when value is in domain otherwise it blows up with match error.  We can also do if it is defined give me result otherwise none.

We can do that first checking whether input is defined or not. If it is defined, return value wrapped in Some otherwise None. But we don’t need to write that much code. Instead we can use lift.

scala> squareRoot.lift(16)
res36: Option[Double] = Some(4.0)

scala> squareRoot.lift(0)
res37: Option[Double] = None

So, we saw how we could pass more than one arguments to partial functions. How we could create bigger partial functions from smaller partial functions using andThen and compose. We explored about applyOrElse and lift methods. I hope you enjoyed it while reading.

Feel free to suggest or comment.