Why functions are first-class in Kotlin - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function variable that adds two numbers.

Kotlin

val add: (Int, Int) -> Int = [1]

Drag options to blanks, or click blank then click option'

A{ a, b -> a + b }

Bfun add(a: Int, b: Int): Int = a + b

Ca + b

Dlambda(a, b) { a + b }

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to assign a function declaration instead of a lambda.

Using incorrect syntax like 'lambda' keyword which doesn't exist in Kotlin.

In Kotlin, you can assign a lambda expression to a variable to create a function value. The syntax { a, b -> a + b } defines a function that takes two integers and returns their sum.

2fill in blank

medium

Complete the code to pass a function as a parameter.

Kotlin

fun operate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
    return [1](x, y)
}

Drag options to blanks, or click blank then click option'

Ay

Boperation

Cx

Doperate

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to call the function by its own name instead of the parameter.

Using variables x or y as if they were functions.

The parameter operation is a function that takes two integers and returns an integer. To use it, call operation(x, y).

3fill in blank

hard

Fix the error in the code to assign a function reference to a variable.

Kotlin

fun greet(name: String) = "Hello, $name"

val greeter: (String) -> String = [1]

Drag options to blanks, or click blank then click option'

A::greet

Bgreet.name

Cgreet()

Dgreet{}

Attempts:

3 left

💡 Hint

Common Mistakes

Adding parentheses which calls the function instead of referencing it.

Using invalid syntax like greet.name or greet{}.

To assign a function reference in Kotlin, use ::greet without parentheses. Using ::greet assigns the function itself, not the result of calling it.

4fill in blank

hard

Fill both blanks to create a list of functions and call the first one.

Kotlin

val functions = listOf<(Int) -> Int>({ x -> x * 2 }, [1])

val result = functions[0]([2])
println(result)

Drag options to blanks, or click blank then click option'

A{ x -> x + 3 }

B5

C10

D{ y -> y - 1 }

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a function call instead of a lambda as the second list element.

Using a function call or variable instead of an integer argument.

The list contains two functions. The second function is a lambda that adds 3. To call the first function with an argument, pass a number like 5.

5fill in blank

hard

Fill all three blanks to filter and map a list using functions.

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)

val filtered = numbers.filter [1] 
val mapped = filtered.map [2] 

println(mapped) // Output: [3]

Drag options to blanks, or click blank then click option'

A{ it > 2 }

B{ it * 10 }

C[30, 40, 50]

D{ it < 3 }

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong filter condition like less than 3.

Mapping with addition instead of multiplication.

Expecting wrong output list.

The filter keeps numbers greater than 2. The map multiplies each by 10. So the output is [30, 40, 50].

Practice

1. Which of the following best explains why functions are considered first-class citizens in Kotlin?

easy

A. Because functions must always return a value.

B. Because functions cannot be nested inside other functions.

C. Because functions can be stored in variables, passed as arguments, and returned from other functions.

D. Because functions are only used for input/output operations.

Solution

1. Step 1: Understand the meaning of first-class functions

   First-class functions means functions can be treated like any other value: stored, passed, and returned.

2. Step 2: Match this meaning with the options

   Because functions can be stored in variables, passed as arguments, and returned from other functions. correctly states this ability, while others describe unrelated or incorrect facts.

3. Final Answer:

   Because functions can be stored in variables, passed as arguments, and returned from other functions. -> Option C

4. Quick Check:

   First-class functions = store, pass, return [OK]

Hint: Remember: first-class means functions act like variables [OK]

Common Mistakes:

• Thinking functions must always return a value
• Believing functions cannot be nested
• Confusing first-class with input/output only

2. Which of the following is the correct syntax to assign a lambda function to a variable in Kotlin?

easy

A. val greet = fun() { println("Hello") }

B. val greet = function() println("Hello")

C. val greet = lambda { println("Hello") }

D. val greet = () -> println("Hello")

Solution

1. Step 1: Recall Kotlin lambda syntax

   Kotlin lambda syntax uses arrow notation: () -> expression or block.

2. Step 2: Compare options with correct syntax

   val greet = () -> println("Hello") matches the correct lambda syntax. val greet = fun() { println("Hello") } is a named function expression, B and D are invalid syntax.

3. Final Answer:

   val greet = () -> println("Hello") -> Option D

