Higher-order function declaration in Kotlin - Step-by-Step Execution

Concept Flow - Higher-order function declaration

Define function

↓

Function takes function as parameter or returns function

↓

Call higher-order function

↓

Inside, passed function is called or returned function is used

↓

Result produced

A higher-order function is declared by defining a function that takes another function as a parameter or returns a function. When called, it uses the passed or returned function to produce a result.

Execution Sample

Kotlin

fun operate(x: Int, y: Int, op: (Int, Int) -> Int): Int {
    return op(x, y)
}

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

This code declares a higher-order function 'operate' that takes two integers and a function 'op'. It calls 'op' with the integers. Then it calls 'operate' with a sum lambda and prints the result.

Execution Table

Step	Action	Evaluation	Result
1	Call operate(3, 4, lambda)	op = lambda {a,b -> a+b}	Proceed to function body
2	Inside operate: call op(3,4)	op(3,4) = 3 + 4	7
3	Return 7 from operate	return 7	sum = 7
4	Print sum	println(7)	Output: 7

💡 Function operate completes and program ends after printing 7

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
x	undefined	3	undefined	undefined
y	undefined	4	undefined	undefined
op	undefined	lambda {a,b -> a+b}	undefined	undefined
sum	undefined	undefined	7	7

Key Moments - 2 Insights

Why do we pass a function as a parameter instead of calling it directly?

Passing a function as a parameter lets the higher-order function decide when and how to call it, as shown in step 2 of the execution_table where 'op' is called inside 'operate'.

What does the syntax '(Int, Int) -> Int' mean in the parameter list?

It means the parameter 'op' is a function that takes two Ints and returns an Int, matching the lambda passed in step 1 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'sum' after step 3?

A 7

B 3

C undefined

D lambda function

💡 Hint

Check the 'Result' column in step 3 where 'sum' is assigned the return value.

At which step is the lambda function 'op' actually called?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column to find when 'op(3,4)' is evaluated.

If we changed the lambda to { a, b -> a * b }, what would be printed at step 4?

A 34

B 7

C 12

D Error

💡 Hint

Multiply 3 and 4 as per the new lambda, check step 2 logic.

Concept Snapshot

Higher-order function declaration in Kotlin:
fun functionName(param: Type, op: (Type, Type) -> ReturnType): ReturnType {
  return op(param, param)
}
Pass functions as parameters using lambda syntax.
Call passed function inside the higher-order function.
Useful for flexible, reusable code.

Full Transcript

This visual trace shows how to declare and use a higher-order function in Kotlin. The function 'operate' takes two integers and a function 'op' as parameters. When called, it invokes 'op' with the integers. The example uses a lambda that sums two numbers. Step-by-step, the code calls 'operate', then inside it calls the lambda, returns the result, and prints it. Variables like 'x', 'y', 'op', and 'sum' change values as the program runs. Common confusions include why functions are passed as parameters and the meaning of function types. The quiz tests understanding of variable values and function calls during execution.

Practice

1. What is a higher-order function in Kotlin?

easy

A. A function that only returns integers

B. A function that takes another function as a parameter or returns a function

C. A function that cannot be called directly

D. A function that has no parameters

Solution

1. Step 1: Understand the definition of higher-order functions

   Higher-order functions are functions that can take other functions as parameters or return them as results.

2. Step 2: Match the definition with the options

   A function that takes another function as a parameter or returns a function correctly describes this behavior, while others describe unrelated function properties.

3. Final Answer:

   A function that takes another function as a parameter or returns a function -> Option B

4. Quick Check:

   Higher-order function = function with function parameter or return [OK]

Hint: Remember: higher-order means function uses another function [OK]

Common Mistakes:

• Thinking higher-order means function returns only numbers
• Confusing higher-order with functions without parameters
• Assuming higher-order functions cannot be called directly

2. Which of the following is the correct syntax to declare a higher-order function in Kotlin that takes a function parameter returning Int?

easy

A. fun operate(x: Int, f: Int): Int { return f(x) }

B. fun operate(x: Int, f: (Int) Int): Int { return f(x) }

