DEV Community: Sagar

Kotlin: Scope functions

Sagar — Thu, 04 Jun 2020 10:25:21 +0000

Prerequisite/Previous articles:

In a hurry?

You can jump to the conclusion section and play the concept.

Recap

We can access the receiver type from the business logic of an extension function through the keyword: this
We can omit the keyword: this
If a lambda has only one parameter, we can access that argument using the keyword: it

Why scope functions?

To make the code more concise!

How does the scope function make the code more concise?

Let us understand it by an example:

As you can see, we could avoid an extra variable. Moreover, we can also omit this keyword as below:

That was neat and clean. Isn't it?

Let us understand our first scope function: with

With

Definition

public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    /*...*/
    return receiver.block()
}

Let us examine the definition.

Inline

We use the inline keyword for the higher order function to avoid a function object creation, memory allocation and runtime overhead.

<T, R> with(receiver: T, block: T.() -> R): R

It is a generic function.
It can have anything as the first parameter. We can pass any instance as the first argument.
Second parameter is a function type, named as block.
block is an extension function.
The receiver type of the block is whatever we pass as the first argument to the scope function: with.
We can access the receiver type T from extension function T.() -> R using the keyword: this.
The function type parameter is the last parameter in the higher order function with. That means, we can pass our function literal between curly braces as an argument after the with function call parentheses.
The return type of both the function type parameter and the scope function itself are same: R.
The return type R is generic. That means, whatever our function literal (that we pass as an argument to our with function) returns, will be the return of our with function.
In function literals, the last statement gives return.

So, using with, we can perform multiple operations on an object without explicitly writing the name of the object or without taking another variable.

However, If the variable is nullable, we cannot avoid that this keyword in with.

Suppose we were getting a nullable value in our last example from below function:

private fun getEvenOrNull(randomNumber: Int): Int? =
   if (randomNumber.rem(2) == 0) randomNumber else null

Handling a nullable variable using with would look like below:

That doesn't look good! There must be a “nullability check” before we perform anything on a “nullable” variable.

Using another scope function called let, we can perform the “nullability check” and it also reduces the code than above and make it more pretty like below:

So, let us examine: let

let

Definition

public inline fun <T, R> T.let(block: (T) -> R): R {
    /*...*/
    return block(this)
}

T.let

We know about an extension function. T represents generics here. So, let is a generic extension function. That means, we can use let for any object. It is a member function for every class.

T.let(block: (T) -> R): R

Facts:

let is a higher order function because it has a function type parameter.
let is also an extension function with a generic receiver type T.
The receiver type T is also a parameter of the function type block here.
block is our function type parameter of the let function. We can pass a function type argument using function literal, lambda expression or an anonymous function.
Because the let function is generic and it has only one parameter which is also a generic, mostly we use function literal to pass as a function type argument.
The function type parameter block is the only parameter of a higher order function let and the function type has also only one parameter (T) which is also the receiver type. So, while calling let, we can omit the function call parentheses, the parameter of the function type and the arrow ->. We will just write our business logic between curly braces and we can access the parameter (T) of the function type block, using the keyword: it.
So, we access the receiver type as well as parameter of the function type inside the let block using the keyword: it.
The return type R is generic. The let function returns whatever our function literal (that we pass as a function type argument for the let function) returns.

Why let?

Because, we don't like that this?. for a "nullable variable" multiple times!

To provide “nullability check”.
To introduce chain operations.

Wait. What? Chain operations? Let us understand what it is.

Suppose we have a normal function like below:

fun doSomething(name: String) {
   println("Name from the method doSomething is: $name")
}

Now, let us do some multiple random operations like below:

Now, let us do the same thing using let:

As you can see, using let, we could avoid new variables while using the return value from multiple chain operations.

What?! Understanding the example:

Let us see what we have done (how we have used the let function):

