Lambda Expressions | Functions

What Are Lambda Expressions?

Lambda expressions are a feature of Kotlin that allows you to define anonymous functions. They can be treated as values and passed around like variables.

Lambda expressions help you create concise and flexible code. They are particularly useful when working with higher-order functions, which are functions that take other functions as parameters or return them.

Basic Syntax

The syntax of a lambda expression in Kotlin is as follows:

{ parameter1: Type1, parameter2: Type2 -> body }

Here, parameter1 and parameter2 are the input parameters, Type1 and Type2 are their types, and body is the block of code that defines what the lambda does.

Example: Simple Lambda

Let's create a simple lambda expression that adds two numbers:

val add = { a: Int, b: Int -> a + b }

In this example, we define a lambda expression add that takes two integers and returns their sum.

Using the Lambda

val result = add(5, 3)

The value of result will be 8.

Lambda with No Parameters

You can also define a lambda expression that takes no parameters:

val greet = { println("Hello, World!") }

To invoke this lambda, simply call:

greet()

This will print "Hello, World!" to the console.

Higher-Order Functions

Lambda expressions are often used in higher-order functions. A higher-order function can take a lambda expression as a parameter or return a lambda expression.

Here’s an example of a higher-order function that accepts a lambda:

fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int { return operation(a, b) }

In this function, operation is a lambda that defines how to process the two integer parameters.

Using the Higher-Order Function

val result = operate(4, 5, add)

Here, we pass the add lambda as the operation. The value of result will be 9.

Lambda with Implicit Parameters

Kotlin allows lambda expressions to use implicit parameters when they are used as an argument in higher-order functions. For example, if you are using a collection, you can refer to the parameters using the it keyword:

val numbers = listOf(1, 2, 3, 4)
val doubled = numbers.map { it * 2 }

In this example, map is a higher-order function that applies the lambda to each element in the list, effectively doubling each number.

Conclusion

Lambda expressions are a powerful feature in Kotlin that enable you to write more concise and functional code. They are widely used in combination with higher-order functions to create flexible and reusable components in your applications.

With the understanding of lambda expressions, you can now implement them in various scenarios to enhance your Kotlin programming skills.

Lambda Expressions in Kotlin