C. fun operate(x: Int, f: (Int) -> Int): Int { return f(x) }

D. fun operate(x: Int, f: (Int) -> Int) { return f(x) }

Solution

1. Step 1: Identify correct function type syntax

   Kotlin uses (Type) -> ReturnType to declare function types. fun operate(x: Int, f: (Int) -> Int): Int { return f(x) } uses (Int) -> Int correctly.

2. Step 2: Check function return and parameter usage

   fun operate(x: Int, f: (Int) -> Int): Int { return f(x) } returns Int and calls f(x) properly. fun operate(x: Int, f: Int): Int { return f(x) } treats f as Int, not a function. fun operate(x: Int, f: (Int) Int): Int { return f(x) } misses arrow. fun operate(x: Int, f: (Int) -> Int) { return f(x) } lacks return type.

3. Final Answer:

   fun operate(x: Int, f: (Int) -> Int): Int { return f(x) } -> Option C

4. Quick Check:

   Function type syntax = (Int) -> Int [OK]

Hint: Look for (Type) -> ReturnType syntax for function parameters [OK]

Common Mistakes:

• Omitting the arrow '->' in function type
• Using wrong parameter type instead of function type
• Missing return type in function declaration

3. What is the output of this Kotlin code?

fun applyTwice(x: Int, f: (Int) -> Int): Int {
    return f(f(x))
}

fun increment(n: Int) = n + 1

fun main() {
    println(applyTwice(3, ::increment))
}

medium

A. 5

B. 4

C. 6

D. 3

Solution

1. Step 1: Understand applyTwice function behavior

   applyTwice calls the function f twice on x: f(f(x)). Here, f is increment which adds 1.

2. Step 2: Calculate the output step-by-step

   First increment(3) = 4, then increment(4) = 5, so applyTwice(3, increment) returns 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Increment twice on 3 = 5 [OK]

Hint: Apply the function twice stepwise to find output [OK]

Common Mistakes:

• Applying function only once
• Confusing function call syntax
• Ignoring the nested function call

4. Identify the error in this Kotlin higher-order function declaration:

fun transform(x: Int, f: Int -> Int): Int {
    return f(x)
}

medium

A. Missing parentheses around function type parameter

B. Return type of transform is missing

C. Function parameter name is invalid

D. Function body syntax is incorrect

Solution

1. Step 1: Check function type syntax in parameter

   Function types must be enclosed in parentheses like (Int) -> Int. Here, f: Int -> Int is missing parentheses.

2. Step 2: Verify other parts of the function

   Return type Int is present, parameter name f is valid, and function body syntax is correct.

3. Final Answer:

   Missing parentheses around function type parameter -> Option A

4. Quick Check:

   Function type needs parentheses: (Int) -> Int [OK]

Hint: Always wrap function types in parentheses (Type) -> ReturnType [OK]

Common Mistakes:

• Omitting parentheses around function type
• Confusing parameter name with type
• Missing return type declaration

5. How would you declare a Kotlin higher-order function named compose that takes two functions f and g (both from Int to Int) and returns a new function from Int to Int that applies g then f?

hard

A. fun compose(f: (Int) -> Int, g: (Int) -> Int): Int = f(g(0))

B. fun compose(f: Int, g: Int): Int = { x -> f(g(x)) }

C. fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int = f(g)

D. fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int = { x -> f(g(x)) }

Solution

1. Step 1: Understand function composition signature

   compose takes two functions f and g, both (Int) -> Int, and returns a function (Int) -> Int.

2. Step 2: Check the lambda expression for composition

   The returned function applies g first, then f: { x -> f(g(x)) }. fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int = { x -> f(g(x)) } matches this exactly.

3. Final Answer:

   fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int = { x -> f(g(x)) } -> Option D

4. Quick Check:

   Compose = return lambda applying g then f [OK]

Hint: Return a lambda applying g then f: { x -> f(g(x)) } [OK]

Common Mistakes:

• Returning wrong type instead of function
• Using incorrect parameter types
• Trying to call functions instead of returning a lambda