Type inference by the compiler in Kotlin - Step-by-Step Execution

Concept Flow - Type inference by the compiler

Start

↓

Declare variable with initializer

↓

Compiler analyzes initializer

↓

Infer variable type

↓

Assign inferred type to variable

↓

Use variable with inferred type

↓

End

The compiler looks at the value assigned to a variable and figures out its type automatically, so you don't have to write it.

Execution Sample

Kotlin

val number = 42
val text = "Hello"
val isActive = true

This code declares three variables and the compiler infers their types from the assigned values.

Execution Table

Step	Code Line	Action	Inferred Type	Variable Value
1	val number = 42	Compiler sees 42 (an integer)	Int	42
2	val text = "Hello"	Compiler sees "Hello" (a string)	String	"Hello"
3	val isActive = true	Compiler sees true (a boolean)	Boolean	true
4	Use variables	Variables have inferred types	number: Int, text: String, isActive: Boolean	42, "Hello", true

💡 All variables have their types inferred from their initial values.

Variable Tracker

Variable	Start	After Inference	Final
number	untyped	Int	Int
text	untyped	String	String
isActive	untyped	Boolean	Boolean

Key Moments - 2 Insights

Why don't we need to write the type explicitly?

Because the compiler looks at the value assigned (like 42 or "Hello") and automatically figures out the type, as shown in steps 1-3 of the execution table.

What happens if we try to assign a different type later?

The compiler will give an error because the variable's type is fixed after inference, as seen in step 4 where variables keep their inferred types.

Visual Quiz - 3 Questions

Look at the execution table, what type does the compiler infer for the variable 'text' at step 2?

A String

B Boolean

C Int

D Double

💡 Hint

Check the 'Inferred Type' column at step 2 in the execution table.

At which step does the compiler assign the type Boolean?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Inferred Type' column and find where 'Boolean' appears.

If we change 'val number = 42' to 'val number = 42.0', how would the inferred type change?

A It would become String

B It would stay Int

C It would become Double

D It would cause a compiler error

💡 Hint

Consider the type of 42.0 in Kotlin and how the compiler infers types from initial values.

Concept Snapshot

Type inference lets Kotlin figure out variable types from assigned values.
Use 'val' or 'var' with an initializer, no need to write the type.
Compiler checks the value and sets the variable's type automatically.
Once inferred, the variable's type cannot change.
Example: val x = 10 // x is Int
This makes code shorter and easier to read.

Full Transcript

In Kotlin, when you declare a variable with 'val' or 'var' and assign it a value, the compiler automatically figures out the variable's type by looking at the value. For example, if you write 'val number = 42', the compiler sees 42 is an integer and sets the type of 'number' to Int. This means you don't have to write 'val number: Int = 42' explicitly. The compiler does this for each variable with an initializer. Once the type is set, you cannot assign a different type to that variable later. This feature helps keep code clean and easy to write.

Practice

1. What does type inference mean in Kotlin?

easy

A. The compiler automatically figures out the variable's type.

B. You must always specify the variable type manually.

C. The program runs slower because types are guessed at runtime.

D. It means variables cannot change their values.

Solution

1. Step 1: Understand type inference concept

   Type inference means the compiler looks at the value assigned and decides the variable's type automatically.

2. Step 2: Compare options with definition

   Only The compiler automatically figures out the variable's type. correctly describes this automatic type detection by the compiler.

3. Final Answer:

   The compiler automatically figures out the variable's type. -> Option A

4. Quick Check:

   Type inference = automatic type detection [OK]

Hint: Type inference means no need to write types explicitly [OK]

Common Mistakes:

• Thinking types are guessed at runtime
• Believing you must always write types
• Confusing type inference with variable mutability

2. Which of the following Kotlin variable declarations uses type inference correctly?

easy

A. val number: String = 10

B. val number: Int = "10"

C. val number = 10

D. val number =

Solution

1. Step 1: Check each declaration for correctness

   val number = 10 assigns 10 to 'number' without specifying type, so compiler infers Int type correctly.

2. Step 2: Identify errors in other options

   val number: Int = "10" assigns a String to Int type explicitly - error. val number: String = 10 assigns Int to String type - error. val number = is incomplete syntax.

3. Final Answer:

   val number = 10 -> Option C

4. Quick Check:

   Correct syntax with inferred type = val number = 10 [OK]

Hint: Look for variable with value but no explicit type [OK]

Common Mistakes:

• Mixing types in assignment
• Leaving declaration incomplete
• Assigning wrong type to explicit type

3. What is the inferred type of result in this Kotlin code?

val result = listOf(1, 2, 3).map { it * 2 }

medium

A. Array<Int>

B. List<Int>

C. Int

D. List<String>

Solution

1. Step 1: Analyze the expression assigned to result

   listOf(1, 2, 3) creates a List<Int>. The map function multiplies each element by 2, so the result is a List<Int>.

2. Step 2: Confirm the inferred type

   Since map returns a List of the transformed elements, the inferred type is List<Int>.

3. Final Answer:

   List<Int> -> Option B

4. Quick Check:

   Mapping Int list with Int operation = List<Int> [OK]

Hint: map keeps list type, changes element type if needed [OK]

Common Mistakes:

• Confusing List with Array
• Thinking map returns a single Int
• Assuming type changes to String

4. Identify the error in this Kotlin code snippet related to type inference:

val x = null
val y = x + 5

medium

A. Cannot add Int to null value

B. x cannot be null without explicit type

C. Type inference infers x as Int automatically

D. No error, code runs fine

Solution

1. Step 1: Understand type inference for null assignment

   Assigning null without type makes x's type Nothing?, which cannot be used in arithmetic.

2. Step 2: Check the operation y = x + 5

   Adding 5 to null is invalid; Kotlin does not allow arithmetic with null values.

3. Final Answer:

   Cannot add Int to null value -> Option A

4. Quick Check:

   Arithmetic with null causes error [OK]

Hint: Null needs explicit type; can't do math with null [OK]

Common Mistakes:

• Assuming null has Int type
• Ignoring null safety rules
• Thinking code compiles without error

5. Given this Kotlin code, what is the inferred type of data?

val data = mapOf("a" to 1, "b" to 2).mapValues { it.value * 10 }

hard

A. List>

B. List<Int>

C. Map

D. Map

Solution

1. Step 1: Analyze mapOf and mapValues usage

   mapOf creates a Map. mapValues transforms each value by multiplying by 10, keeping keys same.

2. Step 2: Determine the resulting type

   mapValues returns a Map with the same key type and transformed value type, so Map.

3. Final Answer:

   Map -> Option D

4. Quick Check:

   mapValues keeps Map type, changes values [OK]

Hint: mapValues keeps Map type, changes only values [OK]

Common Mistakes:

• Confusing mapValues with map returning List
• Assuming values become Strings
• Thinking result is a List instead of Map