Passing lambdas to functions in Kotlin - Mini Project: Build & Apply

Passing lambdas to functions

📖 Scenario: Imagine you are building a simple calculator app that can perform different operations on numbers. You want to write a function that takes two numbers and a small piece of code (a lambda) that tells it what operation to do.

🎯 Goal: You will create a function that accepts two numbers and a lambda function to perform an operation on these numbers. Then, you will call this function with different lambdas to see different results.

📋 What You'll Learn

Create a function called calculate that takes two Int parameters named a and b, and a lambda parameter named operation of type (Int, Int) -> Int.

Create a variable called add that holds a lambda to add two numbers.

Create a variable called multiply that holds a lambda to multiply two numbers.

Call the calculate function with add and multiply lambdas and print the results.

💡 Why This Matters

🌍 Real World

Passing lambdas to functions is common in apps to customize behavior, like sorting lists or handling user actions.

💼 Career

Understanding lambdas and higher-order functions is important for Kotlin developers working on Android apps or backend services.

1

Create the calculate function

Write a function called calculate that takes two Int parameters named a and b, and a lambda parameter named operation of type (Int, Int) -> Int. The function should return the result of calling operation(a, b).

Kotlin

// Write the calculate function here

Hint

Remember, the lambda parameter operation takes two Ints and returns an Int. Use it inside the function to get the result.

2

Create lambdas for addition and multiplication

Create a variable called add that holds a lambda to add two Int numbers. Also create a variable called multiply that holds a lambda to multiply two Int numbers.

Kotlin

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

// Create add and multiply lambdas here

Hint

Use the syntax { x, y -> x + y } to create a lambda that adds two numbers.

3

Call calculate with lambdas

Call the calculate function with arguments 5 and 3 using the add lambda, and store the result in a variable called sumResult. Then call calculate with the same numbers using the multiply lambda, and store the result in a variable called productResult.

Kotlin

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

val add: (Int, Int) -> Int = { x, y -> x + y }
val multiply: (Int, Int) -> Int = { x, y -> x * y }

// Call calculate with add and multiply lambdas and save results

Hint

Call calculate with 5, 3, and the lambda variable like add.

4

Print the results

Print the values of sumResult and productResult on separate lines using println.

Kotlin

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

val add: (Int, Int) -> Int = { x, y -> x + y }
val multiply: (Int, Int) -> Int = { x, y -> x * y }

val sumResult = calculate(5, 3, add)
val productResult = calculate(5, 3, multiply)

// Print sumResult and productResult

Hint

Use println(sumResult) and println(productResult) to show the results.

Practice

1. What is a lambda in Kotlin when passed to a function?

easy

A. A small block of code that can be passed and executed inside the function

B. A type of variable that stores numbers

C. A special kind of loop

D. A keyword to declare a class

Solution

1. Step 1: Understand what a lambda is

   A lambda is a small piece of code that you can write inline and pass around like a value.

2. Step 2: Recognize its use in functions

   Functions can accept lambdas to customize behavior without changing the function code.

3. Final Answer:

   A small block of code that can be passed and executed inside the function -> Option A

4. Quick Check:

   Lambda = small code block passed to function [OK]

Hint: Lambdas are code blocks you pass to functions [OK]

Common Mistakes:

• Thinking lambda is a variable type
• Confusing lambda with loops
• Believing lambda is a keyword for classes

2. Which of the following is the correct syntax to pass a lambda to a function in Kotlin?

easy

A. fun greet(action: Unit -> ()) { action() } greet { println("Hi") }

B. fun greet(action: () -> Unit) { action() } greet { println("Hi") }

C. fun greet(action: () -> Unit) { action } greet { println("Hi") }

D. fun greet(action: () -> Unit) { action() } greet(println("Hi"))

Solution

1. Step 1: Check function parameter type

   The function expects a lambda with no parameters and no return value: () -> Unit.

2. Step 2: Check how lambda is called and passed

   Inside the function, calling action() executes the lambda. Passing greet { println("Hi") } is correct syntax.

3. Final Answer:

   fun greet(action: () -> Unit) { action() } greet { println("Hi") } -> Option B

4. Quick Check:

   Correct lambda syntax = fun greet(action: () -> Unit) { action() } greet { println("Hi") } [OK]

Hint: Use () -> Unit and call lambda with () inside function [OK]

Common Mistakes:

• Wrong lambda type syntax
• Forgetting to call lambda with ()
• Passing lambda as function argument incorrectly

3. What will be the output of this Kotlin code?

fun operate(x: Int, action: (Int) -> Int): Int {
    return action(x)
}

fun main() {
    val result = operate(5) { it * 2 }
    println(result)
}

medium

A. 5

B. 25

C. 10

D. Compilation error

Solution

1. Step 1: Understand the operate function

   It takes an integer and a lambda that doubles the integer (it * 2).

2. Step 2: Calculate the result

   Passing 5 to the lambda doubles it to 10, which is returned and printed.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   5 * 2 = 10 [OK]

Hint: Trace lambda input and output carefully [OK]

Common Mistakes:

• Confusing input and output values
• Forgetting lambda parameter 'it'
• Assuming no return from lambda

4. Identify the error in this Kotlin code snippet:

fun applyOperation(x: Int, op: (Int) -> Int) {
    op(x)
}

fun main() {
    applyOperation(3) { println(it * 3) }
}

medium

A. No error, code runs fine

B. The function applyOperation should return Int but returns Unit

C. The lambda syntax is incorrect

D. The lambda passed does not return a value but function expects Int return

Solution

1. Step 1: Check function signature and lambda

   applyOperation expects a lambda returning Int, but the lambda only prints and returns Unit.

2. Step 2: Understand mismatch consequences

   Because the lambda returns Unit, but function expects Int, this causes a type mismatch error.

3. Final Answer:

   The lambda passed does not return a value but function expects Int return -> Option D

4. Quick Check:

   Lambda return type mismatch = The lambda passed does not return a value but function expects Int return [OK]

Hint: Match lambda return type with function parameter type [OK]

Common Mistakes:

• Ignoring return type mismatch
• Thinking println returns Int
• Assuming no return needed for lambdas

5. You want to write a Kotlin function filterAndTransform that takes a list of integers and two lambdas: one to filter the list and one to transform each filtered item. Which of these function signatures correctly allows passing both lambdas?

hard

A. fun filterAndTransform(list: List<Int>, filter: (Int) -> Boolean, transform: (Int) -> Int): List<Int>

B. fun filterAndTransform(list: List<Int>, filter: Int, transform: Int): List<Int>

C. fun filterAndTransform(list: List<Int>, filter: (Int) -> Int, transform: (Int) -> Boolean): List<Int>

D. fun filterAndTransform(list: List<Int>, filter: () -> Boolean, transform: () -> Int): List<Int>

Solution

1. Step 1: Identify correct lambda types for filtering and transforming

   Filtering needs a lambda that takes Int and returns Boolean; transforming needs a lambda that takes Int and returns Int.

2. Step 2: Match function signature with these lambda types

   fun filterAndTransform(list: List<Int>, filter: (Int) -> Boolean, transform: (Int) -> Int): List<Int> matches these types correctly; others have wrong parameter or return types.

3. Final Answer:

   fun filterAndTransform(list: List<Int>, filter: (Int) -> Boolean, transform: (Int) -> Int): List<Int> -> Option A

4. Quick Check:

   Filter returns Boolean, transform returns Int [OK]

Hint: Filter lambda returns Boolean, transform lambda returns transformed value [OK]

Common Mistakes:

• Using wrong lambda parameter or return types
• Confusing filter and transform lambda roles
• Using lambdas with no parameters