Partial Functions in Scala

Last Updated : 29 Mar, 2019

Introduction: When a function is not able to produce a return for every single variable input data given to it then that function is termed as Partial function. It can determine an output for a subset of some practicable inputs only. It can only be applied partially to the stated inputs. Some important points:

Partial functions are beneficent in understanding many inconsistent kind of Scala functions.
It can be interpreted by utilizing case statements.
It is a Trait, which needs two methods namely isDefinedAt and apply to be implemented.

Example:

Scala

// Scala program of 
// Partial function

// Creating object 
object Case
{

    // Main method
    def main(args: Array[String])
    {

        // Creating Partial function 
        // using two methods
        val r = new PartialFunction[Int, Int] 
        {

            // Applying isDefinedAt method 
            def isDefinedAt(q: Int) = q != 0

            // Applying apply method
            def apply(q: Int) = 12 * q

        } 

        // Displays output if the
        // condition is satisfied
        println(r(10))
    }
}

Output:

Here, two methods are defined for applying Partial function, where isDefinedAt states the condition and apply performs the operation if the given condition is satisfied. Methods to define Partial functions: There are some methods to define Partial function, which includes case statements, collect method, andThen, and orElse.

Partial function using Case statement: we will create a Partial function below using case statement. Example:

Scala

// Scala program using
// case statements

// Creating object 
object Case
{

    // Main method
    def main(args: Array[String])
    {

        // Creating Partial function
        val d: PartialFunction[Int, Int] =
        {

            // using case statement 
            case x if (x % 3) == 0 => x * 3
        }

        // Displays output if 
        // the condition is 
        // satisfied
        println(d(3))
    }
}

Output:

Here, Partial function is created using case statement so, apply and isDefinedAt is not required here.

Partial function using orElse: This method is helpful in chaining Partial functions together. Example:

Scala

// Scala program using
// orElse

// Creating object 
object orElse
{

    // Main method
    def main(args: Array[String])
    {

        // Creating Partial function1
        val M: PartialFunction[Int, Int] = 
        {

            // using case statement 
            case x if (x % 5) == 0 => x * 5
        }

        // Creating Partial function2 
        val m: PartialFunction[Int, Int] = 
        {

            // using case statement 
            case y if (y % 2) == 0 => y * 2
        }

        // chaining two partial 
        // functions using orElse 
        val r = M orElse m

        // Displays output for 
        // which the given condition 
        // is satisfied
        println(r(5))
        println(r(4))
    }
}

Output:

25
8

Here, orElse will return output for which the given condition is satisfied.

Partial function using Collect method: Collect method requests Partial function to every single element of the collection and thus, helps in constructing a new collection. Example:

Scala

// Scala program using
// collect method

// Creating object 
object Collect
{

    // Main method
    def main(args: Array[String])
    {

        // Creating Partial function
        val M: PartialFunction[Int, Int] = 
        {

            // using case statement 
            case x if (x % 5) != 0 => x * 5
        }

        // Applying collect method
        val y = List(7, 15, 9) collect { M }

        // Displays output for which 
        // the given condition 
        // is satisfied
        println(y)
    }
}

Output:

List(35, 45)

Here, Collect will apply Partial function to all the elements of the List and will return a new List on the basis of the conditions stated.

Partial function using andThen: This method appends at the end of the chains, which is utilized to continue towards additional chains of Partial functions. Example:

Scala

// Scala program using
// andThen method

// Creating object 
object andThen
{

    // Main method
    def main(args: Array[String])
    {

        // Creating Partial function
        val M: PartialFunction[Int, Int] =
        {

            // using case statement 
            case x if (x % 4) != 0 => x * 4
        }

        // Creating another function
        val append = (x: Int) => x * 10

        // Applying andThen method 
        val y = M andThen append

        // Displays output after 
        // appending the another
        // function given
        println(y(7))
    }
}

Output:

Here, andThen will append the output of Partial function with the another function given and then will return that value.

Partial Functions in Scala

nidhi1352singh

Improve

Article Tags :

Partial Functions in Scala

Similar Reads

Thank You!

What kind of Experience do you want to share?