"Rust in Action" Learning Generic Functions

lugl4313820

"Rust in Action" Learning Generic Functions [Copy link]

In order for a function to receive and process multiple possible input types, Rust introduces generic types.

When matching multiple types, the trait function is used to check whether the input function can support the operation.

The author gives the following function:

use std::ops::{Add};
use std::time::{Duration};

fn add<T: Add<Output = T>>(i: T, j: T) -> T {
    i + j
}

fn main() {
    let floats = add(1.2 , 3.4);
    let ints = add(10,20);
    let durations = add(
        Duration::new(5,0),
        Duration::new(10, 0)
        
    );
    println!("{}",floats);
    println!("{}", ints);
    println!("{:?}", durations);
}

Import the Add trait from std::ops into the current local scope at the beginning.

Imports the Duration type from std::time into the current local scope.

From the above examples, the function signature becomes very complicated. It takes some patience to understand these complex function signatures. The author gives the following principles:

1. Lowercase letters (such as i and j) represent variables.

2. A single uppercase letter (such as T) indicates a generic type.

3. Names that start with a capital letter (such as Add) are trait names or names of specific types, such as String and Duration.

4. Labels (such as 'a) represent life cycle parameters.

At this point, in fact, under the safety of Rust, programmers need to have very solid basic skills, otherwise reading the code will be very difficult.

Come on, study hard!

秦天qintian0303

It can receive and process a variety of possible input types, but what about output?

lugl4313820

Qintianqintian0303 posted on 2024-4-19 23:30 It can receive and process a variety of possible input types, but what about the output?

Output, it seems to point to T, but it does not do trait, it should be multiple, if the output value is used in other places, then do trait in other places. Here is direct printf. The moderator reminded me well, but I haven't learned it yet.