Why lambdas enable functional style in Kotlin - Quick Recap

Recall & Review

beginner

What is a lambda in Kotlin?

A lambda is a small function without a name that can be passed around as a value. It lets you write code blocks that can be used like variables.

beginner

How do lambdas help write functional style code?

Lambdas let you treat functions as data. This means you can pass functions to other functions, return them, and compose them, which is key in functional programming.

beginner

What is a real-life example of using a lambda in Kotlin?

Using a lambda to filter a list: val evens = numbers.filter { it % 2 == 0 } filters even numbers using a lambda that checks if a number is even.

intermediate

Why does functional style prefer lambdas over traditional functions?

Lambdas are concise and can be created inline, making code shorter and easier to read. They also support higher-order functions, which are essential in functional programming.

intermediate

What is a higher-order function and how do lambdas relate to it?

A higher-order function takes functions as parameters or returns them. Lambdas are often used as the functions passed to or returned from these higher-order functions.

What is a lambda in Kotlin?

A An anonymous function that can be passed as a value

B A named function with parameters

C A class that holds data

D A type of variable

A lambda is an anonymous function that can be passed around as a value.

Which feature of lambdas supports functional programming?

A They cannot return values

B They can only be used once

C They must have a name

D They can be passed as arguments to functions

Lambdas can be passed as arguments, enabling higher-order functions, a key part of functional programming.

What does this Kotlin code do? numbers.filter { it > 5 }

A Sorts the numbers

B Filters numbers greater than 5 using a lambda

C Removes all numbers

D Adds 5 to each number

The lambda { it > 5 } filters the list to keep numbers greater than 5.

Why are lambdas preferred in functional style over traditional functions?

A Because they cannot be reused

B Because they require more code

C Because they are concise and can be used inline

D Because they do not support parameters

Lambdas are concise and inline, making functional code cleaner and easier to read.

What is a higher-order function?

A A function that takes or returns other functions

B A function with many parameters

C A function that runs faster

D A function that cannot use lambdas

Higher-order functions take functions as input or return them, often using lambdas.

Explain how lambdas enable functional programming style in Kotlin.

Think about how functions can be treated like data.

Describe a simple example of using a lambda in Kotlin to filter a list.

Focus on how the lambda defines the filtering rule.

Practice

1. Why do lambdas enable a functional programming style in Kotlin?

easy

A. Because they automatically optimize code for speed

B. Because they replace all loops with recursion

C. Because they require explicit variable declarations

D. Because they allow passing functions as arguments to other functions

Solution

1. Step 1: Understand what lambdas do

   Lambdas are small functions that can be passed around like data.

2. Step 2: Connect lambdas to functional style

   Functional programming relies on passing behavior (functions) as arguments, which lambdas enable.

3. Final Answer:

   Because they allow passing functions as arguments to other functions -> Option D

4. Quick Check:

   Lambdas enable passing behavior = C [OK]

Hint: Lambdas let you pass functions like data [OK]

Common Mistakes:

• Thinking lambdas only replace loops
• Believing lambdas optimize speed automatically
• Confusing lambdas with variable declarations

2. Which of the following is the correct syntax for a lambda expression in Kotlin?

easy

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

B. val sum = (a: Int, b: Int) => a + b

C. val sum = fun(a: Int, b: Int) { return a + b }

D. val sum = lambda(a: Int, b: Int) -> a + b

Solution

1. Step 1: Recall Kotlin lambda syntax

   Kotlin lambdas use curly braces with parameters before the arrow, like { a, b -> ... }.

2. Step 2: Compare options

   val sum = { a: Int, b: Int -> a + b } matches Kotlin syntax. Options B, C, and D use syntax from other languages or incorrect forms.

3. Final Answer:

   val sum = { a: Int, b: Int -> a + b } -> Option A

4. Quick Check:

   Kotlin lambdas use { params -> body } = A [OK]

Hint: Kotlin lambdas use curly braces and arrow -> [OK]

Common Mistakes:

• Using => instead of -> in Kotlin
• Writing full function syntax inside lambda
• Using 'lambda' keyword which Kotlin doesn't have

3. What is the output of this Kotlin code?

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

medium

A. Compilation error

B. [1, 2, 3, 4]

C. [2, 4, 6, 8]

D. [3, 6, 9, 12]

Solution

1. Step 1: Understand the map function with lambda

   map applies the lambda to each element, here multiplying each by 2.

2. Step 2: Calculate the transformed list

   1*2=2, 2*2=4, 3*2=6, 4*2=8, so the list becomes [2, 4, 6, 8].

3. Final Answer:

   [2, 4, 6, 8] -> Option C

4. Quick Check:

   map doubles each element = [2, 4, 6, 8] [OK]

Hint: map applies lambda to each list item [OK]

Common Mistakes:

• Thinking map modifies original list
• Confusing map with filter
• Expecting syntax error due to lambda

4. Identify the error in this Kotlin code using lambdas:

val list = listOf(1, 2, 3)
val filtered = list.filter { it > 2 }
val result = filtered.map { it * 2 }
println(result)

medium

A. Syntax error in lambda expression

B. No error; code runs and prints [6]

C. filter should be replaced with map

D. map cannot be used after filter

Solution

1. Step 1: Analyze filter and map usage

   filter keeps elements greater than 2, so only 3 remains.

2. Step 2: Apply map to filtered list

   map multiplies 3 by 2, resulting in [6].

3. Final Answer:

   No error; code runs and prints [6] -> Option B

4. Quick Check:

   filter then map works fine = A [OK]

Hint: filter then map is valid chain [OK]

Common Mistakes:

• Assuming syntax error in lambdas
• Thinking map can't follow filter
• Confusing filter and map roles

5. Given a list of names, how can lambdas help you create a map of name lengths only for names longer than 3 characters?
Choose the correct Kotlin code snippet.

hard

A. val result = names.filter { it.length > 3 }.associate { it to it.length }

B. val result = names.map { it.length > 3 }.associateWith { it.length }

C. val result = names.associate { if (it.length > 3) it to it.length }

D. val result = names.map { it.length > 3 }.associate { it to it.length }

Solution

1. Step 1: Filter names longer than 3 characters

   Use filter { it.length > 3 } to keep only long names.

2. Step 2: Create a map of name to length

   Use associate { it to it.length } to map each name to its length.

3. Final Answer:

   val result = names.filter { it.length > 3 }.associate { it to it.length } -> Option A

4. Quick Check:

   filter then associate with pairs = B [OK]

Hint: Filter first, then associate with pairs [OK]

Common Mistakes:

• Using associateWith incorrectly
• Trying to map booleans instead of names
• Returning null in associate causing errors