
High order function (Higher level function) is a function which accepts function as a parameter, returns a function and it can do both. We can pass a function instead of passing Int, String, or other data types as a parameter in a function.
Lambdas Expressions
Lambdas Expressions are essentially anonymous functions that we can treat as values , for example -pass lambda expressions as arguments to the function, return them, or do any other thing we could do with a normal object.
Lambda Expressions look like below:
val lambdaName : Type = { argumentList -> codeBody }
val square : (Int) -> Int = { value -> value * value }
val sqrValue = square(12)
There is a simple example:
val returnSameValue : (Int) -> Int = { value -> value }
This is a lambda expression that does nothing. Here the { value -> value }
is a complete function in itself. It takes an int
as a parameter and returns a value as an int
.
In (Int) -> Int
(Int)
represents input int
as a parameter.
Int
represents return type as an int
.
So, the returnSameValue
is a function that takes a value as int
and returns the same value as int
.
Another example:
val addTwoNumbers : (Int, Int) -> Int = { a, b -> a + b }
{ a, b -> a + b }
is also a lambda expression function that takes two int
as the parameters, adds them, and returns an int
value.
In (Int, Int) -> Int
(Int, Int)
represents two int
as the input parameters.
Int
represents return type as an int
.
So, the add
TwoNumbers is a function in itself that takes two int
as the parameters, adds them, and returns as an int
.
A simple and similar example that relate to the lambda expression given above:-
val addition = addTwoNumbers(15,48)
Now, we have understood the lambda expressions. Let’s move to the Higher-order functions.
Higher-Order Functions
A higher-order function is a function that takes functions as parameters or returns a function.
It’s a function which can take do two things:
- Can take functions as parameters
- Can return a function
We will see both the things one by one.
Let’s start with the first one – A function can take a function as parameters.
fun functionAsParameter(xyz: () -> Unit)
{
// It can take functions
// perform a task
// execute the function
abc()
}
This takes a function xyz: () -> Unit
xyz
is just the name for the parameter. It can be anything.
() -> Unit
, this is important.
()
represents that the function takes no parameters.
Unit
represents that the function does not return anything.
So, the functionAsParameter
can take a function that takes zero parameters and does not return anything.
Lets try passing that type of function to the
.functionAsParameter
functionAsParameter(
{
val student = Student()
Student.rollNo = 56
println("Student Roll-Number updated")
}
)
Here { }
is a function in itself. See above highlighted one.
Which creates a student, sets the roll number, and prints an update message. This means it does not take any parameters and does not return anything.
Let’s add fun xyz()
, we do not need to write fun xyz()
in our code. It is just for understanding purposes now.
functionAsParameter(
fun xyz(){
val student = Student()
Student.rollNo = 56
println("Student Roll-Number updated")
}
)
Now, here we can see that we are passing a function xyz() to
().functionAsParameter
As Kotlin provides us a concise way for writing code, it can be changed to the following by removing the ()
.
A function can return a function
Suppose we have a function add
ition which takes two integers as parameters and returns the sum of those two parameters as in int.
fun addition(a: Int, b: Int): Int {
return a + b
}
And, we have a function addFunction
which takes zero parameters and returns a function of the type ((Int, Int) -> Int)
.
fun addFunction(): ((Int, Int) -> Int) {
// can do something and return function as well
// returning function
return ::addition
}
((Int, Int) -> Int)
(Int, Int)
means that the function should take two parameters both as the int
.
Int
means that the function should return value as an int
.
Now, we can call the addFunction
, get the addition function, and call it like below:
val addition = addFunction()
val result = addition(15,19)
This is what higher-order functions are.
To learn more on Higher order function and lambdas in kotlin click here,
For more tech blogs, please visit Knoldus Blogs.
