Companion vs top-level functions decision in Kotlin - Visual Side-by-Side Comparison

Concept Flow - Companion vs top-level functions decision

Start

↓

Need function?

↓

Is function related to class state?

Yes→Use companion object function

No↓

Use top-level function

↓

Function called

↓

Execution

↓

End

Decide if a function belongs inside a companion object (related to class) or as a top-level function (independent). Then call and execute it.

Execution Sample

Kotlin

class MyClass {
  companion object {
    fun companionFun() = "Companion"
  }
}

fun topLevelFun() = "Top-level"

Defines a companion object function and a top-level function, showing two ways to organize functions.

Execution Table

Step	Action	Function Called	Output
1	Call MyClass.companionFun()	companionFun	"Companion"
2	Call topLevelFun()	topLevelFun	"Top-level"
3	Decide function placement	N/A	companionFun inside class, topLevelFun outside
4	End of calls	N/A	Execution complete

💡 All functions executed, decision on placement shown

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
Output	N/A	"Companion"	"Top-level"	N/A

Key Moments - 2 Insights

Why put a function inside a companion object instead of top-level?

Because companion object functions are tied to the class and can access its private members, as shown in step 1 of execution_table.

Can top-level functions access class private members?

No, top-level functions are independent and cannot access private class members, unlike companion functions (see step 3).

Visual Quiz - 3 Questions

Look at the execution_table, what is the output when calling MyClass.companionFun()?

A "Top-level"

B "Companion"

C null

D Error

💡 Hint

Check step 1 in execution_table where companionFun is called

At which step does the decision about function placement happen?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Action' column in execution_table for decision making

If a function needs to access private class data, where should it be placed?

A Outside any class

B Top-level function

C Companion object function

D In a separate file

💡 Hint

Refer to key_moments about access to private members

Concept Snapshot

Companion object functions belong to the class and can access private members.
Top-level functions are independent and live outside classes.
Use companion functions for class-related behavior.
Use top-level functions for general utilities.
Call companion functions with ClassName.function(), top-level directly by name.

Full Transcript

This visual trace shows how to decide between companion object functions and top-level functions in Kotlin. First, if a function needs to access or relate to class state, put it inside the companion object. Otherwise, use a top-level function. The execution table shows calling both types and their outputs. Variables track outputs after each call. Key moments clarify why companion functions can access private class data, unlike top-level functions. The quiz tests understanding of outputs, decision steps, and placement rules. The snapshot summarizes the main points for quick recall.