3 minutes

Java’s approach to functional programming, while possible, often feels indirect, particularly when dealing with function types. The need for explicit interfaces, like Function<T,R>, Consumer<T>, or custom ones, can lead to verbose and somewhat convoluted code.

Kotlin, on the other hand, introduces first-class function types, allowing for a more streamlined and expressive syntax. This distinction fundamentally alters the way higher-order functions are handled, impacting readability and maintainability.

This blog post discuss these differences and highlights the main language features Kotlin provides for Functional Programming.

Function Types

Functions are first class citizens in Kotlin. To facilitate this, Kotlin has a Fuction Type - a type which specifies that an object needs to be a function.

To decalre it, one should wrap the types of the arguments this function expected to recieve in brackets, an arrow (->) and then the result type of the function (if the function doesn’t return anything significant it should return a Unit), something like this () -> Unit or this (Int, Int) -> Int (recall how cumbersome this in Java, aka. @FunctionalInterface).

A function type offers only one method invoke() - which has the same arguments and result type as the function type that defines it. Since invoke() is an operator, we can call it implcitly:

fun x(y: (Int) -> Int) {
    y.invoke(3, 3) // explict invoke
    y(3, 3) // implict invoke
}

Lambda Expressions

Lambda expressions are a shorter alternative to Anonnymous Functions, but also a bit more powerful. To declare a lambda expression, curly brackets are needed ({ } is a valid lambda expression, which its function type is () -> Unit).

A full lambda expression will include a list of parameters seperated again with an arrow ->, followed by the lambda expression body:

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

To make lambdas shorter - an exlict return isn’t needed and the last statement considered to be the return value.

Trailing Lambdas

A Trailing Lambda is a convention in Kotlin, that when the last parameter in a function call is a lambda expression, it can be declared outside of the function’s parameters brackets:

callingMyFunction(param1: Int, param2: String) {
    _ -> println("My lambda is outside the called function's parameters brackets)
}

When a lambda expression is the only parameter for a function, the brackets are needed at all and can be omitted.

Function Reference

Function Reference are complemtery to lambda expressions - instead of creating a new function object we can refer an existing function.

We refer to a top-level function using a :: and the function name - val f = ::topLevelFunctionName.

Inline Functions

Using functions with functional parameters (High Order-Functions) has some performence penalties - when calling such a function, objects are created for each lambda expression, which can have a performance overhead. This a great oppurtuntiy to use Kotlin’s inline keyword - when adding it to a function with functional parameters - the function together with its lambdad expression are inlined.

fun filterList(numbers: List<Int>, predicate: (Int) -> Boolean): List<Int> {
    val result = mutableListOf<Int>()
    for (number in numbers) {
        if (predicate(number)) {
            result.add(number)
        }
    }
    return result
}

val isEven: (Int) -> Boolean = { it % 2 == 0 }

fun main() {
  val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  val evenNumbers = filterList(numbers, isEven)
  println(evenNumbers) // Output: [2, 4, 6, 8, 10]
}

Another benefit of inlining a function with a functional parameters is having a non-local return.