Type inference in Rust - Step-by-Step Execution

Concept Flow - Type inference

Start: Declare variable without type

↓

Compiler guesses type from value

↓

Use variable in code

↓

Compiler checks if usage matches guessed type

↓

If matches, continue

↓

If mismatch, error

↓

End

Rust compiler guesses variable types from assigned values and checks usage to ensure correctness.

Execution Sample

Rust

fn main() {
    let x = 5;
    let y = 3.14;
    let z = "hello";
    println!("{} {} {}", x, y, z);
}

This code declares variables without explicit types; Rust infers their types from the assigned values.

Execution Table

Step	Code Line	Action	Inferred Type	Notes
1	let x = 5;	Declare x with value 5	i32	Integer literal defaults to i32
2	let y = 3.14;	Declare y with value 3.14	f64	Floating point literal defaults to f64
3	let z = "hello";	Declare z with value "hello"	&str	String slice type inferred
4	println!("{} {} {}", x, y, z);	Use variables in print	x:i32, y:f64, z:&str	Types used match inferred types
5	End of main	Program runs successfully	-	No type errors found

💡 All variables have inferred types matching their usage, so compilation succeeds.

Variable Tracker

Variable	Start	After Declaration	Final
x	undefined	5 (i32)	5 (i32)
y	undefined	3.14 (f64)	3.14 (f64)
z	undefined	"hello" (&str)	"hello" (&str)

Key Moments - 3 Insights

Why doesn't Rust need me to write the type for 'x'?

Rust looks at the value '5' assigned to 'x' and guesses it is an integer (i32). This is shown in execution_table row 1.

What happens if I use 'x' as a floating number later?

Rust will give a type error because 'x' was inferred as i32, but using it as a float conflicts. This would fail at step 4 in the execution_table.

How does Rust know 'z' is a string slice?

Because 'z' is assigned a string literal "hello", Rust infers the type &str as shown in execution_table row 3.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What type does Rust infer for variable 'y'?

A f64

B i32

C &str

D bool

💡 Hint

Check the 'Inferred Type' column in execution_table row 2.

At which step does Rust check if variable usage matches the inferred type?

A Step 1

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Action' column where variables are used in println! macro.

If you changed 'let x = 5;' to 'let x = 5.0;', how would the inferred type change?

A From i32 to &str

B From f64 to i32

C From i32 to f64

D No change, stays i32

💡 Hint

Consider how Rust infers types from numeric literals as shown in variable_tracker.

Concept Snapshot

Type inference in Rust:
- Declare variables without explicit types.
- Rust guesses type from assigned value.
- Integer literals default to i32.
- Floating literals default to f64.
- Compiler checks usage matches inferred type.
- Mismatches cause compile errors.

Full Transcript

This example shows how Rust infers types automatically. When you write 'let x = 5;', Rust sees the number 5 and decides 'x' is an integer (i32). For 'let y = 3.14;', Rust infers a floating-point number (f64). For string literals like 'let z = "hello";', Rust infers a string slice type (&str). The compiler then checks if you use these variables in ways that fit their types. If you try to use 'x' as a float later, Rust will give an error because it expects an integer. This process helps you write less code while keeping safety. The execution table shows each step of this inference and checking process.

Practice

1. What does Rust's type inference do when you write let x = 5; without specifying a type?

easy

A. Rust treats x as a string by default.

B. Rust throws a syntax error because the type is missing.

C. Rust requires you to write the type explicitly for all variables.

D. Rust guesses the type of x as i32 based on the value 5.

Solution

1. Step 1: Understand Rust's default integer type

   Rust uses i32 as the default integer type when no type is specified.

2. Step 2: Apply type inference to let x = 5;

   Since 5 is an integer literal, Rust infers x to be i32 automatically.

3. Final Answer:

   Rust guesses the type of x as i32 based on the value 5. -> Option D

4. Quick Check:

   Type inference = i32 for integer literals [OK]

Hint: Integer literals default to i32 if no type given [OK]

Common Mistakes:

• Thinking Rust requires explicit types always
• Assuming default type is string
• Believing missing types cause syntax errors

2. Which of the following is the correct syntax to let Rust infer the type of a floating-point number?

easy

A. let num = "3.14";

B. let num: f64 = 3.14;

C. let num = 3.14;

D. let num = 3,14;

Solution

1. Step 1: Identify valid floating-point syntax

   In Rust, floating-point literals use a dot (.) as decimal separator, so 3.14 is valid.

2. Step 2: Check type inference usage

   Writing let num = 3.14; lets Rust infer f64 type automatically.

3. Final Answer:

   let num = 3.14; -> Option C

4. Quick Check:

   Floating-point literals infer f64 by default [OK]

Hint: Use dot for decimals; omit type to infer f64 [OK]

Common Mistakes:

• Using comma instead of dot for decimals
• Confusing string literals with numbers
• Unnecessarily specifying type when inference works

3. What is the output of this Rust code?

let x = 10;
let y = 20.5;
let z = x as f64 + y;
println!("{}", z);

medium

A. 30.5

B. 30

C. Compilation error due to type mismatch

D. 10.20.5

Solution

1. Step 1: Understand type casting

   Variable x is i32, y is f64. Casting x as f64 converts it to floating-point.

2. Step 2: Calculate the sum

   After casting, 10.0 + 20.5 = 30.5. The println! prints this value.

3. Final Answer:

   30.5 -> Option A

4. Quick Check:

   Cast int to float, then add = 30.5 [OK]

Hint: Cast integers to float before adding floats [OK]

Common Mistakes:

• Expecting integer addition without cast
• Assuming implicit cast without as
• Confusing output format with concatenation

4. Identify the error in this Rust code snippet:

let a = 5;
let b = 2.0;
let c = a + b;

medium

A. Cannot add integer and floating-point without casting.

B. Variable a is not initialized.

C. Missing semicolon after let b = 2.0.

D. Rust does not support addition operator.

Solution

1. Step 1: Check variable types

   a is i32 (integer), b is f64 (floating-point).

2. Step 2: Understand addition rules in Rust

   Rust does not allow adding different numeric types directly; explicit casting is needed.

3. Final Answer:

   Cannot add integer and floating-point without casting. -> Option A

4. Quick Check:

   Mixed-type addition requires cast [OK]

Hint: Add only same types or cast explicitly [OK]

Common Mistakes:

• Ignoring type mismatch errors
• Assuming implicit conversion between int and float
• Overlooking Rust's strict type rules

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

let values = vec![1, 2, 3];
let result: Vec<f64> = values.iter().map(|&x| x as f64 * 1.5).collect();

hard

A. Vec<i32>

B. Vec<f64>

C. Vec<&i32>

D. Compilation error due to missing type annotation

Solution

1. Step 1: Analyze the iterator and map closure

   values.iter() produces references &i32. The closure |&x| x as f64 * 1.5 dereferences and casts x to f64, then multiplies.

2. Step 2: Collect into specified type

   The collect() call collects results into Vec<f64> as explicitly annotated.

3. Final Answer:

   Vec<f64> -> Option B

4. Quick Check:

   Mapping with cast and collecting matches annotated type [OK]

Hint: Check closure cast and collect type annotation [OK]

Common Mistakes:

• Confusing iterator item types with collected vector type
• Missing dereference in closure causing type errors
• Assuming collect infers wrong type without annotation