The most widespread use of traits is for writing generic functions or types. For
example, the following signature describes a function for consuming any iterator
yielding items of type A
`Ato produce a collection of
` to produce a collection of A
`A`:
fn from_iter<T: Iterator<A>>(iterator: T) -> SomeCollection<A>
Here, the Iterator
`Iteratortrait is specifies an interface that a type
` trait is specifies an interface that a type T
`T` must
explicitly implement to be used by this generic function.
Pros:
struct
`structand
` and enum
`enumtype is generic over some type parameter
` type is generic over some type
parameter T
`T, values of type
`, values of type T
`Twill be laid out _inline_ in the
` will be laid out inline in the
struct
`struct/
`/enum
`enum`, without any indirection.Precise types. Because generic give a name to the specific type implementing a trait, it is possible to be precise about places where that exact type is required or produced. For example, a function
fn main() { fn binary<T: Trait>(x: T, y: T) -> T }fn binary<T: Trait>(x: T, y: T) -> T
is guaranteed to consume and produce elements of exactly the same type T
`T; it cannot be invoked with parameters of different types that both implement
`; it
cannot be invoked with parameters of different types that both implement
Trait
`Trait`.
Cons:
T
`Tis a type parameter, it stands for a _single_ actual type. So for example a
` is a type parameter, it stands for a single actual type. So for example
a Vec<T>
`VecGeneric types are a form of abstraction, which entails a mental indirection: if
a function takes an argument of type T
`Tbounded by
` bounded by Trait
`Trait, clients must first think about the concrete types that implement
`, clients must first
think about the concrete types that implement Trait
`Trait` to understand how and when
the function is callable.
To keep the cost of abstraction low, favor widely-known traits. Whenever possible, implement and use traits provided as part of the standard library. Do not introduce new traits for generics lightly; wait until there are a wide range of types that can implement the type.