let is a generic extension function. So, any instance can call it. Here, the let function is called on a nullable int variable.
let is also a higher order function. it has only one parameter. The parameter is of function type. The function type parameter has also only one parameter. Hence, we can omit the function call parentheses, the parameter of the function type and the arrow ->. All we write is just our business logic between curly braces and we access the parameter of the function type (which is also the receiver type of our extension function) using the keyword it.
We have done the same. After the function name which is “let”, there is our business logic between curly braces. The keyword it represents our int instance for the first let block and a StringBuilder instance for the second and third block.

Few things to note here:

The last statement in the let block decides the return type.
We are returning the result and not the receiver type itself.
We can check the nullability of the receiver type before we proceed.
It is an extension function. So, we can chain multiple operations. The return type (last statement) of the previous let block will become the receiver type of next function.
When we want to access the receiver type, we can use the keyword it (We have to use it to access the receiver type).
We can use any function on the receiver type from the let block using the keyword: it.
We can pass the receiver type to another function within the let block using the keyword: it.

With Vs Let

If there is a nullable value or chain operations, use let. Otherwise, use with because we can omit the keyword this.

Can't we have a function that can omit the keyword this like a with function and support nullability check and chain operations like let?

Yes! Our next scope function run is a hybrid product which has power of both let and with.

Let us study: run

Run

Below is the definition of the run function.

public inline fun <T, R> T.run(block: T.() -> R): R {
   /*...*/
   return block()
}

Similar to the let function, run is also an extension function and a higher order function. Hence, it also uses the keyword inline to avoid the function object creation.

The differences between let and run functions are:

The function type parameter
Return type

Let us examine it.

T.run(block: T.() -> R): R

The receiver type of an extension function and its function type is same: T. That means, we can access the receiver type using the keyword: this.
The keyword this can be omitted when we want to call any function on it that reduces the code even more.
It seems that the run function has combined the power of with and let. Or maybe we can say it is a with+ version! With was lacking the pros of an extension function (nullability check and chain operations) which the run function satisfies.

Instead of let, If we use run and rewrite the same function we have written earlier for let, it would look like below:

There are few things common between run and let as below. It will help us in deciding when to use them:

Both are extension functions.
Last statement is the return type.
We can check the nullability before we proceed.
Extension functions are helpful for chain operations.

However, there is a small but important difference between them as below. It will help us in selecting the right scope function.

In let, we access the receiver type using the keyword it and it cannot be omitted. However, in run, we access the receiver type using the keyword this and it can be omitted sometimes.

So, if we are not passing the receiver as an argument, we better use run because it reduces the code.

Considering above facts, we can rewrite our last example in a better way like below:

StringBuilder(toString()) looks more concise than StringBuilder(it.toString()).

Similarly, append(" test") looks more concise than it.append(" test").

However, wouldn’t it be more concise if we can replace all $this by $it?

But how? We have to use this to refer to the context object in run.
Correct, but not for "also”. We can use it to refer to the context object while using also.

Then, how is it different from let?

“also” returns the object itself whereas the last statement is “return type” for let.

Ok, enough theory! Show me code!

Also

Definition

public inline fun <T> T.also(block: (T) -> Unit): T {
   /*...*/
   block(this)
   return this
}

T.also

It is an extension function. That means, we can use it for “nullability check” before we proceed to work on a nullable value.

<T> T.also(block: (T) -> Unit): T

(block: (T) -> Unit)

block is a function type parameter.

block has one and only parameter (T).

We know that if the function type has one and only argument, we can access the argument using the keyword it.

T , The only parameter of the block is also a receiver type here.

So, we will be accessing the receiver type T using the keyword: it.

The interesting part is, it returns the receiver type itself: T

Using also, We can rewrite our last example code as below:

As shown in the example, also returns the object itself despite anything written in it's block and it uses it to refer to the context object.

So, It uses it to refer to the context object. That means, if we need to call some methods on the context object, we will have to use it like below:

