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

Concept Flow - Type inference by the compiler

Start

↓

Declare variable with value

↓

Compiler checks value type

↓

Compiler assigns variable type

↓

Use variable with inferred type

↓

End

The compiler looks at the value assigned to a variable and automatically decides the variable's type without needing explicit type annotation.

Execution Sample

Swift

let number = 42
let message = "Hello"
let pi = 3.14

This code declares three constants with values, and the compiler infers their types as Int, String, and Double respectively.

Execution Table

Step	Code Line	Action	Inferred Type	Variable Value
1	let number = 42	Assign 42 to number	Int	42
2	let message = "Hello"	Assign "Hello" to message	String	"Hello"
3	let pi = 3.14	Assign 3.14 to pi	Double	3.14
4	End	All variables declared with inferred types	-	-

💡 All variables have been assigned values, so the compiler infers their types and finishes.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
number	uninitialized	42 (Int)	42 (Int)	42 (Int)	42 (Int)
message	uninitialized	uninitialized	"Hello" (String)	"Hello" (String)	"Hello" (String)
pi	uninitialized	uninitialized	uninitialized	3.14 (Double)	3.14 (Double)

Key Moments - 3 Insights

Why don't we need to write the type explicitly like 'let number: Int = 42'?

Because the compiler looks at the value '42' and automatically knows 'number' should be an Int, as shown in execution_table step 1.

What happens if we assign a value of a different type later to the same variable?

In Swift, variables declared with 'let' are constants and cannot change. Also, the compiler fixes the type at declaration, so assigning a different type later would cause an error.

How does the compiler know that 3.14 is a Double and not a Float?

By default, Swift treats decimal numbers like 3.14 as Double, so the compiler infers 'pi' as Double in execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What type does the compiler infer for 'message'?

A Double

B Int

C String

D Bool

💡 Hint

Check the 'Inferred Type' column for step 2 in the execution_table.

At which step does the compiler infer the type Double?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

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

If we change 'let number = 42' to 'let number = 42.0', what type will the compiler infer?

A Int

B Double

C String

D Float

💡 Hint

Decimal numbers like 42.0 are inferred as Double by default in Swift.

Concept Snapshot

Type inference lets the compiler guess variable types from assigned values.
Syntax: let variable = value
No need to write type explicitly.
Compiler assigns type like Int, String, Double automatically.
Helps write cleaner and shorter code.

Full Transcript

In Swift, when you declare a variable or constant and assign it a value, the compiler automatically figures out the type of that variable. For example, if you write 'let number = 42', the compiler sees the number 42 and knows 'number' is an Int. This is called type inference. It means you don't have to write the type yourself. The compiler uses the value to decide the type. This works for strings, numbers with decimals, and more. The compiler fixes the type when you declare the variable, so you cannot later assign a different type to it. This feature helps you write code faster and cleaner without losing type safety.

Practice

1. What does type inference mean in Swift?

easy

A. The program runs slower because types are guessed.

B. You must always write the type explicitly.

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

D. You cannot use variables without specifying types.

Solution

1. Step 1: Understand type inference concept

   Type inference means the compiler guesses the type of a variable based on the value assigned.

2. Step 2: Compare options with definition

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

3. Final Answer:

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

4. Quick Check:

   Type inference = automatic type detection [OK]

Hint: Type inference means compiler guesses type automatically [OK]

Common Mistakes:

• Thinking you must always write types explicitly
• Believing type inference slows down the program
• Confusing type inference with dynamic typing

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

easy

A. let number = 10

B. let number: = 10

C. let number Int = 10

D. let number : Int 10

Solution

1. Step 1: Check syntax for variable declaration with type inference

   Type inference allows omitting the type, so let number = 10 is correct.

2. Step 2: Identify syntax errors in other options

   Options B, C, and D have syntax errors: missing type name, wrong order, or missing assignment operator.

3. Final Answer:

   let number = 10 -> Option A

4. Quick Check:

   Correct syntax with inference = let number = 10 [OK]

Hint: Look for correct Swift syntax without explicit type [OK]

Common Mistakes:

• Adding colon without type name
• Writing type before variable name incorrectly
• Omitting assignment operator

3. What is the type of variable value in this Swift code?

let value = 3.14

medium

A. Double

B. Int

C. String

D. Float

Solution

1. Step 1: Identify the literal type assigned

   The number 3.14 is a decimal number, which Swift treats as Double by default.

2. Step 2: Confirm Swift default for floating-point literals

   Swift infers floating-point literals as Double unless specified otherwise.

3. Final Answer:

   Double -> Option A

4. Quick Check:

   3.14 literal = Double type [OK]

Hint: Decimal numbers default to Double in Swift [OK]

Common Mistakes:

• Assuming 3.14 is Float by default
• Confusing Int with floating-point types
• Thinking literals default to String

4. Identify the error in this Swift code snippet:

var name = "Alice"
name = 42

medium

A. No error, type inference allows changing type.

B. Error: Cannot assign Int to a variable inferred as String.

C. Error: Missing semicolon after first line.

D. Error: Variable must be declared with explicit type.

Solution

1. Step 1: Check initial type inferred for variable

   Variable name is assigned a String "Alice", so compiler infers type String.

2. Step 2: Analyze reassignment with different type

   Assigning an Int (42) to a String variable causes a type mismatch error.

3. Final Answer:

   Error: Cannot assign Int to a variable inferred as String. -> Option B

4. Quick Check:

   Type mismatch on reassignment = Error [OK]

Hint: Variable type fixed by first assignment, cannot change later [OK]

Common Mistakes:

• Thinking type inference allows changing variable type
• Assuming semicolons are required in Swift
• Believing explicit type declaration is always needed

5. Given this Swift code, what is the type of result?

let numbers = [1, 2, 3]
let result = numbers.map { $0 * 2 }

hard

A. Array<Any>

B. Int

C. [Double]

D. [Int]

Solution

1. Step 1: Understand the type of numbers

   Array numbers contains Int values, so its type is [Int].

2. Step 2: Analyze the map operation and type inference

   The map multiplies each Int by 2, producing another Int for each element, so the result is an array of Ints.

3. Step 3: Confirm inferred type of result

   Since map returns an array of transformed elements, result is inferred as [Int].

4. Final Answer:

   [Int] -> Option D

5. Quick Check:

   map on [Int] with Int output = [Int] [OK]

Hint: map returns array of same type as transformed elements [OK]

Common Mistakes:

• Thinking map returns a single Int
• Assuming map changes type to Double automatically
• Believing result is Array<Any> without type inference