Map-backed delegated properties in Kotlin - Step-by-Step Execution

Concept Flow - Map-backed delegated properties

Start with Map holding data

↓

Declare class with properties delegated to Map

↓

Access property

↓

Delegate fetches value from Map by key

↓

Return value as property result

↓

End

The property delegates get their values from a Map by using the property name as the key.

Execution Sample

Kotlin

class User(val map: Map<String, Any?>) {
  val name: String by map
  val age: Int    by map
}

val user = User(mapOf("name" to "Alice", "age" to 30))
println(user.name)
println(user.age)

This code creates a User whose properties get values from a Map, then prints those values.

Execution Table

Step	Action	Property Accessed	Map Key Used	Value Retrieved	Output
1	Create User instance	-	-	-	-
2	Access user.name	name	name	Alice	Alice
3	Access user.age	age	age	30	30
4	End	-	-	-	-

💡 All properties accessed successfully from the map; program ends.

Variable Tracker

Variable	Start	After 1	After 2	Final
user.map	empty	{name=Alice, age=30}	{name=Alice, age=30}	{name=Alice, age=30}
user.name	uninitialized	uninitialized	Alice	Alice
user.age	uninitialized	uninitialized	uninitialized	30

Key Moments - 2 Insights

Why does accessing user.name fetch "Alice" from the map?

Because the property 'name' is delegated to the map, so when accessed, it looks up the key 'name' in the map and returns its value, as shown in execution_table step 2.

What happens if the map does not contain a key for a delegated property?

Accessing that property will throw an exception because the map lookup will fail. This is implied by the delegation mechanism shown in the flow and execution steps.

Visual Quiz - 3 Questions

Look at the execution table, what value is retrieved when user.age is accessed?

A "Alice"

B 30

C null

D Exception

💡 Hint

Check execution_table row 3 under 'Value Retrieved' column.

At which step does the property 'name' get its value from the map?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at execution_table row 2 where 'Property Accessed' is 'name'.

If the map did not have the key "age", what would happen when accessing user.age?

A It returns 0 by default

B It returns null

C It throws an exception

D It returns "age" string

💡 Hint

Delegated properties require the key to exist in the map; missing keys cause errors as implied in key_moments.

Concept Snapshot

Map-backed delegated properties in Kotlin let class properties get their values from a Map.
Syntax: val prop: Type by map
When you access prop, it looks up the key "prop" in the map and returns the value.
If the key is missing, an exception occurs.
This is useful for dynamic or flexible data storage.

Full Transcript

This visual execution shows how Kotlin's map-backed delegated properties work. We start with a Map holding keys and values. A class declares properties delegated to this map. When we access a property like user.name, the delegation fetches the value from the map using the property name as the key. The execution table traces each step: creating the user, accessing name and age, and retrieving their values from the map. The variable tracker shows how user.name and user.age get their values after access. Key moments clarify why the property fetches from the map and what happens if a key is missing. The quiz tests understanding of these steps and outcomes. This helps beginners see exactly how delegation to a map works in Kotlin.