Generic structs in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a generic struct in Rust?

A generic struct in Rust is a struct that can hold data of any type, specified when the struct is used. It uses type parameters to be flexible and reusable.

beginner

How do you define a generic struct with one type parameter in Rust?

You add angle brackets with a type parameter after the struct name, like <T>. For example:

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

intermediate

Can a generic struct have multiple type parameters? How?

Yes. You list multiple type parameters separated by commas inside the angle brackets. For example:

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

beginner

How do you create an instance of a generic struct with a specific type?

You specify the type when creating the instance or let Rust infer it. For example: <br><pre>let p = Point { x: 5, y: 10 }; // Rust infers T = i32
let p2: Point<f64> = Point { x: 1.0, y: 4.0 };</pre>

beginner

Why use generic structs instead of fixed-type structs?

Generic structs let you write flexible and reusable code. You can use the same struct for different data types without rewriting it for each type.

How do you declare a generic struct named Container with one type parameter T?

A struct Container<T> value: T;

B struct Container<T> { value: T }

C struct Container { T value }

D struct Container<T> (value: T);

The correct syntax uses angle brackets after the struct name to declare the type parameter T.

What does this code do?
struct Pair { first: T, second: U }

A Defines a struct with fixed types T and U

B Defines a struct with one generic type T

C Defines a struct with two generic types T and U

D Defines a function with generic parameters

The struct Pair has two generic type parameters T and U, allowing it to hold two values of possibly different types.

How do you create an instance of Point<f64> with x=1.0 and y=2.0?

A let p = Point<f64>(1.0, 2.0);

B let p: Point<f64> = Point { x: 1.0, y: 2.0 };

C let p = Point { x: 1.0, y: 2.0 };

D Both B and C are correct

Rust can infer the type from the values or you can specify it explicitly.

Why are generic structs useful?

A They allow code reuse for different data types

B They make code slower

C They restrict structs to one type only

D They are only used for functions

Generic structs let you write one struct that works with many types, improving code reuse.

Which of these is NOT a valid generic struct declaration?

A struct Box { T value }

B struct Info<T, U> { first: T, second: U }

C struct Wrapper<T> (T);

D struct Data<T> { value: T }

Option A is invalid because it does not declare T as a generic parameter properly.

Explain what a generic struct is and how you define one in Rust.

Think about how you make a struct work with any type.

Describe how to create and use an instance of a generic struct with multiple type parameters.

Remember to specify types or let Rust infer them.

Practice

1. What does the <T> mean in the definition of a generic struct in Rust?

easy

A. It specifies a fixed type that the struct must always use.

B. It declares a placeholder type that can be replaced with any type when used.

C. It is used to define a function inside the struct.

D. It marks the struct as unsafe to use.

Solution

1. Step 1: Understand generic type parameters

   The <T> syntax declares a generic type parameter named T, which acts as a placeholder for any type.

2. Step 2: Recognize its purpose in structs

   This allows the struct to be flexible and work with any data type specified when creating an instance.

3. Final Answer:

   It declares a placeholder type that can be replaced with any type when used. -> Option B

4. Quick Check:

   Generic type parameter = placeholder type [OK]

Hint: Generic <T> means flexible type placeholder [OK]

Common Mistakes:

• Thinking <T> fixes the type permanently
• Confusing <T> with function syntax
• Assuming <T> makes the struct unsafe

2. Which of the following is the correct syntax to define a generic struct named Container with one generic type parameter T?

easy

A. struct Container<T> { value: T }

B. struct Container { T value }

C. struct Container<T> (value: T);

D. struct Container<T> = { value: T };

Solution

1. Step 1: Recall Rust struct syntax with generics

   Generic structs use struct Name<T> { field: T } syntax.

2. Step 2: Check each option

   struct Container<T> { value: T } matches the correct syntax with curly braces and generic parameter T. Options A, B, and D have syntax errors or wrong struct declaration styles.

3. Final Answer:

   struct Container<T> { value: T } -> Option A

4. Quick Check:

   Correct generic struct syntax = struct Container<T> { value: T } [OK]

Hint: Use struct Name<T> { field: T } for generic structs [OK]

Common Mistakes:

• Omitting angle brackets around T
• Using parentheses instead of braces
• Trying to assign struct with '='

3. What will be the output of this Rust code?

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

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

medium

A. 5 and 10

B. Pair { first: 5, second: 10 }

C. Compilation error due to missing type annotation

D. Runtime error

Solution

1. Step 1: Understand struct instantiation with generics

   The struct Pair is instantiated with integers 5 and 10, so T is inferred as i32.

2. Step 2: Analyze the println! macro output

   The macro prints the values of pair.first and pair.second separated by " and ".

3. Final Answer:

   5 and 10 -> Option A

4. Quick Check:

   Printing struct fields = 5 and 10 [OK]

Hint: Generic type inferred from values; prints fields directly [OK]

Common Mistakes:

• Expecting struct debug print without {:?}
• Thinking type annotation is mandatory here
• Assuming runtime error without reason

4. Identify the error in this generic struct code and choose the fix:

struct Wrapper<T> {
    value: T
}

fn main() {
    let w: Wrapper = Wrapper { value: 42 };
}

medium

A. Wrapper struct must have a lifetime parameter

B. Missing semicolon after struct field declaration

C. Cannot assign integer to generic type T

D. Missing generic type parameter in variable declaration: use Wrapper<i32>

Solution

1. Step 1: Check struct usage with generics

   The variable w is declared as Wrapper without specifying the generic type <T>, which is required.

2. Step 2: Fix by specifying the type

   Adding <i32> to Wrapper in the declaration fixes the error: let w: Wrapper<i32> = ....

3. Final Answer:

   Missing generic type parameter in variable declaration: use Wrapper<i32> -> Option D

4. Quick Check:

   Specify generic type when declaring variables [OK]

Hint: Always specify generic type when declaring variables [OK]

Common Mistakes:

• Forgetting to add <T> in variable type
• Thinking semicolon is missing after field
• Assuming lifetime needed without context

5. Given this generic struct and function, what is the output?

struct Container<T> {
    item: T,
}

impl<T> Container<T> {
    fn new(item: T) -> Self {
        Container { item }
    }

    fn describe(&self) -> String {
        match &self.item {
            i if i.is::<i32>() => "Integer container".to_string(),
            _ => "Other container".to_string(),
        }
    }
}

fn main() {
    let c = Container::new(100);
    println!("{}", c.describe());
}

hard

A. Integer container

B. Other container

C. Compilation error due to is::<i32>() usage

D. Runtime panic

Solution

1. Step 1: Analyze the use of is::<i32>() in match

   The method is::<i32>() does not exist on generic references in Rust; this causes a compilation error.

2. Step 2: Understand Rust type checking limitations

   Rust does not support runtime type checking like is::<i32>() on generic types without special traits or macros.

3. Final Answer:

   Compilation error due to is::<i32>() usage -> Option C

4. Quick Check:

   Rust generics lack runtime type checks like is::<Type>() [OK]

Hint: Rust generics can't check type at runtime without traits [OK]

Common Mistakes:

• Assuming is::<Type>() works on generics
• Expecting output without compilation errors
• Ignoring Rust's static typing rules