So, we had to use it while calling a function on the context object from also block similar to let.

Can we omit it to make the code even more concise?

Yes! By using apply instead of also!

Similar to run, apply also uses this to refer to the context object. However, unlike run, being a sibling of also, apply returns the context object itself.

Let us examine apply.

Apply

Definition

public inline fun <T> T.apply(block: T.() -> Unit): T {
   /*...*/
   block()
   return this
}

T.apply

It is an extension function. Useful for “nullability check”.

block: T.() -> Unit

block is a function type parameter.

The receiver type of an extension function T.apply and it's function type parameter block is same: T.
And we know that we can refer to a receiver type using the keyword: this
And we also know that we can omit the keyword this while calling a function on it.

T.apply(block: T.() -> Unit): T

As we can see, it returns the receiver type itself.

Let us see how we can include apply in our last example:

Conclusion:

We have scope functions to make the code more concise.
All scope functions can be categorized or differentiated by two facts:

The way to refer to the context object (this or it)
Return type (the object itself or the last statement)

Using these two facts, we can decide which scope function to use for a particular situation.

1) If we need last statement as a return, we have:

T.run
T.let
with

Anything that the with can do, can be done by T.run also. Clearly, T.run wins here because of it's added “nullability check” and “chain operation” capabilities.

T.run is better than T.let if we are not passing the receiver type as an argument to another function.

2) If we want to return the object itself, we have:

apply (uses this to refer to the object)
also (uses it to refer to the object)

Same as the comparison between T.run Vs T.let; apply is better than also if we are not passing the context object as an argument to another function.

Play an overview of this article:

That’s all! If you find this article helpful, you can click on that heart icon 😉

Applauds and creative critics are always welcome 😇. Your ❤ motivates me to write more articles.

Thanks for reading the article! Have a great day 😇.

Relevant previous articles

Inline function
Extension function and Receiver type
Function type, Function literal, Lambda expression and Anonymous function

You can follow me to get the notification when I publish a new article.

Let us be Connected

https://www.linkedin.com/in/srdpatel

https://twitter.com/iSrdPatel

Tags: kotlin, scopeFunctions, android

Kotlin: Inline function

Sagar — Mon, 04 May 2020 10:41:51 +0000

Prerequisite/Previous articles:

Inline function

We know that a new function object is created for each and every function type in a higher order function. It causes memory allocation and hence, runtime overhead. To avoid this or say, to improve the performance, we can use the keyword inline.

However, that doesn’t mean we should inline each and every function! In fact, when we try to inline a function that is not accepting a function type, the IDE will tell us to remove the inline keyword.

Also, we should not inline any higher order function that has more than 3 lines because generated code grows a lot for an inline function. You can check the Kotlin standard library to get an idea about when to use inline functions.

When using an inline function, we are not allowed to pass a function type parameter to another function. However, if it is necessary, we can mark such a function type as a noinline.

Let us understand it by an example:

Suppose we have our higher order function like below:

fun Int.doSomething(y: Int, ftOne: Int.(Int) -> Int, ftTwo: (Int) -> Int) {

           /*...*/
}

So, in such case, in order to prevent new function object creation, we can make the function inline as below:

inline fun Int.doSomething(y: Int, ftOne: Int.(Int) -> Int, ftTwo: (Int) -> Int) {
        /*...*/
}

However, if we are passing any function type to another function like below:

//Compile time error… Illegal usage of inline function type ftOne...
inline fun Int.doSomething(y: Int, ftOne: Int.(Int) -> Int, ftTwo: (Int) -> Int) {
        //passing a function type to another function
        val funOne = someFunction(ftOne)
        /*...*/
}

Here, the compiler will complain to us: Illegal usage of inline function type ftOne…

To solve that, we can rewrite our function as below:

inline fun Int.doSomething(y: Int, noinline ftOne: Int.(Int) -> Int, ftTwo: (Int) -> Int) {
        //passing a function type to another function
        val funOne = someFunction(ftOne)
        /*...*/
}

