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.