Higher-order function declaration in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple higher-order function call

What is the output of this Kotlin code that uses a higher-order function?

Kotlin

fun operateOnNumber(x: Int, operation: (Int) -> Int): Int {
    return operation(x)
}

fun main() {
    val result = operateOnNumber(5) { it * 3 }
    println(result)
}

A Error: Missing return type

B 5

C 15

D 0

💡 Hint

Look at how the lambda multiplies the input by 3.

The function operateOnNumber takes an integer and a function that transforms an integer. The lambda multiplies 5 by 3, so the output is 15.

🧠 Conceptual

intermediate

Understanding function types in Kotlin

Which of the following is the correct Kotlin function type declaration for a function that takes a String and returns a Boolean?

A Boolean -> String

B (String) -> Boolean

C fun(String): Boolean

D String -> Boolean

💡 Hint

Function types use the arrow notation with parentheses around parameters.

In Kotlin, function types are declared as (ParameterType) -> ReturnType. So a function taking a String and returning a Boolean is (String) -> Boolean.

🔧 Debug

advanced

Identify the error in this higher-order function declaration

What error does this Kotlin code produce?

Kotlin

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

fun main() {
    println(applyTwice(2) { it + 3 })
}

A SyntaxError: Missing parentheses around function type parameter

B TypeError: Cannot invoke function

C No error, prints 8

D RuntimeException: Null pointer

💡 Hint

Check the function type syntax in the parameter list.

The function type parameter must be declared with parentheses around the parameter type: (Int) -> Int, not Int -> Int.

❓ Predict Output

advanced

Output of nested higher-order functions

What is the output of this Kotlin code?

Kotlin

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

fun main() {
    val add2 = { x: Int -> x + 2 }
    val times3 = { x: Int -> x * 3 }
    val combined = compose(add2, times3)
    println(combined(4))
}

A 14

B 18

C 24

D 20

💡 Hint

Remember the order of function composition: f(g(x)) means g runs first.

times3(4) = 12, then add2(12) = 14, so the output is 14.

🧠 Conceptual

expert

Effect of inline keyword on higher-order functions

What is the main benefit of declaring a higher-order function as inline in Kotlin?

A It disables the use of lambdas as parameters

B It allows the function to be called asynchronously

C It automatically caches the function result

D It reduces runtime overhead by avoiding object allocation for lambdas

💡 Hint

Think about performance and how lambdas are handled at runtime.

Inlining a higher-order function copies the function body at call sites, avoiding lambda object creation and improving performance.

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