However, if there is only one lambda parameter and we are passing it to another function, it doesn’t make any sense to make such a higher order function inline and the compiler will also suggest the same!

Let us understand it by an example:

Suppose we have a higher order function like below:

inline fun Int.doSomething(y: Int, noinline ftOne: Int.(Int) -> Int) {
        //passing a function type to another function
        val funOne = someFunction(ftOne)
        /*...*/
}

Here, the compiler will tell us to not use the inline keyword when there is only one lambda parameter and we are passing it to another function. So, we can rewrite above function as below:

    fun Int.doSomething(y: Int, ftOne: Int.(Int) -> Int) {
        //passing a function type to another function
        val funOne = someFunction(ftOne)
        /*...*/
    }

Note that we had to remove the keyword noinline as well because it can be used only for inline functions!

That’s all!

If you have read this article, if this article has helped you, you can click on that ❤ icon. Your ❤ motivates me to write more articles.

You can follow me to get the notification when I publish a new article.

Let us be Connected

https://www.linkedin.com/in/srdpatel

https://twitter.com/iSrdPatel

Tags: kotlin, inline

Kotlin: Extension function and Receiver type

Sagar — Sat, 02 May 2020 01:01:11 +0000

Prerequisite/Previous Part

Kotlin: Function type, function literal, lambda expression and anonymous function

Extension Function

General scenario: We make a class. We write a few methods. Later, we realize that we need more methods for the class. We write more methods in the same class.

But, if the class is in the third-party library that we are using through dependency or in such a way that we cannot add new functions in such a class, we cannot modify that class.

In kotlin, we can add a new function for any class in any other class too. Such a function is called an “Extension function” and we can use such an extension function only inside the class where it is created.

So now, we can add new functions even for the class that is in the third-party library. Note that it is not limited to third-party library class only! Main thing is, we can add a new function for any class in any other class too.

Syntax

In order to create an extension function, we write the class name (also known as a receiver type) followed by a dot, followed by our function as below:

//Here, OurClassName is called a receiver type
fun OurClassName.ourExtensionFunction

For example:

/**
 * Extension function. Here, String is known as receiver type. 
 * That means, we can call this function on any String. 
 * The extension function can be called only from the   
 * class where it is defined.
 */
fun String.extensionFun() {
//We can access the receiver (Here, it is String) using "this" keyword inside the //business logic
     println("from extension function: $this")
}

We can access an instance of the receiver type using this keyword inside the business logic as shown above.

How to call / use an extension function?

val myString = "MyString"
myString.extensionFunction() //prints: from extension function: MyString

Receiver

We have seen a receiver type in an extension function. Similarly, a function type, function literal, lambda expression and an anonymous function can also have a receiver type.

A function type with receiver

Syntax/Signature of a function type with receiver:

ft: Int.(Int) -> Int // Here, the receiver type is: Int

Function type with the receiver as a parameter

We can have a higher order function having a function type parameter with receiver as below:

//A higher order function whose function type parameter has a receiver
fun doSomething(x: Int, y: Int, ft: Int.(Int) -> Int) {
   val ftWithReceiver = x.ft(y) //OR ft(x, y) where x is a receiver.
   println("doSomething: $ftWithReceiver")
}

Note that when a receiver is treated as an argument, it must be a first argument as shown in the comment of the above function.

In order to call above higher order function, we can do one of the below things:

Function literal with receiver

//A function literal, accessing the receiver by using the keyword: this
doSomething(1, 2) { y: Int -> this - y } //prints: doSomething: -1

Let us understand our “function literal”.

{ y: Int -> this - y }

Our function literal has been passed as an argument against:

ft: Int.(Int) -> Int)

The function type parameter is expecting an Int parameter. Our function literal has also an Int parameter:

y: Int
Inside the business logic, we have used the keyword: this

