Generic functions in Rust - Step-by-Step Execution

Concept Flow - Generic functions

Define generic function with <T>

↓

Call function with specific type

↓

Compiler replaces T with actual type

↓

Function runs with concrete type

↓

Return result or perform action

This flow shows how a generic function is defined with a placeholder type T, then called with a real type, which the compiler uses to create a specific version of the function.

Execution Sample

Rust

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

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

This code defines a generic function that prints any value that can be displayed, then calls it with an integer and a string.

Execution Table

Step	Action	Generic Type T	Concrete Type	Output
1	Define function print_value<T>	T	N/A	No output
2	Call print_value(42)	T	i32	Value: 42
3	Call print_value("hello")	T	&str	Value: hello
4	End of calls	N/A	N/A	Execution stops

💡 All calls completed, no more function calls

Variable Tracker

Variable	Start	After call 1	After call 2	Final
value	N/A	42 (i32)	"hello" (&str)	N/A

Key Moments - 3 Insights

Why do we write <T> after the function name?

The <T> tells Rust this function uses a generic type placeholder T, which will be replaced by a real type when the function is called, as shown in execution_table rows 2 and 3.

How does Rust know what type T is when calling the function?

Rust infers T from the argument passed to the function call, like 42 is i32 and "hello" is &str, as seen in execution_table rows 2 and 3.

Can the generic function print_value accept any type?

No, only types that implement the Display trait, so they can be printed. This is why we write <T: std::fmt::Display> in the function definition.

Visual Quiz - 3 Questions

Look at the execution_table, what is the concrete type of T when print_value is called with 42?

A &str

B String

C i32

D f64

💡 Hint

Check execution_table row 2 under Concrete Type column

At which step does the function print_value get called with a string?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at execution_table rows and find where Output is 'Value: hello'

If we remove the Display trait bound from <T: std::fmt::Display>, what would happen?

A Compiler error because println! needs Display

B Code compiles and runs fine

C Function runs but prints nothing

D Function only works for integers

💡 Hint

Recall key_moments about trait bounds and printing requirements

Concept Snapshot

Generic functions use <T> to accept any type.
The compiler replaces T with the actual type at call time.
Trait bounds like <T: Display> restrict usable types.
This allows code reuse with different data types.
Calls with different types create specialized versions.

Full Transcript

This lesson shows how generic functions work in Rust. We define a function with a placeholder type T using angle brackets. When we call the function with a real value, Rust replaces T with that value's type. For example, calling print_value(42) uses i32 for T, and print_value("hello") uses &str. The function requires T to implement the Display trait so it can print the value. The execution table traces each step: defining the function, calling it with different types, and the output produced. Variable tracking shows how the value variable changes type per call. Key moments clarify why we use <T>, how Rust infers types, and why trait bounds matter. The quiz tests understanding of type substitution, call steps, and trait bounds. This helps beginners see how generic functions enable flexible, reusable code.

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