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.