Lambdas and Functional Programming

# CHAPTER 19

Lambdas and Functional Programming #

1. Chapter Introduction #

2. Learning Objectives #

• Write Lambda expressions using { }.

• Understand the it keyword.

• Use Trailing Lambda syntax.

• Transform lists using map.

• Search lists using filter.

3. What is a Lambda? #

fun main() {
    // A lambda assigned to a variable!
    // Type is: (Int, Int) -> Int
    val multiply = { a: Int, b: Int -> a * b }
    
    // Executing the lambda
    println(multiply(5, 4)) // Outputs 20
}

*Notice there is no return keyword in a lambda! The result of the LAST line of code inside the lambda is automatically returned.*

4. The Magic it Keyword #

fun main() {
    // Explicit way
    val square: (Int) -> Int = { num -> num * num }
    
    // Idiomatic Kotlin way using 'it'
    val fastSquare: (Int) -> Int = { it * it }
    
    println(fastSquare(5)) // Outputs 25
}

5. Trailing Lambda Syntax #

// A function taking a String and a Lambda
fun processData(data: String, action: (String) -> Unit) {
    action(data)
}

fun main() {
    // Without trailing lambda
    processData("Hello", { println(it.uppercase()) })
    
    // WITH Trailing Lambda (Idiomatic Kotlin!)
    processData("Hello") { 
        println(it.uppercase()) 
    }
}

6. Processing Collections (map, filter) #

#### map (Transforming) map applies the lambda to every item in the list and returns a new list of the results.

val numbers = listOf(1, 2, 3, 4)
// Multiplies every number by 10
val doubled = numbers.map { it * 10 } 

println(doubled) // [10, 20, 30, 40]

#### filter (Filtering) filter keeps items where the lambda evaluates to true.

val numbers = listOf(1, 2, 3, 4, 5, 6)
// Keeps only even numbers
val evens = numbers.filter { it % 2 == 0 } 

println(evens) // [2, 4, 6]

#### Chaining Operations Because these return new lists, you can chain them together elegantly!

val prices = listOf(5, 12, 8, 20)

val processed = prices
    .filter { it > 10 }   // Keep 12, 20
    .map { it * 2 }       // Double them: 24, 40
    
println(processed) // [24, 40]

7. Common Mistakes #

• Using return inside a lambda: Using the return keyword inside a standard lambda will actually try to return from the *enclosing function* (like main), not just the lambda. Remember: the last line of the lambda is automatically the return value!

• Overusing it: If a lambda contains complex logic over multiple lines, using it makes the code hard to read. Explicitly name your parameter (e.g., { student -> student.grade > 90 }).

8. Best Practices #

• Embrace Trailing Lambdas: This syntax is used everywhere in Kotlin (especially in Jetpack Compose UI for Android). Always move the lambda outside the parentheses if it is the last argument.

9. Exercises #

1. 1. Create a listOf names: "Alice", "Bob", "Amanda", "Charlie".

1. 2. Use .filter { ... } to find names that start with "A".

1. 3. Use .map { ... } to convert those names to uppercase.

1. 4. Print the final list.

10. MCQs with Answers #

Q9. Is numbers.filter { it > 5 }.map { it * 2 } valid syntax in Kotlin? a) Yes, functional operations can be chained b) No Answer: a) Yes.

11. Interview Questions #

• Q: Explain what the it keyword represents in Kotlin Lambdas. What is the condition for using it?

• Q: What is Trailing Lambda syntax? Why do modern Kotlin frameworks (like Jetpack Compose) rely on it so heavily? (Answer: Because it allows function calls to look like native language structures, building clean, readable hierarchical blocks).

12. Summary #

13. Next Chapter Recommendation #