Types and Bounds
Single line formatting
- [T]no spaces
- [T; expr], e.g.,- [u32; 42],- [Vec<Foo>; 10 * 2 + foo()](space after colon, no spaces around square brackets)
- *const T,- *mut T(no space after- *, space before type)
- &'a T,- &T,- &'a mut T,- &mut T(no space after- &, single spaces separating other words)
- unsafe extern "C" fn<'a, 'b, 'c>(T, U, V) -> Wor- fn()(single spaces around keywords and sigils, and after commas, no trailing commas, no spaces around brackets)
- !gets treated like any other type name,- Name
- (A, B, C, D)(spaces after commas, no spaces around parens, no trailing comma unless it is a one-tuple)
- <Baz<T> as SomeTrait>::Foo::Baror- Foo::Baror- ::Foo::Bar(no spaces around- ::or angle brackets, single spaces around- as)
- Foo::Bar<T, U, V>(spaces after commas, no trailing comma, no spaces around angle brackets)
- T + T + T(single spaces between types, and- +).
- impl T + T + T(single spaces between keyword, types, and- +).
Do not put space around parentheses used in types, e.g., (Foo)
Line breaks
Avoid breaking lines in types where possible. Prefer breaking at outermost scope, e.g., prefer
#![allow(unused)] fn main() { Foo< Bar, Baz<Type1, Type2>, > }
to
#![allow(unused)] fn main() { Foo<Bar, Baz< Type1, Type2, >> }
If a type requires line-breaks in order to fit, this section outlines where to break such types if necessary.
Break [T; expr] after the ; if necessary.
Break function types following the rules for function declarations.
Break generic types following the rules for generics.
Break types with + by breaking before the + and block-indenting the
subsequent lines. When breaking such a type, break before every +:
#![allow(unused)] fn main() { impl Clone + Copy + Debug Box< Clone + Copy + Debug > }