Trait Bounds

When working with generics, you often want to require the types to implement some trait, so that you can call this trait’s methods.

You can do this with T: Trait:

  1. fn duplicate<T: Clone>(a: T) -> (T, T) {
  2.     (a.clone(), a.clone())
  3. }
  5. // struct NotCloneable;
  7. fn main() {
  8.     let foo = String::from("foo");
  9.     let pair = duplicate(foo);
  10.     println!("{pair:?}");
  11. }

This slide should take about 8 minutes.

  • Try making a NonCloneable and passing it to duplicate.

  • When multiple traits are necessary, use + to join them.

  • Show a where clause, students will encounter it when reading code.

    1. fn duplicate<T>(a: T) -> (T, T)
    2. where
    3.     T: Clone,
    4. {
    5.     (a.clone(), a.clone())
    6. }
    • It declutters the function signature if you have many parameters.
    • It has additional features making it more powerful.
      • If someone asks, the extra feature is that the type on the left of “:” can be arbitrary, like Option<T>.
  • Note that Rust does not (yet) support specialization. For example, given the original duplicate, it is invalid to add a specialized duplicate(a: u32).