Coding Friction

Kotlin Lambda Function

Lambda is a function which has no name. It is a concise way to define a block of code that can be passed around as an argument to higher-order functions or stored in a variable for later use.

Lambda functions are useful in various contexts, such as higher-order functions, collections operations (like map, filter, and reduce), and asynchronous programming.

The general syntax for a lambda function in Kotlin is as follows:

val lambdaName: (parameter1Type, parameter2Type, ...) -> ReturnType = { parameter1, parameter2, ... ->
    // Function body
    // Return value (if applicable)

1. lambdaName: This is an optional name for the lambda function, which can be used if need to reference the function elsewhere.

2. (parameter1Type, parameter2Type, …): These are the parameter types that the lambda function takes. Lambda functions can have zero or more parameters.

3. ReturnType: This is the type of the value that the lambda function will return. you can use Unit If the function doesn’t return anything.

4. ->: This is the lambda operator, which separates the parameter list from the function body.

5. Function body : This is the code that makes up the body of the lambda function. It gets executed when the lambda is called.

Now, let’s see some examples of lambda functions:

Example 1: A lambda function with parameters that adds two numbers and returns the result:

val addNumbers: (Int, Int) -> Int = { a, b -> a + b }

val result = addNumbers(5, 3)
println("Result: $result")  // Output: Result: 8

Example 2: A simple lambda without parameters:

val greet: () -> Unit = {
    println("Hello, World!")
// Calling the lambda function 
greet() // Output: Hello, World!

Example 3: Lambda as an argument to a higher-order function:

// Higher-order function to perform a mathematical operation on two numbers
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)

fun main() {
    // Using the 'calculate' function with different operations using lambdas
    val addResult = calculate(6, 8) { x, y -> x + y }
    println("Addition Result: $addResult") // Output: Addition Result: 14

    val subtractResult = calculate(10, 7) { x, y -> x - y }
    println("Subtraction Result: $subtractResult") // Output: Subtraction Result: 3

    val multiplyResult = calculate(14, 6) { x, y -> x * y }
    println("Multiplication Result: $multiplyResult") // Output: Multiplication Result: 84

In this example, calculate is  a higher-order function that takes two integers a and b, and a lambda operation that takes two integers and returns an integer. The calculate function applies the lambda operation to the input integers a and b and returns the result.

Example 4: return a lambda function from another function

This feature allows you to create functions that generate and customize behavior on-the-fly based on certain conditions or inputs.

Here’s an example:

// Function that returns a lambda
fun createAdder(amount: Int): (Int) -> Int {
    return { x -> x + amount }

fun main() {
    // Create an adder function that adds 6 to any input
    val addSix = createAdder(6)

    // Use the returned lambda to perform addition
    val result1 = addSix (10) // 10 + 6 = 16
    val result2 = addSix (20) // 20 + 6 = 26

    println("Result 1: $result1") // Output: Result 1: 16
    println("Result 2: $result2") // Output: Result 2: 26

In the main function, we call createAdder(6) to get the addFive lambda. then use addFive to perform addition on different input values (10 and 20 in this case) As a result, we get 16 and 26, respectively, because the addFive lambda adds 6 to the given input..