Where clauses

A bound can also be expressed using a where clause immediately before the opening {, rather than at the type’s first mention. Additionally, where clauses can apply bounds to arbitrary types, rather than just to type parameters.

Some cases that a where clause is useful:

• When specifying generic types and bounds separately is clearer:

1. impl <A: TraitB + TraitC, D: TraitE + TraitF> MyTrait<A, D> for YourType {}

3. // Expressing bounds with a `where` clause
4. impl <A, D> MyTrait<A, D> for YourType where
5. A: TraitB + TraitC,
6. D: TraitE + TraitF {}

• When using a where clause is more expressive than using normal syntax. The impl in this example cannot be directly expressed without a where clause:

1. use std::fmt::Debug;

3. trait PrintInOption {
4. fn print_in_option(self);
5. }

7. // Because we would otherwise have to express this as `T: Debug` or
8. // use another method of indirect approach, this requires a `where` clause:
9. impl<T> PrintInOption for T where
10. Option<T>: Debug {
11. // We want `Option<T>: Debug` as our bound because that is what's
12. // being printed. Doing otherwise would be using the wrong bound.
13. fn print_in_option(self) {
14. println!("{:?}", Some(self));
15. }
16. }

18. fn main() {
19. let vec = vec![1, 2, 3];

21. vec.print_in_option();
22. }

See also:

RFC, struct, and trait