Move type parameters and trait bounds to their own page

Author: matthewjasper

src/SUMMARY.md

@@ -34,6 +34,7 @@
         - [Traits](items/traits.md)
         - [Implementations](items/implementations.md)
         - [External blocks](items/external-blocks.md)
+    - [Type and lifetime parameters](items/generics.md)
     - [Associated Items](items/associated-items.md)
     - [Visibility and Privacy](visibility-and-privacy.md)
     - [Attributes](attributes.md)
@@ -64,6 +65,7 @@
     - [Dynamically Sized Types](dynamically-sized-types.md)
     - [Type layout](type-layout.md)
     - [Interior mutability](interior-mutability.md)
+    - [Trait and lifetime bounds](trait-bounds.md)
     - [Subtyping](subtyping.md)
     - [Type coercions](type-coercions.md)
     - [Destructors](destructors.md)

src/items.md

@@ -36,22 +36,3 @@ as if the item was declared outside the scope — it is still a static item
 qualified by the name of the enclosing item, or is private to the enclosing
 item (in the case of functions). The grammar specifies the exact locations in
 which sub-item declarations may appear.
-
-## Type Parameters
-
-Functions, type aliases, structs, enumerations, unions, traits and
-implementations may be *parameterized* by type. Type parameters are given as a
-comma-separated list of identifiers enclosed in angle brackets (`<...>`), after
-the name of the item (except for implementations, where they come directly
-after `impl`) and before its definition.
-
-The type parameters of an item are considered "part of the name", not part of
-the type of the item. A referencing [path] must (in principle) provide type
-arguments as a list of comma-separated types enclosed within angle brackets, in
-order to refer to the type-parameterized item. In practice, the type-inference
-system can usually infer such argument types from context. There are no general
-type-parametric types, only type-parametric items. That is, Rust has no notion
-of type abstraction: there are no higher-ranked (or "forall") types abstracted
-over other types, though higher-ranked types do exist for lifetimes.
-
-[path]: paths.html

src/items/enumerations.md

@@ -132,8 +132,8 @@ enum ZeroVariants {}
 ```
 
 [IDENTIFIER]: identifiers.html
-[_Generics_]: items.html#type-parameters
-[_WhereClause_]: items.html#type-parameters
+[_Generics_]: items/generics.html
+[_WhereClause_]: iitems/generics.html#where-clauses
 [_Expression_]: expressions.html
 [_TupleFields_]: items/structs.html
 [_StructFields_]: items/structs.html

src/items/generics.md

@@ -0,0 +1,18 @@
+# Type Parameters
+
+Functions, type aliases, structs, enumerations, unions, traits and
+implementations may be *parameterized* by type. Type parameters are given as a
+comma-separated list of identifiers enclosed in angle brackets (`<...>`), after
+the name of the item (except for implementations, where they come directly
+after `impl`) and before its definition.
+
+The type parameters of an item are considered "part of the name", not part of
+the type of the item. A referencing [path] must (in principle) provide type
+arguments as a list of comma-separated types enclosed within angle brackets, in
+order to refer to the type-parameterized item. In practice, the type-inference
+system can usually infer such argument types from context. There are no general
+type-parametric types, only type-parametric items. That is, Rust has no notion
+of type abstraction: there are no higher-ranked (or "forall") types abstracted
+over other types, though higher-ranked types do exist for lifetimes.
+
+[path]: paths.html

src/items/structs.md

@@ -82,7 +82,7 @@ particular layout using the [`repr` attribute].
 
 [_OuterAttribute_]: attributes.html
 [IDENTIFIER]: identifiers.html
-[_Generics_]: items.html#type-parameters
-[_WhereClause_]: items.html#type-parameters
+[_Generics_]: items/generics.html
+[_WhereClause_]: items/generics.html#where-clauses
 [_Visibility_]: visibility-and-privacy.html
 [_Type_]: types.html

src/items/traits.md

@@ -16,32 +16,7 @@ Traits are implemented for specific types through separate [implementations].
 
 ## Trait bounds
 
-Generic functions may use traits as _bounds_ on their type parameters. This
-will have three effects:
-
-- Only types that have the trait may instantiate the parameter.
-- Within the generic function, the methods of the trait can be called on values
-  that have the parameter's type. Associated types can be used in the
-  function's signature, and associated constants can be used in expressions
-  within the function body.
-- Generic functions and types with the same or weaker bounds can use the
-  generic type in the function body or signature.
-
-For example:
-
-```rust
-# type Surface = i32;
-# trait Shape { fn draw(&self, Surface); }
-struct Figure<S: Shape>(S, S);
-fn draw_twice<T: Shape>(surface: Surface, sh: T) {
-    sh.draw(surface);
-    sh.draw(surface);
-}
-fn draw_figure<U: Shape>(surface: Surface, Figure(sh1, sh2): Figure<U>) {
-    sh1.draw(surface);
-    draw_twice(surface, sh2); // Can call this since U: Shape
-}
-```
+Generic items may use traits as [bounds] on their type parameters.
 
 ## Generic Traits
 
@@ -136,12 +111,9 @@ let mycircle = Box::new(mycircle) as Box<Circle>;
 let nonsense = mycircle.radius() * mycircle.area();
 ```
 
