What are Lambda Expressions in Kotlin? A Complete Guide [2024] Video

In the world of programming, Lambda expressions have become a powerful tool for creating concise and flexible code. Kotlin, a modern and versatile programming language, fully embraces the concept of Lambda expressions, allowing developers to write more expressive and efficient code. In this article, we will explore the ins and outs of Lambda expressions in Kotlin, understanding their syntax, usage, and the benefits they bring to the table. We will elaborate more on this in the blog post below and the above video.

Lambda expressions, also known as anonymous functions, are a way to define functions without explicitly naming them. They provide a concise and powerful syntax for creating small, self-contained blocks of code that can be passed around as variables, making them ideal for functional programming paradigms.

In Kotlin, Lambda expressions follow a specific syntax pattern. They are defined using curly braces {}, and can optionally take parameters and return a value. The basic structure of a Lambda expression in Kotlin is as follows:

Let's break down the different components of this syntax:

For example, here is a lambda that doubles a number:

We can call it like a regular function:

The full explicit syntax looks like:

But in most cases, the types can be omitted thanks to Kotlin's type inference.

Some other example lambda expressions:

Lambda parameters can also be destructured like regular method parameters:

Overall the syntax is very flexible but always follows the same underlying structure - parameters, arrow, body.

Lambda expressions bring several benefits to Kotlin development, making code more concise, expressive, and flexible. Here are some of the key advantages:

Lambda expressions allow you to write more compact code by eliminating the need for explicit function declarations. This leads to cleaner and more readable code, especially when dealing with small and self-contained functions.

For example, compare this regular function:

To this simple lambda doing the same work:

Lambda expressions are a core feature of functional programming, and Kotlin's support for Lambda expressions opens up a whole new world of functional programming possibilities. With Lambda expressions, you can easily work with higher-order functions, perform functional transformations on collections, and embrace the functional programming paradigm.

Furthermore, Treating functions as values allows adopting functional concepts like:

This declarative style abstracts flow control away from stateful code, which reduces bugs.

By treating Lambda expressions as first-class citizens, Kotlin enables you to pass them as arguments, store them in variables, and return them from functions. This provides a high level of flexibility, allowing you to dynamically adjust the behavior of your code at runtime.

The concise nature of Lambda expressions can lead to more efficient code, as unnecessary boilerplate is eliminated. Additionally, the ability to pass Lambda expressions as arguments to higher-order functions can reduce code duplication and improve code reuse.

Lambdas seamlessly convert to Java 8+ functional interfaces like Runnable, providing easy interop:

Enables leveraging lambdas for Android, Spring Framework, RxJava, and more.

Executing logic asynchronously is easy by passing lambdas to threads, callbacks, deferred values, and flows:

No need for separate Runnable classes.

One of the key advantages of Lambda expressions is their ability to be used as first-class citizens in Kotlin. This means that you can treat Lambda expressions just like any other variable, passing them as arguments to functions, storing them in variables, or even returning them from other functions.

A common use case for Lambda expressions is to pass them as arguments to higher-order functions. Higher-order functions are functions that either take other functions as parameters or return functions as their result. Let's take a look at an example:

In this example, we have a higher-order function called processData that takes a list of integers and a Lambda expression as arguments. The Lambda expression (Int) -> Unit represents a function that takes an integer as a parameter and returns nothing. Inside the processData function, we loop through the list of numbers and apply the Lambda expression to each item.

Another powerful feature of Lambda expressions is the ability to store them in variables. This allows you to reuse Lambda expressions throughout your code. Here's an example:

In this example, we define a Lambda expression called multiply that takes two integers as parameters and returns their product. We then store this Lambda expression in a variable called multiply. This variable can now be used as a regular function, taking two integers and returning their product.

Lambda expressions can also be returned from functions, allowing you to dynamically generate functions based on certain conditions or calculations. Here's an example:

In this example, we have a function called createMultiplier that takes an integer factor as a parameter and returns a Lambda expression (Int) -> Int. This Lambda expression multiplies the input number by the factor. In the main function, we create a multiplier by calling createMultiplier(3) and then use this multiplier to multiply the number 5. The result is printed as "The result is: 15".

In Kotlin, if a Lambda expression has only one parameter, you can use the it keyword as a shorthand for that parameter. This makes the code more concise and readable. Here's an example:

In this example, we have a list of numbers and we want to filter out the numbers greater than 3 and print them. Instead of explicitly defining the parameter in the Lambda expression, we can use the it keyword to refer to each element in the list. This allows us to write more succinct code.

A very popular example is filtering lists using the .filter {} standard library function. Pass a predicate lambda to filter that returns true or false to select elements:

We can filter by any condition without requiring temporary variables or loops.

Chaining filter() and map() together is also common:

This maps all values over 2 to their triple value.

Lambdas are extremely useful for event handling in Android/GUI apps by running code when events occur:

No need to create separate single-method interfaces.

Can also use lambdas for asynchronous event streams with RxJava, Flow APIs, etc.

We can create threads by passing a lambda instead of needing a separate Runnable class:

Cleaner syntax without extra classes.

Lambdas also work great with coroutines for non-blocking concurrency.

JPA criteria queries accept lambdas to construct dynamic database lookups:

Can apply filtering conditions dynamically.

Lambdas allow passing functionality around to enable reusable, declarative code.

An important link between lambdas and Java is functional interfaces.

A functional interface defines a single abstract method that serves as its functional method signature.

Kotlin automatically converts lambda expressions to an instance of Java functional interfaces as needed for interoperability.

For example, Runnable is frequently used with threads in Java:

We can construct a Runnable using a Kotlin lambda instead of anonymous class:

The lambda translates to a Runnable instance behind the scenes.

Some other common functional interfaces used by Kotlin developers include:

Using lambdas as functional interfaces unlocks interoperability with fundamental Java APIs like streams, Swing, Spring Framework, and more.

Lambda expressions are a powerful feature of Kotlin that allows for the creation of concise and flexible code. By treating functions as first-class citizens, Kotlin enables developers to write expressive and efficient code that is easy to read and maintain. Whether you're working with higher-order functions, transforming collections, or implementing functional programming principles, Lambda expressions in Kotlin provide a valuable tool for achieving your programming goals. Start leveraging the power of Lambda expressions in your Kotlin projects and unlock a whole new level of code elegance and efficiency.

Lambda Expressions Docs - Official Kotlin docs on lambdas and anonymous functions.

If you found value in the article, please also share it on the following platforms: