Why generics are needed in Rust - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a function that returns the first element of a slice.

Rust

fn first_element(slice: &[[1]]) -> &[1] {
    &slice[0]
}

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

Ai32

BT

CString

Dbool

Attempts:

3 left

💡 Hint

Common Mistakes

Using a specific type like i32 limits the function to only that type.

Forgetting to use a generic type causes the function to be less flexible.

Using T as a generic type allows the function to work with any type of slice.

2fill in blank

medium

Complete the code to declare a generic struct named Point.

Rust

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

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

AV

BPoint

CU

DT

Attempts:

3 left

💡 Hint

Common Mistakes

Using a name that does not match the field types.

Not declaring the generic type in angle brackets.

The generic type T allows the struct to hold any type for its fields.

3fill in blank

hard

Fix the error in the function signature to make it generic.

Rust

fn print_value(value: [1]) {
    println!("{}", value);
}

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

AT

Bi32

C&str

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using a concrete type instead of a generic type.

Not declaring the generic type parameter.

Using T as a generic type requires declaring it in the function signature with <T>.

4fill in blank

hard

Fill both blanks to define a generic function that returns the larger of two values.

Rust

fn max_value<[1]: PartialOrd>(a: [1], b: [1]) -> [1] {
    if a > b { a } else { b }
}

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

AT

BU

CV

DW

Attempts:

3 left

💡 Hint

Common Mistakes

Using different generic type names inconsistently.

Not adding the trait bound : PartialOrd.

The generic type T is used consistently and constrained by PartialOrd to allow comparison.

5fill in blank

hard

Fill all three blanks to implement a generic struct with two different types.

Rust

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

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

AT

BU

CV

DW

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same generic type for both fields when different types are needed.

Not declaring both generic types in the struct definition.

The struct uses two generic types T and U for its fields.

Practice

1. Why do we use generics in Rust?
fn print_value<T>(value: T) {}

easy

A. To limit functions to only one type of data

B. To write functions that work with many types without repeating code

C. To make the code run faster by using specific types only

D. To avoid using variables inside functions

Solution

1. Step 1: Understand the purpose of generics

   Generics allow writing one function that can accept many types instead of writing many functions for each type.

2. Step 2: Analyze the example function

   The function print_value<T> uses a placeholder T to accept any type, showing flexibility.

3. Final Answer:

   To write functions that work with many types without repeating code -> Option B

4. Quick Check:

   Generics = flexible reusable code [OK]

Hint: Generics = one code fits many types [OK]

Common Mistakes:

• Thinking generics make code faster
• Believing generics restrict types
• Confusing generics with variables

2. Which of the following is the correct syntax to define a generic function in Rust?

easy

A. fn example<T>(value T) {}

B. fn example(value: T) {}

C. fn example<T> value: T {}

D. fn example<T>(value: T) {}

Solution

1. Step 1: Recall Rust generic function syntax

   Generic functions use angle brackets <T> after the function name to declare type parameters.

2. Step 2: Check each option

   fn example<T>(value: T) {} correctly uses fn example<T>(value: T) {}. Others miss brackets or have wrong parameter syntax.

3. Final Answer:

   fn example<T>(value: T) {} -> Option D

4. Quick Check:

   Generic syntax = fn name<T>(param: T) [OK]

Hint: Generic syntax always uses <T> after function name [OK]

Common Mistakes:

• Omitting angle brackets for generics
• Missing colon between parameter and type
• Placing type parameter incorrectly

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

fn print_type(value: T) {
    println!("Value: {}", value);
}

fn main() {
    print_type(10);
    print_type("hello");
}

medium

A. Compilation error due to missing trait

B. Value: 10
Value: 10

C. Value: 10
Value: hello

D. Runtime error printing value

Solution

1. Step 1: Understand trait bound usage

   The generic type T requires the Display trait to print values with {}.

2. Step 2: Check calls with different types

   Calling print_type(10) prints "Value: 10" and print_type("hello") prints "Value: hello" because both implement Display.

3. Final Answer:

   Value: 10 Value: hello -> Option C

4. Quick Check:

   Generics with Display trait print all types correctly [OK]

Hint: Generics with Display print any printable type [OK]

Common Mistakes:

• Assuming generic needs no trait bound
• Expecting same output for different inputs
• Confusing compile and runtime errors

4. Identify the error in this Rust code using generics:

fn add<T>(a: T, b: T) -> T {
    a + b
}

fn main() {
    println!("{}", add(5, 10));
}

medium

A. Missing trait bound for + operator on T

B. Wrong return type declared

C. Function parameters should be references

D. Cannot use println! with generic functions

Solution

1. Step 1: Check operator usage on generic type

   The + operator requires the type T to implement the Add trait.

2. Step 2: Identify missing trait bound

   The function lacks T: std::ops::Add<Output = T> bound, causing a compile error.

3. Final Answer:

   Missing trait bound for + operator on T -> Option A

4. Quick Check:

   Operators need trait bounds on generics [OK]

Hint: Add operator needs trait bound on generic type [OK]

Common Mistakes:

• Ignoring trait bounds for operators
• Assuming all types support + by default
• Thinking references are always required

5. You want to write a generic function that returns the largest of two values. Which is the correct way to define it in Rust?

hard

A. fn largest(a: T, b: T) -> T { if a > b { a } else { b } }

B. fn largest<T>(a: T, b: T) -> T { if a > b { a } else { b } }

C. fn largest(a: T, b: T) -> T { if a > b { a } else { b } }

D. fn largest(a: T, b: T) -> T { if a > b { a } else { b } }

Solution

1. Step 1: Identify required trait for comparison

   To compare two values with >, the type T must implement PartialOrd.

2. Step 2: Check trait bounds in options

   fn largest(a: T, b: T) -> T { if a > b { a } else { b } } correctly uses T: PartialOrd. fn largest<T>(a: T, b: T) -> T { if a > b { a } else { b } } misses trait bound, C uses Copy which is unrelated to comparison, D uses Display which is for printing.

3. Final Answer:

   fn largest<T: PartialOrd>(a: T, b: T) -> T { if a > b { a } else { b } } -> Option A

4. Quick Check:

   Comparison needs PartialOrd trait bound [OK]

Hint: Use PartialOrd trait to compare generics [OK]

Common Mistakes:

• Omitting PartialOrd trait bound
• Using unrelated traits like Copy or Display
• Assuming all types can be compared