-[`Send`]: ../std/marker/trait.Send.html
-[`Send`]: ../std/marker/trait.Sync.html
-[`UnwindSafe`]: ../std/panic/trait.UnwindSafe.html
-[`RefUnwindSafe`]: ../std/panic/trait.RefUnwindSafe.html
+[bounds]: trait-bounds.html
 [trait object]: types.html#trait-objects
 [explicit]: expressions/operator-expr.html#type-cast-expressions
 [methods called]: expressions/method-call-expr.html
 [RFC 255]: https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md
-[associated items]: items/associated-items.html
+[associated items]: items/associated-items.html

src/items/type-aliases.md

@@ -30,6 +30,6 @@ let _: F = E::A;  // OK
 ```
 
 [IDENTIFIER]: identifiers.html
-[_Generics_]: items.html#type-parameters
-[_WhereClause_]: items.html#type-parameters
+[_Generics_]: items/generics.html
+[_WhereClause_]: items/generics.html#where-clauses
 [_Type_]: types.html

src/items/unions.md

@@ -146,6 +146,6 @@ More detailed specification for unions, including unstable bits, can be found
 in [RFC 1897 "Unions v1.2"](https://github.com/rust-lang/rfcs/pull/1897).
 
 [IDENTIFIER]: identifiers.html
-[_Generics_]: items.html#type-parameters
-[_WhereClause_]: items.html#type-parameters
+[_Generics_]: items/generics.html
+[_WhereClause_]: items/generics.html#where-clauses
 [_StructFields_]: items/structs.html

src/trait-bounds.md

@@ -0,0 +1,28 @@
+# Trait bounds
+
+Generic functions may use traits as _bounds_ on their type parameters. This
+will have three effects:
+
+- Only types that have the trait may instantiate the parameter.
+- Within the generic function, the methods of the trait can be called on values
+  that have the parameter's type. Associated types can be used in the
+  function's signature, and associated constants can be used in expressions
+  within the function body.
+- Generic functions and types with the same or weaker bounds can use the
+  generic type in the function body or signature.
+
+For example:
+
+```rust
+# type Surface = i32;
+# trait Shape { fn draw(&self, Surface); }
+struct Figure<S: Shape>(S, S);
+fn draw_twice<T: Shape>(surface: Surface, sh: T) {
+    sh.draw(surface);
+    sh.draw(surface);
+}
+fn draw_figure<U: Shape>(surface: Surface, Figure(sh1, sh2): Figure<U>) {
+    sh1.draw(surface);
+    draw_twice(surface, sh2); // Can call this since U: Shape
+}
+```