-> this - y
We access an instance of our receiver in a business logic of an extension function through the keyword: this
Our this keyword has been inferred as a receiver type: Int for:

ft: Int.(Int) -> Int)

Our this keyword refers to a receiver type: Int

Lambda expression with receiver

//A lambda with receiver type. Accessing the receiver by using the keyword: this
val ftSubtraction: Int.(Int) -> Int = { y: Int -> this - y }

And then we can use that lambda to pass as an argument to our higher order function as below:

//passing a lambda for the higher order function
doSomething(1, 2, ftSubtraction) //prints: doSomething: -1

Same receiver for both an extension function and a function type

Suppose we have a higher order function like below:

//Same receiver type for both an extension function and its function type param
fun Int.doSomething(y: Int, ft: Int.(Int) -> Int) {
    //In such case, we can omit the receiver while calling the function type
    val ftWithReceiver = ft(y) //It is Int.ft(y) 
    println("doSomething: $ftWithReceiver")
}

So, as shown in the example above: When the receiver type of an extension function is the same as its function type parameter, we can omit the keyword this while calling any function on it.

We can call above extension function like below:

Using Anonymous function

//passing an anonymous function
1.doSomething(2) { y: Int -> this - y } //prints: doSomething: -1

Using lambda

//passing a lambda for the higher order function
1.doSomething(2, ftSubtraction) //prints: doSomething: -1

You can play the concept below:

That's all!

If you have read this article, if this article has helped you, you can give me your ❤ 😉

Link to previous article

Next article: inline

Let us be Connected

https://www.linkedin.com/in/srdpatel

https://twitter.com/iSrdPatel

Tags: kotlin, function type, function literal, lambda expression, anonymous function, higher order function, extension function, receiver type

Kotlin: Function type, Function literal, Lambda expression and Anonymous function

Sagar — Fri, 01 May 2020 01:15:43 +0000

Function Type

We know data types. Similarly, we have function type too in kotlin.

Signature / Syntax

    Name: (only comma separated data types) -> return data type

    ft: (Int, Int) -> Int

How to call / execute a function type?

    ft(1, 2) 

    //OR

    ft.invoke(1, 2)

Usage:

Function type as an interface

Like an interface, we can implement a function type in a kotlin class. When we implement a function type, we get a method called “invoke” to override having a similar signature of the implemented function type.

Example:

    //Implementing a function type like an interface
    class ClassName : (Int, Int) -> Int {

    /**We get a method "invoke" to override with similar signature of     
     * function type we implemented
     */
    override fun invoke(p1: Int, p2: Int): Int {
            return p1 + p2
        }

    }

Function type as a parameter

As a function parameter in a higher order function. The function that takes one or more function types as a parameter/s or/and the function that returns a function type is known as a higher order function.

    fun doSomething(a: Int, b: Int, ft: (Int, Int) -> Int): String {

        val result = ft(a, b) //OR ft.invoke(a, b)

        return “doSomething: ” + result
    }

There is one thing to remember here:.

A new function object will be created for each and every function type of a higher order function.

How to call/use/execute such a higher order function?

We know how to call a function but we may not know how to pass a function type argument/s in any higher order function!

We can pass function type arguments using function literal, lambda expression or by anonymous function. Let us check these all one by one.

Function literal

Signature / Syntax: 1

    { comma separated pascal parameters -> business logic }

Example:

    { x: Int, y: Int -> x + y }

Note that the last statement in a function literal is considered as a return statement. So, the last statement in a function literal decides the return type.

We can use function literal to pass as a function type argument for higher order function as below:

    //Calling a higher order function 

    println(doSomething(1, 2, {x: Int, y: Int -> x + y})) 

    //prints: doSomething: 3

OR if the function type parameter is the last parameter in the higher order function, we can write our function literal after the closing function parenthesis as below:

    //Calling a higher order function

    println(doSomething(1, 2){x: Int, y: Int -> x + y})

    //prints: doSomething: 3

