Kotlin is `fun` - lambdas with receivers

As we already covered, Kotlin provides the ability to extend a class or an interface with new functionality without having to inherit from the class or use design patterns such as Decorator ⮕ Kotlin is fun - extension functions.

Kotlin also treats functions as first-class citizens, meaning they can be passed around. It also, of course, supports generics ⮕ Kotlin is fun - Function types, lambdas, and higher-order functions.

This means we can write something like this:

fun <T> T.doWith(op: (T) -> Unit) {
    op(this)
}

This extension function can be called on anything and will simply pass this anything as an argument to the lambda passed as a parameter. For example:

val someList = listOf(1, 2, 3, 4)

someList.doWith ({ list -> 
    println(list.size)
    println(list.sum())
})

This is syntax is not following the conventions. Let's rewrite it in proper Kotlin, by removing parenthesis and using the implicit it parameter:

someList.doWith { // it -> List<Int>
    println(it.size)
    println(it.sum())
}

This is better. Notice though that the it is redundant. We would rather be able to write:

someList.doWith { // this -> List<Int>
  println(size)
  println(sum())
}

But how? Read on!

Lambdas with receivers

To make this magic happen, the only necessity is to change the type of the op argument from (T) -> Unit to T.() -> Unit. This special syntax, A.(B), denotes a receiver object:

Inside the body of the function literal, the receiver object passed to a call becomes an implicit this, so that you can access the members of that receiver object without any additional qualifiers, or access the receiver object using a this expression.

The final implementation is now:

fun <T> T.doWith(op: T.() -> Unit) {
    op(this)
}

listOf(1, 2, 3, 4).doWith {
    println(size)
    println(this.sum()) // "this" is optional 
}

It is just a bit of sugar-coating, but admit this syntax looks cool 😎.

Side note

In the real world, we would also want this doWith to be inline, to improve performances:

inline fun <T> T.doWith(op: T.() -> Unit) {
    op(this)
}

For more information on receivers (and more examples), see the docs on Function literals with receivers.