Generic functions in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a generic function in Rust?

A generic function in Rust is a function that can work with different data types without repeating code. It uses type parameters to accept any type specified when calling the function.

beginner

How do you declare a generic function in Rust?

You declare a generic function by adding angle brackets with a type parameter after the function name, like <T>. For example:

fn example<T>(value: T) { /* code */ }

beginner

Why use generic functions instead of multiple functions for each type?

Generic functions let you write one function that works for many types, reducing repeated code and making your program easier to maintain and read.

intermediate

What is a trait bound in a generic function?

A trait bound limits the types a generic function can accept by requiring the type to implement certain behavior. For example, fn print(value: T) means T must implement the Display trait.

intermediate

Explain the difference between fn example<T>(value: T) and fn example(value: T).

The first function accepts any type T. The second requires T to implement the Copy trait, meaning the value can be duplicated simply without moving ownership.

What does the <T> mean in a Rust function declaration?

A It declares a generic type parameter named T.

B It calls a function named T.

C It specifies a lifetime named T.

D It imports a module named T.

The angle brackets with T declare a generic type parameter, allowing the function to accept any type.

Which of these is a correct way to restrict a generic type to types that can be printed using a where clause?

A fn print<T: Display>(value: T)

B fn print<T>(value: T: Display)

C fn print<T where Display>(value: T)

D fn print<T>(value: T) where T: Display

The correct syntax to add a trait bound outside the angle brackets is using a where clause: where T: Display.

Why might you add a trait bound like T: Copy to a generic function?

A To ensure the type can be duplicated without moving ownership.

B To make the function slower.

C To restrict the function to only integer types.

D To allow the function to accept any type.

The Copy trait means the type can be copied simply, so the function can duplicate values safely.

What happens if you call a generic function with different types?

A Rust only uses the first type and ignores others.

B Rust creates a version of the function for each type used.

C The program will not compile.

D Rust runs the same function without changes.

Rust generates specialized versions of the generic function for each type it is called with.

Which keyword is used to declare a generic type parameter in Rust?

A fn

B let

C <T>

D trait

Generic type parameters are declared inside angle brackets, like .

Explain what a generic function is and why it is useful in Rust.

Think about how one function can work with many types.

Describe how trait bounds work in generic functions and give an example.

Trait bounds tell Rust what behaviors a type must have.

Practice

1. What does the <T> mean in a Rust function definition like fn example<T>(value: T) {}?

easy

A. It makes the function generic, so it can accept any type.

B. It defines a new variable inside the function.

C. It restricts the function to only work with integers.

D. It marks the function as unsafe.

Solution

1. Step 1: Understand the syntax <T> in Rust

   The <T> after the function name declares a generic type parameter named T.

2. Step 2: Explain the effect of generic type parameter

   This allows the function to accept any type for value, making it flexible and reusable.

3. Final Answer:

   It makes the function generic, so it can accept any type. -> Option A

4. Quick Check:

   Generic type parameter = flexible function input [OK]

Hint: Look for <T> after function name for generics [OK]

Common Mistakes:

• Thinking <T> is a variable declaration
• Assuming it restricts to one type like integer
• Confusing it with unsafe code marker

2. Which of the following is the correct syntax to define a generic function named print_value that takes one argument of any type T?

easy

A. fn print_value(T value) {}

B. fn print_value<T>(value: T) {}

C. fn print_value(value: <T>) {}

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

Solution

1. Step 1: Recall generic function syntax in Rust

   Generic functions use <T> after the function name to declare the generic type.

2. Step 2: Match the syntax with options

   fn print_value<T>(value: T) {} correctly places <T> after the function name and uses value: T as parameter type.

3. Final Answer:

   fn print_value<T>(value: T) {} -> Option B

4. Quick Check:

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

Hint: Generic type always goes after function name in angle brackets [OK]

Common Mistakes:

• Putting T inside parameter parentheses incorrectly
• Using angle brackets around parameter type
• Missing angle brackets after function name

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

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

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

medium

A. Value: 10\nValue: hello

B. Value: 10\nValue: 10

C. Compilation error due to missing trait bound

D. Runtime error

Solution

1. Step 1: Understand the generic function with trait bound

   The function show_value requires T to implement Display so it can be printed.

2. Step 2: Check calls with integer and string

   Both 10 (integer) and "hello" (string) implement Display, so both calls print correctly.

3. Final Answer:

   Value: 10 Value: hello -> Option A

4. Quick Check:

   Trait bound allows printing = output shown [OK]

Hint: Check trait bounds to know if printing works [OK]

Common Mistakes:

• Assuming generic functions print without trait bounds
• Thinking string prints as number
• Expecting compilation error without trait bound

4. Identify the error in this generic function and how to fix it:

fn compare<T>(a: T, b: T) -> bool {
    a == b
}

medium

A. Function should return i32 instead of bool.

B. Function parameters should be references, not values.

C. Generic type T must be replaced with i32.

D. Missing trait bound T: PartialEq to use == operator.

Solution

1. Step 1: Understand use of == in generic function

   The == operator requires the type T to implement the PartialEq trait.

2. Step 2: Identify missing trait bound

   The function lacks T: PartialEq bound, so compiler will error when using ==.

3. Final Answer:

   Missing trait bound T: PartialEq to use == operator. -> Option D

4. Quick Check:

   Operator needs trait bound = add T: PartialEq [OK]

Hint: Add trait bounds when using operators on generics [OK]

Common Mistakes:

• Ignoring trait bounds for operators
• Changing return type unnecessarily
• Replacing generic with concrete type without reason

5. You want to write a generic function largest that returns the largest element from a slice of any type T. Which of these is the correct way to define it?

hard

A. fn largest<T>(list: &[T]) -> T { let mut largest = list[0]; for &item in list { if item > largest { largest = item; } } largest }

B. fn largest(list: &[i32]) -> i32 { let mut largest = list[0]; for &item in list { if item > largest { largest = item; } } largest }

C. fn largest<T: PartialOrd + Copy>(list: &[T]) -> T { let mut largest = *list[0]; for &item in list { if item > largest { largest = item; } } largest }

D. fn largest<T: PartialEq>(list: &[T]) -> T { list[0] }

Solution

1. Step 1: Identify required traits for comparison and copying

   To compare elements with >, T must implement PartialOrd. To copy elements, Copy trait is needed.

2. Step 2: Check function signature and body

   fn largest<T: PartialOrd + Copy>(list: &[T]) -> T { let mut largest = *list[0]; for &item in list { if item > largest { largest = item; } } largest } correctly adds T: PartialOrd + Copy and uses a loop to find the largest element.

3. Final Answer:

   fn largest<T: PartialOrd + Copy>(list: &[T]) -> T { ... } -> Option C

4. Quick Check:

   Traits PartialOrd + Copy needed for generic largest function [OK]

Hint: Add PartialOrd and Copy traits for generic comparisons [OK]

Common Mistakes:

• Omitting trait bounds causing compile errors
• Returning wrong type or missing copy trait
• Using concrete types instead of generics