Closures and variable capture in Kotlin - Mini Project: Build & Apply

Closures and Variable Capture in Kotlin

📖 Scenario: Imagine you are creating a simple counter system where each counter remembers its own count. This is useful in many apps like tracking clicks or scores.

🎯 Goal: You will build a Kotlin program that creates counters using closures. Each counter will remember its own count and increase it when called.

📋 What You'll Learn

Create a function that returns another function (a closure)

Use a variable inside the outer function to keep count

The inner function should increase and return the count

Create multiple counters to show they keep separate counts

Print the counts to see the closure in action

💡 Why This Matters

🌍 Real World

Closures are used in apps to keep track of user actions, like clicks or scores, without using global variables.

💼 Career

Understanding closures helps in writing clean, modular code and is important for many programming jobs involving functional programming or event handling.

1

Create a function with a count variable

Write a function called makeCounter that declares a variable count initialized to 0 inside it.

Kotlin

fun makeCounter(): () -> Int {
    // Your code here
}

Need a hint?

Think of count as the memory inside the function that will keep track of the number.

2

Return a function that increases count

Inside makeCounter, return a lambda function that increases count by 1 and returns the new value.

Kotlin

fun makeCounter(): () -> Int {
    var count = 0
    // Return a lambda that increments and returns count
    // Your code here
}

Need a hint?

The returned lambda remembers the count variable and changes it each time it is called.

3

Create two counters and call them

Create two variables counterA and counterB by calling makeCounter(). Then call counterA() twice and counterB() once, storing the results in a1, a2, and b1 respectively.

Kotlin

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count += 1
        count
    }
}

// Create two counters and call them
// Your code here

Need a hint?

Each counter should keep its own count separate from the other.

4

Print the counts to see closure effect

Print the values of a1, a2, and b1 each on its own line using println.

Kotlin

fun makeCounter(): () -> Int {
    var count = 0
    return {
        count += 1
        count
    }
}

val counterA = makeCounter()
val counterB = makeCounter()

val a1 = counterA()
val a2 = counterA()
val b1 = counterB()

// Print the counts
// Your code here

Need a hint?

Each print shows how the counters remember their own counts separately.