### Post Brief Table of Content

###
- Introduction
- What is Partial Function?
- Partial Function General Example
- PartialFunction in Scala API
- Partial Function Examples
- Partial Function Rules
- Partial Function Real-Time Scenarios
- Scala Partial Functions Interview Questions

### Introduction

Before reading this post, please go through my previous Scala posts to learn some Scala Basics. In this post, I'm going to discuss one interesting concept: Scala Partial Functions.

Scala Language has many kinds of functions. Partial Function is one of the types of Functions available in Scala Language. To read about functions basics, please click here:

Scala Language has many kinds of functions. Partial Function is one of the types of Functions available in Scala Language. To read about functions basics, please click here:

**Scala Functions Basics**### What is Partial Function?

If a function does NOT support all argument(s) of it's input(s), then that function is known as a Partial Function. Opposite to Partial Function is Total Function which supports all argument(s) of it's input(s).

Partial Functions are defined only partially, which does not support all possible input(s). It supports only subset of it's input(s).

In Scala, we can use scala.PartialFunction trait to define Partial Functions. We will discuss how to define it with some examples in the coming sections.

In this section, we will take one Real-time Example to explain this Partial Function concept.

I think, everyone did some Mathematics from Schooling days. In Maths, division operation does not support for all inputs. It is NOT defined for denominator = 0. Hence, division is a partial function.

In a/b, if b=0 we will get ArthimeticException

NOTE:-

We have already discussed some useful examples in above sections. However, I want to discuss some real-time scenarios in this section

Partial Functions are defined only partially, which does not support all possible input(s). It supports only subset of it's input(s).

In Scala, we can use scala.PartialFunction trait to define Partial Functions. We will discuss how to define it with some examples in the coming sections.

### Partial Function General Example

I think, everyone did some Mathematics from Schooling days. In Maths, division operation does not support for all inputs. It is NOT defined for denominator = 0. Hence, division is a partial function.

In a/b, if b=0 we will get ArthimeticException

```
scala> 1/0
java.lang.ArithmeticException: / by zero
```

Here nominator = 1 and denominator = 0. Hence we got exception.

**Scala Function Example:-**

```
scala> def division(no1:Int, no2:Int) = no1/no2
division: (no1: Int, no2: Int)Int
scala> division(1,1)
res9: Int = 1
scala> division(1,0)
java.lang.ArithmeticException: / by zero
scala> division(0,1)
res11: Int = 0
scala> division(0,0)
java.lang.ArithmeticException: / by zero
```

### PartialFunction In Scala API

Scala has built-in support to define Partial functions. We can use scala.PartialFunction trait to define Partial Functions.

Let us explore scala.PartialFunction trait now. In Scala API, it is define as shown below:

```
package scala
trait PartialFunction[-A, +B] extends (A) ⇒ B
```

In simple way, it is defined as PartialFunction[A,B]

- A is input to this function
- B is output to this function

It has couple of functions. "

**isDefinedAt**" is more popular and useful function. We will discuss about this function usage in the Examples section.### Partial Function Examples

Let us explore PartilaFunction with some examples here.

**Example-1:-**

```
scala> val increment: PartialFunction[Int, Int] = {
| case x:Int => x+1
| }
increment: PartialFunction[Int,Int] = <function1>
scala> increment(10)
res22: Int = 11
```

Here both input and output are of same type: Int.

Now let us define our division function (defined "Partial Function Real-time Example" section) using PartialFunction

**Example-2:-**Now let us define our division function (defined "Partial Function Real-time Example" section) using PartialFunction

```
scala> val division: PartialFunction[(Int,Int), Int] = {
| case (n:Int,d:Int) if d!= 0 => n/d
| }
division: PartialFunction[(Int, Int),Int] = <function1>
scala> division(1,1)
res23: Int = 1
scala> division(1,0)
scala.MatchError: (1,0) (of class scala.Tuple2$mcII$sp)
scala> division(0,1)
res25: Int = 0
scala> division(0,0)
scala.MatchError: (0,0) (of class scala.Tuple2$mcII$sp)
```

Here input is a Tuple2 of (Int,Int) type and output is of Int type.

**Example-3:-**

```
scala> val greet: PartialFunction[String, Unit] =
{ case name:String => println("Hello, "+ name) }
greet: PartialFunction[String,Unit] = <function1>
scala> greet("Rams")
Hello, Rams
```

A Partial Function can return Unit (no return value) also.

### Partial Function Rules

In Scala Language, we should follow some rules to define Partial Functions:

- Use scala.PartialFunction trait to define partial functions
- "case" block(s) are used to define partial function's body
- Entire function should be enclosed in curly braces

```
scala> val increment: PartialFunction[Int, Int] = case x:Int => x+1
<console>:1: error: illegal start of simple expression
val increment: PartialFunction[Int, Int] = case x:Int => x+1
```

- We can use "isDefinedAt" to check whether a Partial Function is defined at given input

```
if(division.isDefinedAt(1,0))
// Do something
else
// Do something else
```

NOTE:-

If input does NOT any available cases in a Partial Function, it throws MatchError as shown below:

```
scala> val division: PartialFunction[(Int,Int), Int] = {
| case (n:Int,d:Int) if d!= 0 => n/d
| }
division: PartialFunction[(Int, Int),Int] = <function1>
scala> division(0,0)
scala.MatchError: (0,0) (of class scala.Tuple2$mcII$sp)
```

**Partial Function Real-time Scenarios**

**Scenario-1:-**

One of the best examples is Akka Actors

```
def receive {
case ... => Do some thing
}
```

In developing Actors, we should define the implementation of a receive function as shown in the above example. It is actual a Partial Function

```
def receive: PartialFunction[Any,Unit] = { ... }
```

**Scenario-2:-**

Scala API uses Partial Function concept in many places. For instance, collect function available in Collection API.

**Scenario-3:-**

We can use Partial Function where we don't have full definition for it's inputs.

**Partial Function Interview Questions**
That’s In this section, we will discuss some useful Scala Partial Functions related Interview Questions and Answers:

That’s it all about “Scala Partial Functions”. We will discuss some more important Scala Concepts in my coming posts.

- What is Partial Function?
- What is Total Function?
- What is the type of a Scala Partial Function?

In Scala, the type of a Partial Function is scala.PartialFunction[A,B]

- When do we get a MatchError in a Partial Function?

That’s it all about “Scala Partial Functions”. We will discuss some more important Scala Concepts in my coming posts.

Please drop me a comment if you like my post or have any issues/suggestions. I love your valuable comments so much.