Generic structs in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of generic struct instantiation

What is the output of this Rust code when run?

Rust

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let p = Point { x: 5, y: 10 };
    println!("({}, {})", p.x, p.y);
}

A (5, 10)

B (x, y)

C (0, 0)

D Compilation error

💡 Hint

Look at how the struct is instantiated with integers.

The struct Point is generic over type T. Here, T is inferred as i32 because 5 and 10 are integers. The println! macro prints the values of x and y, which are 5 and 10.

❓ Predict Output

intermediate

Output of generic struct with different types

What will this Rust program print?

Rust

struct Pair<T, U> {
    first: T,
    second: U,
}

fn main() {
    let pair = Pair { first: "hello", second: 42 };
    println!("{} and {}", pair.first, pair.second);
}

A 42 and hello

B hello and hello

C Compilation error due to mismatched types

D hello and 42

💡 Hint

Check the order of fields in the struct and the println! macro.

The struct Pair has two generic types T and U. Here, T is &str and U is i32. The println! macro prints first then second, so output is 'hello and 42'.

🔧 Debug

advanced

Identify the error in generic struct usage

What error does this Rust code produce when compiled?

Rust

struct Container<T> {
    value: T,
}

fn main() {
    let c: Container<i32> = Container { value: "text" };
}

A No error, compiles successfully

B Type mismatch error: expected i32 but found &str

C Syntax error: missing semicolon

D Missing lifetime specifier error

💡 Hint

Check the type of value assigned to the generic struct instance.

The struct Container expects a value of type i32, but a string slice &str is assigned, causing a type mismatch error.

🧠 Conceptual

advanced

Understanding generic struct methods

Given this Rust code, what is the output when main runs?

Rust

struct Wrapper<T> {
    item: T,
}

impl<T> Wrapper<T> {
    fn new(item: T) -> Self {
        Wrapper { item }
    }
    fn get_item(&self) -> &T {
        &self.item
    }
}

fn main() {
    let w = Wrapper::new(3.14);
    println!("{}", w.get_item());
}

A Compilation error: missing trait bound

B Wrapper { item: 3.14 }

C 3.14

D Runtime error

💡 Hint

Look at how the method get_item returns a reference to the item.

The Wrapper struct holds a generic item. The method get_item returns a reference to the item. Printing it shows 3.14.

❓ Predict Output

expert

Output of nested generic structs

What is the output of this Rust program?

Rust

struct Outer<T> {
    inner: Inner<T>,
}

struct Inner<U> {
    value: U,
}

fn main() {
    let o = Outer { inner: Inner { value: "Rust" } };
    println!("{}", o.inner.value);
}

A Rust

B Outer { inner: Inner { value: "Rust" } }

C Compilation error: cannot infer type

D Runtime panic

💡 Hint

Focus on how the nested structs hold and access the value.

Outer holds an Inner struct which holds a value of type &str. Printing o.inner.value prints 'Rust'.