Returning functions from functions in Kotlin - Step-by-Step Execution

Concept Flow - Returning functions from functions

Call outerFunction

↓

outerFunction runs

↓

Create innerFunction

↓

Return innerFunction

↓

Call returned innerFunction

↓

innerFunction runs and returns result

The outer function creates and returns an inner function. Later, calling the returned function runs the inner function's code.

Execution Sample

Kotlin

fun outerFunction(): (Int) -> Int {
    return fun(x: Int): Int { return x * 2 }
}

val f = outerFunction()
println(f(5))

Defines a function that returns another function doubling its input, then calls it with 5.

Execution Table

Step	Action	Evaluation	Result
1	Call outerFunction()	Runs outerFunction body	Returns inner function (x) -> x * 2
2	Assign returned function to f	f now holds inner function	f = (x) -> x * 2
3	Call f(5)	Runs inner function with x=5	Returns 10
4	Print result	Output value	10

💡 Execution stops after printing the result of f(5)

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
f	undefined	function returned by outerFunction	function assigned	function called with 5	function remains assigned

Key Moments - 3 Insights

Why does outerFunction return a function instead of a value?

Because outerFunction's return type is a function type (Int) -> Int, it returns a function object, as shown in execution_table step 1.

How do we call the function returned by outerFunction?

We assign it to a variable (f) and then call f with an argument, as shown in execution_table steps 2 and 3.

What happens when we call f(5)?

The inner function runs with x=5 and returns 10, as shown in execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of calling f(5)?

A Function object

B 10

C 5

D Error

💡 Hint

Check execution_table row 3 where f(5) is called and returns 10.

At which step is the inner function created and returned?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at execution_table step 1 where outerFunction returns the inner function.

If we change outerFunction to return a function that triples x, what would f(5) return?

A 15

B 10

C 5

D Error

💡 Hint

Think about the inner function's return value when multiplying x by 3 instead of 2.

Concept Snapshot

fun outerFunction(): (Int) -> Int {
  return fun(x: Int): Int { return x * 2 }
}

val f = outerFunction()  // f is a function
println(f(5))           // prints 10

- Functions can return other functions.
- Returned functions can be called later.

Full Transcript

This example shows how a Kotlin function can return another function. The outerFunction returns an inner function that doubles its input. When we call outerFunction, it returns this inner function, which we store in variable f. Calling f(5) runs the inner function with 5, returning 10. This lets us create functions dynamically and use them later.

Practice

1. What does it mean when a Kotlin function returns another function?

easy

A. The function can only return primitive data types like Int or String.

B. The function cannot have parameters if it returns another function.

C. The outer function produces a function as its result that can be called later.

D. The returned function must be called immediately inside the outer function.

Solution

1. Step 1: Understand function return types

   In Kotlin, a function can return any type, including another function type.

2. Step 2: Interpret returning a function

   Returning a function means the outer function gives back a function that can be stored or called later.

3. Final Answer:

   The outer function produces a function as its result that can be called later. -> Option C

4. Quick Check:

   Returning a function means output is a callable function [OK]

Hint: Returning function means output is a callable function [OK]

Common Mistakes:

• Thinking only primitive types can be returned
• Assuming returned function must be called immediately
• Believing returned functions cannot have parameters

2. Which of the following is the correct syntax to declare a Kotlin function that returns another function taking an Int and returning a String?

easy

A. fun outer(): (Int) -> String = { i -> i.toString }

B. fun outer(): (Int) -> String { return { i -> i.toString() } }

C. fun outer(): (Int) String { return { i -> i.toString() } }

D. fun outer(): Int -> String = return { i -> i.toString() } }

Solution

1. Step 1: Check function return type syntax

   In Kotlin, a function returning another function uses syntax like: fun name(): (ParamType) -> ReturnType

2. Step 2: Verify the return statement

   The function returns a lambda matching (Int) -> String, e.g., { i -> i.toString() }

3. Final Answer:

   fun outer(): (Int) -> String { return { i -> i.toString() } } -> Option B

4. Quick Check:

   Correct function type syntax = fun outer(): (Int) -> String { return { i -> i.toString() } } [OK]

Hint: Return type for function is (ParamType) -> ReturnType [OK]

Common Mistakes:

• Using arrow -> incorrectly in return type
• Mixing return type syntax with function body
• Omitting parentheses around function type

3. What is the output of this Kotlin code?

fun makeMultiplier(x: Int): (Int) -> Int {
    return { y -> x * y }
}

fun main() {
    val multiplyBy3 = makeMultiplier(3)
    println(multiplyBy3(5))
}

medium

A. 35

B. 8

C. Compilation error

D. 15

Solution

1. Step 1: Understand makeMultiplier function

   makeMultiplier returns a function that multiplies its input by x (captured from outer function).

2. Step 2: Trace main function calls

   multiplyBy3 is a function multiplying by 3; multiplyBy3(5) = 3 * 5 = 15.

3. Final Answer:

   15 -> Option D

4. Quick Check:

   3 * 5 = 15 [OK]

Hint: Returned function uses captured outer variable [OK]

Common Mistakes:

• Confusing parameter names
• Forgetting the closure captures x
• Expecting immediate multiplication without calling returned function

4. Identify the error in this Kotlin code that tries to return a function:

fun outer(): (Int) -> Int {
    val inner = { x: Int -> x * 2 }
    return inner()
}

medium

A. Calling inner() instead of returning the function itself

B. Missing return type declaration for outer function

C. Incorrect lambda parameter syntax

D. Cannot return a lambda from a function

Solution

1. Step 1: Analyze return statement

   inner is a lambda function; inner() calls it and returns Int, not a function.

2. Step 2: Correct return value

   To return the function itself, return inner without parentheses.

3. Final Answer:

   Calling inner() instead of returning the function itself -> Option A

4. Quick Check:

   Return function, not function call [OK]

Hint: Return function name without () to return function itself [OK]

Common Mistakes:

• Returning function call instead of function
• Omitting function return type
• Misunderstanding lambda syntax

5. Given this Kotlin code, what will be the output?

fun createCounter(start: Int): () -> Int {
    var count = start
    return {
        count += 1
        count
    }
}

fun main() {
    val counter = createCounter(10)
    println(counter())
    println(counter())
}

hard

A. 11
12

B. 10
11

C. 12
13

D. Compilation error

Solution

1. Step 1: Understand closure capturing variable

   The returned lambda captures 'count' variable and increments it each call.

2. Step 2: Trace calls to counter()

   First call: count = 10 + 1 = 11; prints 11. Second call: count = 11 + 1 = 12; prints 12.

3. Final Answer:

   11 12 -> Option A

4. Quick Check:

   Closure increments count on each call [OK]

Hint: Closures keep state between calls [OK]

Common Mistakes:

• Assuming count resets each call
• Confusing initial value with first output
• Expecting compilation error due to var usage