Generic functions in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a generic function with different types

What is the output of this Rust program that uses a generic function to print values?

Rust

fn print_value<T: std::fmt::Display>(value: T) {
    println!("Value: {}", value);
}

fn main() {
    print_value(42);
    print_value("hello");
}

A Value: 42\nValue: \"hello\"

B Value: 42\nValue: hello

C Value: 42\nValue: hello\nValue: 42

D Compilation error due to missing trait bound

💡 Hint

Look at the trait bound std::fmt::Display and how it allows printing.

The generic function print_value accepts any type T that implements the Display trait. Both 42 (integer) and "hello" (string slice) implement Display, so the function prints them as expected.

🧠 Conceptual

intermediate

Understanding generic function constraints

Which statement best describes why generic functions in Rust often require trait bounds?

A Trait bounds specify what operations the generic type can perform, enabling the compiler to check correctness.

B Trait bounds allow generic functions to accept any type without restrictions.

C Trait bounds are optional and only used for documentation purposes.

D Trait bounds automatically convert types to a common type inside the function.

💡 Hint

Think about how Rust ensures safety and correctness with generics.

Trait bounds tell the compiler what capabilities a generic type must have, so the function can safely use those operations. Without trait bounds, the compiler cannot guarantee the code will work.

🔧 Debug

advanced

Identify the error in this generic function

What error does this Rust code produce?

Rust

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

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

A error: mismatched types between a and b

B error: missing lifetime specifier

C error: binary operation `+` cannot be applied to type `T`

D No error, prints 15

💡 Hint

Consider what trait is needed to use the + operator in Rust.

The generic type T does not have a trait bound specifying it supports the + operator. Rust requires the Add trait bound to use + on generic types.

📝 Syntax

advanced

Correct syntax for a generic function with multiple type parameters

Which option shows the correct syntax for a generic function that takes two different types and returns a tuple of them?

A fn pair<T, U>(a: T, b: U) -> (T, U) { (a, b) }

B fn pair<T, U>(a: T, b: U) -> (U, T) { (a, b) }

C fn pair<T, U>(a: T, b: U) -> (T, U) { a, b }

D fn pair<T, U>(a: T, b: U) -> (T, U) { return a, b; }

💡 Hint

Remember how to return a tuple in Rust.

Option A correctly defines a generic function with two type parameters and returns a tuple (a, b). Option A returns the wrong tuple order. Options C and D have syntax errors in the return statement.

🚀 Application

expert

Using generic functions with trait bounds and lifetimes

What is the output of this Rust program?

Rust

fn longest<'a, T>(x: &'a T, y: &'a T) -> &'a T
where
    T: std::fmt::Display + PartialOrd,
{
    if x >= y {
        println!("{} is longer or equal", x);
        x
    } else {
        println!("{} is longer", y);
        y
    }
}

fn main() {
    let a = "apple";
    let b = "banana";
    let result = longest(&a, &b);
    println!("Longest: {}", result);
}

A apple is longer or equal\nLongest: apple

B Runtime panic due to lifetime mismatch

C Compilation error due to trait bound mismatch

D banana is longer\nLongest: banana

💡 Hint

Consider how string slices compare and the trait bounds used.

The function compares two references to types that implement PartialOrd and Display. Since "banana" is lexicographically greater than "apple", it prints "banana is longer" and returns a reference to "banana".