4. Quick Check:

   Lambda syntax = () -> expression [OK]

Hint: Look for arrow notation () -> for lambdas [OK]

Common Mistakes:

• Using 'function()' keyword which doesn't exist
• Confusing named function with lambda syntax
• Using 'lambda' keyword which is invalid

3. What will be the output of the following Kotlin code?

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

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

medium

A. 8

B. 53

C. Error: Missing function body

D. 0

Solution

1. Step 1: Understand the operate function

   It takes two Ints and a function 'op' that combines them, then returns the result of op(x, y).

2. Step 2: Analyze the lambda passed

   The lambda { a, b -> a + b } adds the two numbers 5 and 3, so operate returns 8.

3. Final Answer:

   8 -> Option A

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Trace lambda execution with given inputs [OK]

Common Mistakes:

• Concatenating numbers as strings instead of adding
• Expecting syntax error due to lambda
• Ignoring the lambda parameter and outputting 0

4. Identify the error in the following Kotlin code that uses a function as a parameter:

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

fun main() {
    val result = applyOperation(4, 2) { a, b -> a * b
    println(result)
}

medium

A. Incorrect function parameter types.

B. Missing closing brace '}' for the lambda expression.

C. applyOperation should return Unit, not Int.

D. Lambda parameters must be declared outside the function call.

Solution

1. Step 1: Check lambda syntax in main()

   The lambda passed to applyOperation lacks a closing brace '}', causing a syntax error.

2. Step 2: Verify other parts

   Parameter types and return types are correct; lambda parameters inside call are valid.

3. Final Answer:

   Missing closing brace '}' for the lambda expression. -> Option B

4. Quick Check:

   Unclosed lambda = syntax error [OK]

Hint: Count opening and closing braces in lambdas [OK]

Common Mistakes:

• Assuming parameter types are wrong
• Thinking return type must be Unit
• Believing lambda parameters can't be inline

5. You want to create a Kotlin function that takes a list of integers and a function to transform each integer, returning a new list with transformed values. Which of the following implementations correctly uses first-class functions to achieve this?

hard

A. fun transformList(nums: List<Int>, transformer: (Int) -> Int): List<Int> {
val result = mutableListOf<Int>()
for (num in nums) {
result.add(transformer(num))
}
return result
}

B. fun transformList(nums: List<Int>, transformer: Int): List<Int> {
return nums.map { transformer }
}

C. fun transformList(nums: List<Int>): List<Int> {
return nums.map { it * 2 }
}

D. fun transformList(nums: List<Int>, transformer: (Int) -> Int): List<Int> {
nums.forEach { transformer(it) }
return nums
}

Solution

1. Step 1: Understand the requirement

   The function must accept a list and a function to transform each element, returning a new list with transformed values.

2. Step 2: Analyze each option

   fun transformList(nums: List<Int>, transformer: (Int) -> Int): List<Int> { val result = mutableListOf<Int>() for (num in nums) { result.add(transformer(num)) } return result } correctly takes a function parameter and applies it to each element, collecting results in a new list. fun transformList(nums: List<Int>, transformer: Int): List<Int> { return nums.map { transformer } } wrongly treats transformer as Int. fun transformList(nums: List<Int>): List<Int> { return nums.map { it * 2 } } lacks a transformer parameter. fun transformList(nums: List<Int>, transformer: (Int) -> Int): List<Int> { nums.forEach { transformer(it) } return nums } applies transformer but returns original list without changes.

3. Final Answer:

   fun transformList(nums: List<Int>, transformer: (Int) -> Int): List<Int> { val result = mutableListOf<Int>() for (num in nums) { result.add(transformer(num)) } return result } -> fun transformList(nums: List<Int>, transformer: (Int) -> Int): List<Int> { val result = mutableListOf<Int>() for (num in nums) { result.add(transformer(num)) } return result }

4. Quick Check:

   Function parameter + new list = fun transformList(nums: List<Int>, transformer: (Int) -> Int): List<Int> { val result = mutableListOf<Int>() for (num in nums) { result.add(transformer(num)) } return result } [OK]

Hint: Look for function parameter applied to each element and new list returned [OK]

Common Mistakes:

• Passing transformer as Int instead of function
• Not returning a new transformed list
• Using forEach without collecting results