Lambda syntax and declaration in Kotlin - Step-by-Step Execution

Concept Flow - Lambda syntax and declaration

Start

↓

Declare Lambda

↓

Assign Lambda to Variable

↓

Call Lambda

↓

Execute Lambda Body

↓

Return Result

↓

End

This flow shows how a lambda is declared, assigned to a variable, called, and executed to produce a result.

Execution Sample

Kotlin

val sum: (Int, Int) -> Int = { a, b -> a + b }
val result = sum(3, 4)
println(result)

This code declares a lambda that adds two integers, calls it with 3 and 4, and prints the result.

Execution Table

Step	Action	Evaluation	Result
1	Declare lambda 'sum' with parameters a, b	Lambda created	sum holds lambda (a, b) -> a + b
2	Call sum(3, 4)	Invoke lambda with a=3, b=4	Execute body: 3 + 4
3	Calculate 3 + 4	Addition	7
4	Assign result	result = 7	result holds 7
5	Print result	println(7)	Output: 7

💡 Lambda executed and result printed, program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4	Final
sum	undefined	lambda (a, b) -> a + b	lambda (a, b) -> a + b	lambda (a, b) -> a + b	lambda (a, b) -> a + b
result	undefined	undefined	undefined	7	7

Key Moments - 3 Insights

Why do we write the lambda parameters before the arrow '->' inside the braces?

The parameters before '->' define inputs to the lambda. This is shown in Step 1 where 'a, b' are declared before '->' to receive values when called.

How does the lambda get called and executed?

In Step 2, calling sum(3, 4) passes 3 and 4 to the lambda parameters, then Step 3 executes the body 'a + b' with these values.

What type does the variable 'sum' have?

In Step 1, 'sum' is declared with type '(Int, Int) -> Int', meaning it takes two Ints and returns an Int, matching the lambda signature.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'result' after Step 4?

A 7

B 3

C undefined

D sum lambda

💡 Hint

Check the 'result' variable in variable_tracker after Step 4.

At which step is the lambda body 'a + b' actually executed?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'Evaluation' column in execution_table where addition happens.

If we change the lambda to { x, y -> x * y }, what changes in the execution table?

A Step 5 output changes to 7

B Step 3 result changes to 12

C Step 2 changes to call sum(3, 4)

D No changes

💡 Hint

Multiplying 3 and 4 gives 12 instead of 7, check Step 3 result.

Concept Snapshot

Lambda syntax in Kotlin:
val name: (Type1, Type2) -> ReturnType = { param1, param2 -> expression }
- Parameters before '->' inside braces
- Expression after '->' is the body
- Call lambda like a function: name(arg1, arg2)
- Lambda returns the last expression value
- Useful for short, inline functions

Full Transcript

This visual trace shows how to declare and use a lambda in Kotlin. First, a lambda is declared with parameters and a body expression. It is assigned to a variable with a function type. Then, calling the lambda passes arguments to parameters, executes the body, and returns the result. The variable 'result' stores this output, which is printed. Key points include the syntax of parameters before the arrow, calling the lambda like a function, and the lambda returning the last expression. The execution table and variable tracker help visualize each step clearly.

Practice

1. What is a lambda expression in Kotlin?

easy

A. A small unnamed function stored in a variable

B. A class declaration

C. A type of loop

D. A way to declare variables

Solution

1. Step 1: Understand lambda basics

   Lambdas are small functions without a name that can be stored in variables.

2. Step 2: Compare with other options

   Classes, loops, and variable declarations are different concepts from lambdas.

3. Final Answer:

   A small unnamed function stored in a variable -> Option A

4. Quick Check:

   Lambda = unnamed function [OK]

Hint: Lambdas are unnamed functions in curly braces [OK]

Common Mistakes:

• Confusing lambdas with classes
• Thinking lambdas are loops
• Mixing lambdas with variable declarations

2. Which of the following is the correct syntax for a lambda that takes two Ints and returns their sum?

easy

A. { a, b : Int -> a + b }

B. (a, b) -> { a + b }

C. fun(a, b) { return a + b }

D. { a, b -> a + b }

Solution

1. Step 1: Recall lambda syntax

   Lambdas use curly braces with parameters before an arrow, then the body: { params -> body }

2. Step 2: Check each option

   { a, b -> a + b } matches correct syntax. (a, b) -> { a + b } wrongly uses parentheses outside braces. fun(a, b) { return a + b } is a function, not a lambda. { a, b : Int -> a + b } incorrectly places type annotation.

3. Final Answer:

   { a, b -> a + b } -> Option D

4. Quick Check:

   Correct lambda syntax = { params -> body } [OK]

Hint: Lambdas use braces with arrow separating params and body [OK]

Common Mistakes:

• Using parentheses instead of braces
• Trying to write full function syntax
• Incorrect type annotations inside lambda

3. What is the output of this Kotlin code?

val multiply = { x: Int, y: Int -> x * y }
println(multiply(3, 4))

medium

A. 12

B. 7

C. 34

D. Error

Solution

1. Step 1: Understand the lambda function

   The lambda takes two Ints x and y, and returns their product x * y.

2. Step 2: Calculate the output

   Calling multiply(3, 4) returns 3 * 4 = 12.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply parameters inside lambda to get output [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Syntax errors in lambda call

4. Identify the error in this Kotlin lambda declaration:

val greet = { name String -> "Hello, $name" }

medium

A. Lambda body must be outside braces

B. Arrow is missing after parameters

C. Missing colon between parameter and type

D. Cannot use string interpolation in lambda

Solution

1. Step 1: Check parameter syntax

   Parameters must have a colon between name and type: name: String

2. Step 2: Verify lambda structure

   The arrow -> is present after parameters, and string interpolation is allowed inside lambdas.

3. Final Answer:

   Missing colon between parameter and type -> Option C

4. Quick Check:

   Parameter syntax = name: Type [OK]

Hint: Use colon between param name and type in lambdas [OK]

Common Mistakes:

• Omitting colon in parameter declaration
• Forgetting arrow after parameters
• Thinking string interpolation is disallowed

5. How can you declare a lambda in Kotlin that filters a list of integers to keep only even numbers?

hard

A. val evenFilter = { list: List<Int> -> list.filter(it % 2 == 0) }

B. val evenFilter = { list: List<Int> -> list.filter { it % 2 == 0 } }

C. val evenFilter = { list: List<Int> -> list.filter { x -> x / 2 == 0 } }

D. val evenFilter = { list: List<Int> -> list.filter { x -> x % 2 = 0 } }

Solution

1. Step 1: Understand filter usage

   filter takes a lambda returning true for elements to keep. Correct condition is x % 2 == 0 for even numbers.

2. Step 2: Check each option

   val evenFilter = { list: List<Int> -> list.filter { it % 2 == 0 } } correctly uses filter with lambda and modulus check. val evenFilter = { list: List<Int> -> list.filter(it % 2 == 0) } misses braces for lambda. val evenFilter = { list: List<Int> -> list.filter { x -> x / 2 == 0 } } uses division instead of modulus. val evenFilter = { list: List<Int> -> list.filter { x -> x % 2 = 0 } } uses assignment (=) instead of comparison (==).

3. Final Answer:

   val evenFilter = { list: List<Int> -> list.filter { it % 2 == 0 } } -> Option B

4. Quick Check:

   Filter with { it % 2 == 0 } keeps evens [OK]

Hint: Use filter { it % 2 == 0 } to select even numbers [OK]

Common Mistakes:

• Using assignment (=) instead of comparison (==)
• Using division (/) instead of modulus (%)
• Omitting braces around lambda in filter