OR if the higher order function has only one parameter or say if the function type parameter is one and only parameter in a higher order function like below:

   //region A higher order function that has one and only function type parameter
    private fun doSomething(ft: (Int, Int) -> Int) {
        val result = ft(1, 2)
        /*...*/
    }
   //endregion

While calling such a higher order function, we can omit the function call parentheses like below:

        doSomething { x: Int, y: Int -> x + y }

Syntax / Signature 2

Also, if the function type is only parameter in a higher order function and if the function type has also only one parameter like below:

 private fun doSomething(ft: (Int) -> String) {
        /*...*/
 }

While passing such a function literal, in addition to function call parentheses, we can also omit the parameter and an arrow -> ! We just write core business logic between curly braces and we can access our single parameter through the keyword it like below:

doSomething { "$it" }

And if the higher order function has only one function type parameter and the function type has no parameter like below:

private fun doSomethingY(ft: () -> String) {
        /*...*/
}

We can simply write our business logic between curly braces right after the higher order function name as below:

doSomethingY { "test" }

Types:

There are two types of function literals.

Lambda expression
Anonymous function

Lambda expression

Lambda expression is just another way to define a function in a short way.

Signature / Syntax 1

We can either specify explicit function type and let the data type of parameters inferred in below format:

nameOfTheLambda: (explicit function type) = { comma separated parameter: Inferred data type -> business logic }

Or we can give explicit type annotation to parameters and let the function type inferred like below format:

nameOfTheLambda: (inferred function type) = { comma separated parameter: Explicit dataType -> business logic}

Or we can write both function type and data type of parameter (but why?) like below:

nameOfTheLambda: (explicit function type) = { comma separated parameter: Explicit dataType -> business logic}

Let us see an example:

    /**
     * nameOfTheLambda: function type 
     * = { comma separated pascal parameters -> business logic }
     */

    val lambda: (Int, Int): Int = { x: Int, y: Int -> x + y }

Signature / Syntax 2 for special case

If a lambda has only one parameter, we can omit everything except a business logic inside the curly braces and we can access the single argument using the keyword: it

Example:

Suppose we have a lambda expression like below:

    val lambdaIncrement: (Int): Int = { x: Int -> x + 1 }

We can write the equivalent lambda as below:

    val lambdaIncrement: (Int): Int = { it + 1 }

Summary for a lambda expression having a single parameter

Usage: How to call / execute / use lambda expression

We can use above lambda expression directly like below:

    println(lambda(1,2)) //prints: 3

OR we can pass a lambda as a function type argument to a higher order function like below:

    println(doSomething(1, 2, lambda)) //prints: doSomething: 3

Sometimes, the common term “lambda” is used to represent a function type, function literal or a lambda expression.

Anonymous function

Signature / Syntax

    //fun(comma separated pascal parameters) = business logic

    fun(x: Int, y: Int) = x + y

We can store an anonymous function in a variable like below:

    val anonymousFunction: (Int, Int): Int = fun(x: Int, y: Int) = x + y

Usage: How to use an anonymous function

We use an anonymous function as an argument for a higher order function like below:

    println(doSomething(1, 2, fun(x: Int, y: Int) = x + y )) 

    //prints: doSomething: 3

We can use an anonymous function through a variable to pass as an argument in a higher order function as below:

    println(doSomething(1, 2, anonymouseFunction) 

    //prints: doSomething: 3

That’s all! If you have read this article, if you find this article helpful, you can click on that heart icon 😉

Applauds and creative critics are always welcome 😇

In next article, we will learn about Extension function and Receiver type.

Thanks for reading the article! Have a great day 😇

Let us be Connected

https://www.linkedin.com/in/srdpatel

https://twitter.com/iSrdPatel

Tags: kotlin, function type, function literal, lambda expression, anonymous function, higher order function