Currying Function in Java Explained [Practical Examples]

Introduction to Currying Function in Java

In Java, currying function is the mechanism of breaking down a multi-argument function to form the multiple functions with single arguments such that the output remains same. In other words, when we don't want to pass all the arguments to the function, we use currying. So, currying decomposes higher order functions into cascaded functions with one argument that return a function, except for the last cascade that returns the result of computation.

Hence, it simplifies the function call. The other advantage is that the currying function allows us to create more specialized function so as to allow code re-usability.

Advertisement

 

Syntax

The syntax of apply function is as shown below. The apply function applies to the given argument t and returns the result.

apply(T t)

 

Examples demonstrating currying in Java

Example 1 : Currying function to multiply two numbers

In this example, we are designing the curried function with two integer parameters to compute multiplication of two numbers. Here, we will use apply method to pass two parameters 10 and 20 to the curried function.

// Program to demonstrate the currying in Java
import java.util.function.Function;

// Main class  
public class Main {
    public static void main(String args[])
    {  
        // Curried Function for Multiplying u & v
        Function<Integer, Function<Integer, Integer> >
        c = u -> v -> u * v;
     
        // Calling Curried Function for Multiplying u & v
        System.out.println("Product of 10 and 20 is "+ c.apply(10).apply(20));
    }
}

Output

Product of 10 and 20 is 200

 

Example 2 : Currying function to concatenate the strings

In this example, we are designing the curried function with two string parameters to compute concatenation of two Strings. We will use apply method to concatenate the strings using the curried function.

// Program to demonstrate the currying in Java
import java.util.function.Function;

// Main class  
public class Main {
    public static void main(String args[])
    {  
        // Curried Function for concatenating the strings
        Function<String, Function<String, String> >
        c = u -> v -> u + v;
     
        // Calling Curried Function for concatenating the strings
        System.out.println("Concate two string : "+ c.apply("Hello").apply("World"));
    }
}

Output

Concate two string : HelloWorld

 

Example 3 : Currying function to evaluate the expression

In this example, we are designing the curried function with three integer parameters to  evaluate the expression. We will use apply method to pass three parameters using the apply method and thereby evaluating the expression 2x+3y+5z to get its result.

Advertisement
// Program to demonstrate the currying in Java
import java.util.function.Function;
  
public class Main {
    public static void main(String args[])
    {
  
        // Curried Function for Multiplying u & v
        Function<Integer, Function<Integer, Function<Integer, Integer> > >
        c = x -> y -> z-> 2*x + 3*y + 5*z;
     
        // Calling Curried Function for Multiplying u & v
        System.out.println("Evaluating 2x+3y+5z with x=10, y=20 and z=5 : "+ c.apply(10).apply(20).apply(5));
    }
}

Output

Evaluating 2x+3y+5z with x=10, y=20 and z=5 : 105

 

Example 4 : Currying function using the values from the function call

In this example, we will call a function fun1, fun2 and fun3 to get three values to compute the value of expression. Thereafter, we will evaluate the expression 2x+3y+5z to get its result.

// Program to demonstrate the currying in Java
import java.util.function.Function;
  
public class Main {
    
    public static int fun1()
    {
        return 10;
    }
    public static int  fun2()
    {
        return 20;
    }
   public static int fun3()
    {
        return 5;
    }
    public static void main(String args[])
    {
        
        // Curried Function for Multiplying u & v
        Function<Integer, Function<Integer, Function<Integer, Integer> > >
        c = x -> y -> z-> 2*x + 3*y + 5*z;
     
        // Calling Curried Function for Multiplying u & v
        System.out.println("Evaluating 2x+3y+5z with x=10, y=20 and z=5 : "+ c.apply(fun1()).apply(fun2()).apply(fun3()));
    }
}

Output

Evaluating 2x+3y+5z with x=10, y=20 and z=5 : 105

 

Example 5 : Currying function computing simple interest using Class

In this example, we are having a class SI that has a class variable rate which sets the rate depending on the type of account. Thereafter, we have a function getrate() that returns the value of class variable rate.

In Main class we are scanning the principal amount and duration from the user. Thereafter, we will compute the simple interest using curried function and obtaining value from the getrate() method of the SI class. Hence, it shows the simple interest computed taking principal, rate and duration.

// Program to demonstrate the currying in Java
import java.util.function.Function;
import java.util.Scanner;
class SI{
    double rate;
    SI(String t)
    {
        if(t=="Savings")
            this.rate=7.5f;
        else
            this.rate=3.5f;
    }
    public double getrate()
    {
        return this.rate;
    }
}  
public class Main {
    
    public static void main(String args[])
    {
        // Creating object of SI class to get the rate of interest
        // Here we will get the rate for savings account
        SI o=new SI("Savings");  
        
        // Curried Function for computing simple interest
        Function<Double, Function<Double, Function<Double, Double> > >
        c = x -> y -> z-> (x*y*z)/100.0;
        
        // Getting principal and number of years from the user
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter your principal amount ");
        double p=sc.nextFloat();
        System.out.println("Enter the duration of deposit in Years");
        double n=sc.nextFloat();
     
        // Calling Curried Function for computing simple interest
        System.out.println("Simple Interest on principal "+p+" with rate "+o.getrate()+" for "+n+" years will be "+ c.apply(p).apply(o.getrate()).apply(n));
    }
}

Output

Advertisement
Enter your principal amount 
1000
Enter the duration of deposit in Years
2.5
Simple Interest on principal 1000.0 with rate 7.5 for 2.5 years will be 187.5

 

Example 6 : Currying function computing student score using class

In this example, We will take a class Student that sets the sport marks of student based on the total marks of the student. Thereafter it computes the final score using currying function in a Main class. The equation used to compute the score is score=total+sport*25.

// Program to demonstrate the currying in Java
import java.util.function.Function;
import java.util.Scanner;
class Student{
    int sport;
    Student(int total)
    {
        if(total >210)
            this.sport=5;
        else if(total > 180)
            this.sport=3;
        else    
            this.sport=0;
    }
    public int getsport()
    {
        return this.sport;
    }
}  
public class Main {
    
    public static void main(String args[])
    {
        // Getting marks of 3 subjects for a student
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter marks of three subjects ");
        int a=sc.nextInt();
        int b=sc.nextInt();
        int c=sc.nextInt();
        int t=a+b+c;

        // Creating object of Student class to get the sport marks on the basis of total marks
        // Here we will get the rate for savings account
        Student o=new Student(t);  
        
        // Curried Function for computing score
        Function<Integer, Function<Integer, Integer> >
        s = x -> y -> x + y * 25;
        
        // Calling Curried Function for computing score
        System.out.println("Total of 3 subjects will be "+t+". Sports marks will be "+o.getsport()+". So final result will be "+ s.apply(t).apply(o.getsport()));
    }
}

Output

Enter marks of three subjects 
60
70
65
Total of 3 subjects will be 195. Sports marks will be 3. So final result will be 270

 

Summary

The knowledge of currying functions in Java is very useful while working on real time applications. In this tutorial, we covered the different scenario to use function currying in java with an example. As per the requirement of an application, we can choose an appropriate approach for currying. We learned in detail about currying with an example.

All in all, this tutorial, covers everything that you need to know in order to have a clear view on currying function in Java.

 

References

Function Interface

 

Didn't find what you were looking for? Perform a quick search across GoLinuxCloud

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can either use the comments section or contact me form.

Thank You for your support!!

Leave a Comment

X