Function references (::functionName) in Kotlin - Step-by-Step Execution

Concept Flow - Function references (::functionName)

Define function

↓

Use :: to get reference

↓

Pass reference as argument

↓

Call function via reference

↓

Get result/output

This flow shows how a function is defined, referenced using ::, passed around, and called later.

Execution Sample

Kotlin

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

fun main() {
    val greeter = ::greet
    println(greeter("Alice"))
}

This code defines a function greet, gets its reference with ::greet, assigns it to greeter, and calls it.

Execution Table

Step	Action	Evaluation	Result/Output
1	Define function greet	fun greet(name: String) = "Hello, $name!"	Function greet ready
2	Get reference ::greet	::greet	Function reference assigned to greeter
3	Call greeter("Alice")	greeter("Alice") calls greet("Alice")	"Hello, Alice!"
4	Print output	println(...) prints result	Hello, Alice!

💡 Program ends after printing the greeting.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
greeter	undefined	Function reference to greet	N/A (called)	Function reference to greet

Key Moments - 3 Insights

Why do we use ::greet instead of just greet?

Using ::greet gets the function itself as a value (a reference), not calling it. See execution_table step 2 where ::greet assigns the reference.

What happens when we call greeter("Alice")?

Calling greeter("Alice") actually calls the original greet function with "Alice". See execution_table step 3 for this call and result.

Can we store function references in variables?

Yes, variables like greeter can hold function references, letting us call the function later. This is shown in variable_tracker and steps 2-3.

Visual Quiz - 3 Questions

Look at the execution_table, what is stored in greeter after step 2?

A A function reference to greet

B The string "Hello, Alice!"

C The result of calling greet

D Nothing, greeter is undefined

💡 Hint

Check variable_tracker column 'After Step 2' for greeter's value.

At which step does the program print the greeting message?

A Step 1

B Step 4

C Step 3

D Step 2

💡 Hint

Look at execution_table row with action 'Print output'.

If we replaced ::greet with greet() in step 2, what would happen?

A greeter would be null

B greeter would hold the function reference

C greeter would hold the result of greet called with no arguments (error)

D Program would print "Hello, Alice!" immediately

💡 Hint

Calling greet() without arguments causes error; ::greet gets reference without calling.

Concept Snapshot

Function references (::functionName) let you treat functions as values.
Use :: before a function name to get its reference.
Store references in variables to call functions later.
Calling the reference runs the original function.
Useful for passing functions as arguments or callbacks.

Full Transcript

This example shows how Kotlin functions can be referenced using the :: operator. First, a function greet is defined that takes a name and returns a greeting string. Then, ::greet gets the function reference and assigns it to a variable greeter. Calling greeter("Alice") calls the original greet function with "Alice" and returns "Hello, Alice!". Finally, the result is printed. The execution table traces each step: defining the function, getting the reference, calling via the reference, and printing the output. The variable tracker shows greeter holds the function reference after step 2. Key moments clarify why :: is needed to get the reference, how calling the reference works, and that variables can store function references. The quiz tests understanding of what is stored, when output happens, and what happens if :: is omitted. This teaches how function references enable flexible, reusable code by treating functions as values.

Practice

1. What does the Kotlin syntax ::functionName represent?

easy

A. A call to the function named functionName

B. A comment about the function named functionName

C. A variable declaration named functionName

D. A reference to the function named functionName

Solution

1. Step 1: Understand the :: operator in Kotlin

   The :: operator is used to get a reference to a function, not to call it.

2. Step 2: Differentiate between calling and referencing

   Calling a function uses parentheses like functionName(), while referencing uses ::functionName.

3. Final Answer:

   A reference to the function named functionName -> Option D

4. Quick Check:

   Function reference = ::functionName [OK]

Hint: Remember :: means 'point to function', not call it [OK]

Common Mistakes:

• Confusing function reference (::) with function call (())
• Thinking :: declares a variable
• Assuming :: is a comment or annotation

2. Which of the following is the correct syntax to pass a function reference to map in Kotlin?

easy

A. list.map(::functionName)

B. list.map(:functionName)

C. list.map(functionName())

D. list.map(functionName)

Solution

1. Step 1: Identify how to pass function references in Kotlin

   Function references use the :: operator before the function name when passed as arguments.

2. Step 2: Check each option for correct syntax

   list.map(::functionName) uses ::functionName, which is the correct way to pass a function reference to map.

3. Final Answer:

   list.map(::functionName) -> Option A

4. Quick Check:

   Pass function reference with :: [OK]

Hint: Use :: before function name when passing as argument [OK]

Common Mistakes:

• Passing function call instead of reference (using parentheses)
• Omitting :: operator
• Using incorrect single colon : instead of double ::

3. What is the output of this Kotlin code?

fun square(x: Int) = x * x
val numbers = listOf(1, 2, 3)
val squares = numbers.map(::square)
println(squares)

medium

A. [1, 4, 9]

B. [square, square, square]

C. [1, 2, 3]

D. Compilation error

Solution

1. Step 1: Understand the function reference usage

   The ::square passes the square function to map, which applies it to each element.

2. Step 2: Calculate the result of applying square to each number

   Applying square to 1, 2, 3 gives 1, 4, 9 respectively.

3. Final Answer:

   [1, 4, 9] -> Option A

4. Quick Check:

   map(::square) squares each element [OK]

Hint: map(::function) applies function to each list item [OK]

Common Mistakes:

• Expecting original list instead of transformed list
• Confusing function reference with function call
• Thinking output is function names instead of results

4. Identify the error in this Kotlin code snippet:

fun greet(name: String) = "Hello, $name"
val greeter = greet
println(greeter("Alice"))

medium

A. Missing parentheses when assigning function reference

B. Cannot assign function directly without :: operator

C. Function greet must return Unit

D. No error, code runs fine

Solution

1. Step 1: Check how function references are assigned

   Assigning a function to a variable requires the :: operator to get a reference.

2. Step 2: Identify the missing :: operator

   The code assigns greet instead of ::greet, causing a type mismatch error.

3. Final Answer:

   Cannot assign function directly without :: operator -> Option B

4. Quick Check:

   Use :: to assign function reference [OK]

Hint: Use :: when assigning function to variable [OK]

Common Mistakes:

• Assigning function name without ::
• Adding parentheses which calls function instead of referencing
• Assuming function must return Unit

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

fun isEven(n: Int) = n % 2 == 0
val numbers = listOf(1, 2, 3, 4, 5, 6)
val evenNumbers = numbers.filter(::isEven)
println(evenNumbers)

Choose the correct output and explain why function references are useful here.

hard

A. [true, false, true, false, true, false]

B. [1, 3, 5]

C. [2, 4, 6]

D. Compilation error due to filter usage

Solution

1. Step 1: Understand the function reference with filter

   The ::isEven passes the isEven function to filter, which keeps elements where the function returns true.

2. Step 2: Apply isEven to each number and filter

   Numbers 2, 4, and 6 are even, so they remain in the filtered list.

3. Step 3: Explain usefulness of function references

   Function references let us pass existing functions easily without writing extra lambdas.

4. Final Answer:

   [2, 4, 6] -> Option C

5. Quick Check:

   filter(::isEven) keeps even numbers [OK]

Hint: filter(::function) keeps items where function returns true [OK]

Common Mistakes:

• Confusing filter with map output
• Expecting boolean list instead of filtered list
• Not using :: for function reference