Generic Traits

Traits can also be generic, just like types and functions. A trait’s parameters get concrete types when it is used.

1. ```
   #[derive(Debug)]
   ```
2. ```
   struct Foo(String);
   ```

4. ```
   impl From<u32> for Foo {
   ```
5. ```
       fn from(from: u32) -> Foo {
   ```
6. ```
           Foo(format!("Converted from integer: {from}"))
   ```
7. ```
       }
   ```
8. ```
   }
   ```

10. ```
    impl From<bool> for Foo {
    ```
11. ```
        fn from(from: bool) -> Foo {
    ```
12. ```
            Foo(format!("Converted from bool: {from}"))
    ```
13. ```
        }
    ```
14. ```
    }
    ```

16. ```
    fn main() {
    ```
17. ```
        let from_int = Foo::from(123);
    ```
18. ```
        let from_bool = Foo::from(true);
    ```
19. ```
        println!("{from_int:?}, {from_bool:?}");
    ```
20. ```
    }
    ```

• The From trait will be covered later in the course, but its definition in the std docs is simple.
• Implementations of the trait do not need to cover all possible type parameters. Here, Foo::from("hello") would not compile because there is no From<&str> implementation for Foo.
• Generic traits take types as “input”, while associated types are a kind of “output” type. A trait can have multiple implementations for different input types.
• In fact, Rust requires that at most one implementation of a trait match for any type T. Unlike some other languages, Rust has no heuristic for choosing the “most specific” match. There is work on adding this support, called specialization.