Type inference in Rust - Mini Project: Build & Apply

Type inference

📖 Scenario: You are writing a small Rust program to calculate the total price of items in a shopping cart. Rust can often figure out the type of variables automatically, which is called type inference. This helps you write cleaner code without always specifying types.

🎯 Goal: Build a Rust program that uses type inference to calculate the total price of items in a cart and print the result.

📋 What You'll Learn

Create a variable called prices that holds a list of item prices as floating-point numbers.

Create a variable called total initialized to zero using type inference.

Use a for loop with variables price to iterate over prices and add each price to total.

Print the total price using println!.

💡 Why This Matters

🌍 Real World

Type inference helps programmers write cleaner and shorter code without losing safety. It is used in many Rust programs to reduce clutter.

💼 Career

Understanding type inference is important for Rust developers to write efficient and readable code, which is valuable in software development jobs.

1

Create the list of prices

Create a variable called prices and set it to a list containing these floating-point numbers: 10.5, 20.0, and 5.75.

Rust

# Create a variable called prices with the values 10.5, 20.0, and 5.75
# Your code here

Hint

Use let prices = vec![10.5, 20.0, 5.75]; to create a vector of floats.

2

Create a total variable with type inference

Add a variable called total and set it to 0.0 without specifying its type explicitly.

Rust

fn main() {
    let prices = vec![10.5, 20.0, 5.75];
    // Create a variable called total and set it to 0.0
    // Your code here
}

Hint

Write let total = 0.0; and let Rust figure out the type.

3

Add prices to total using a for loop

Use a for loop with variable price to iterate over prices and add each price to total. Use let mut total to allow changing total.

Rust

fn main() {
    let prices = vec![10.5, 20.0, 5.75];
    let mut total = 0.0;
    // Use a for loop to add each price to total
    // Your code here
}

Hint

Make total mutable with mut and add each price inside the loop.

4

Print the total price

Use println! to print the text Total price: followed by the value of total.

Rust

fn main() {
    let prices = vec![10.5, 20.0, 5.75];
    let mut total = 0.0;
    for price in prices {
        total += price;
    }
    // Print the total price
    // Your code here
}

Hint

Use println!("Total price: {}", total); to show the result.

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