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) -> W
orfn()
(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::Bar
orFoo::Bar
or::Foo::Bar
(no spaces around::
or angle brackets, single spaces aroundas
)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 > }