Type inference in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code using type inference?

Consider the following Rust code snippet. What will it print when run?

Rust

fn main() {
    let x = 5;
    let y = 10.0;
    let z = x as f64 + y;
    println!("{}", z);
}

A 15

B 15.0

C 15.00

D Compilation error

💡 Hint

Remember that Rust infers types and you can cast integers to floats.

The integer x is cast to f64, then added to y which is f64. The result is printed as 15.0 by println! macro.

❓ Predict Output

intermediate

What type does Rust infer for this variable?

Look at this Rust code. What type does Rust infer for variable `v`?

Rust

fn main() {
    let v = vec![1, 2, 3];
    println!("{}", v.len());
}

A Compilation error due to ambiguous type

B Vec<u32>

C Vec<f64>

D Vec<i32>

💡 Hint

Integer literals default to i32 unless specified otherwise.

Rust infers the vector type as Vec because the integer literals are i32 by default.

🔧 Debug

advanced

Why does this Rust code fail to compile?

This Rust code does not compile. What is the cause of the error?

Rust

fn main() {
    let x = "hello";
    let y = x + " world";
    println!("{}", y);
}

A Cannot add &str to &str directly; no implementation of `Add` for &str

B println! macro syntax error

C Variable y is not mutable

D Missing semicolon after let x declaration

💡 Hint

In Rust, string slices (&str) cannot be added with + operator directly.

Rust does not implement the + operator for &str and &str. You must convert to String or use format! macro.

❓ Predict Output

advanced

What is the output of this Rust code with type inference and shadowing?

Analyze this Rust code. What will it print?

Rust

fn main() {
    let x = 5;
    let x = x + 1.0;
    println!("{}", x);
}

A Compilation error due to mismatched types

B 6.0

C 6

D Runtime panic

💡 Hint

Rust does not automatically convert integer to float in arithmetic.

The first x is i32, the second x tries to add i32 + f64 which is a type mismatch causing a compile error.

🧠 Conceptual

expert

How does Rust's type inference handle generic functions?

Given this generic function, what type does Rust infer for `T` when calling `identity(42)`?

Rust

fn identity<T>(x: T) -> T {
    x
}

fn main() {
    let a = identity(42);
    println!("{}", a);
}

A Compilation error due to ambiguous type

B T is inferred as u32

C T is inferred as i32

D T is inferred as f64

💡 Hint

Integer literals default to i32 unless specified otherwise.

Rust infers T as i32 because 42 is an integer literal defaulting to i32.

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