Generic structs in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a generic struct named Point with one type parameter T.

Rust

struct Point<[1]> {
    x: T,
    y: T,
}

Drag options to blanks, or click blank then click option'

AT

BU

CV

DX

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to declare the generic type parameter after the struct name.

Using a different letter in the struct declaration and fields.

The generic type parameter is declared inside angle brackets after the struct name. Here, T is the type parameter used for the fields.

2fill in blank

medium

Complete the code to create an instance of Point with i32 type.

Rust

let p = Point::<[1]>{ x: 5, y: 10 };

Drag options to blanks, or click blank then click option'

Af64

Bbool

CString

Di32

Attempts:

3 left

💡 Hint

Common Mistakes

Using a type that does not match the field values.

Omitting the type parameter when creating the instance.

To create a generic struct instance with a specific type, use the syntax Point::. Here, i32 is the integer type.

3fill in blank

hard

Fix the error in the struct definition to allow different types for x and y.

Rust

struct Point<[1], U> {
    x: T,
    y: U,
}

Drag options to blanks, or click blank then click option'

AT

BU

CV

DX

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong generic parameter name for the first type.

Not declaring enough generic parameters for the fields.

To have different types for x and y, declare two generic parameters T and U. The first parameter must be T to match the field x.

4fill in blank

hard

Fill both blanks to define a generic struct Pair with two type parameters and fields of those types.

Rust

struct Pair<[1], [2]> {
    first: T,
    second: U,
}

Drag options to blanks, or click blank then click option'

AT

BV

CU

DW

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the order of generic parameters.

Using generic parameters that don't match the field types.

The struct has two generic parameters T and U. The fields first and second use these types respectively.

5fill in blank

hard

Fill all three blanks to create a generic struct Triple with three type parameters and fields.

Rust

struct Triple<[1], [2], [3]> {
    a: X,
    b: Y,
    c: Z,
}

Drag options to blanks, or click blank then click option'

AX

BY

CZ

DT

Attempts:

3 left

💡 Hint

Common Mistakes

Using fewer generic parameters than fields.

Using generic parameters that don't match the field names.

The struct has three generic parameters X, Y, and Z. The fields a, b, and c use these types respectively.

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