rarw

Author: lcnr

src/items/generics.md

@@ -310,6 +310,12 @@ struct Foo<#[my_flexible_clone(unbounded)] H> {
 }
 ```
 
+r[items.generics.instantiation]
+When using an item its generic parameters have to get instantiated. This replaces all occurances of the parameter with either the explicitly provided argument or a new unconstrained inference variable.
+
+Instantiating the generic parameters of an item generally requires proving its where clauses.
+
+
 [array repeat expression]: ../expressions/array-expr.md
 [arrays]: ../types/array.md
 [slices]: ../types/slice.md

src/trait-bounds.md

@@ -56,13 +56,11 @@ The bounds of an item must be satisfied when using that item.
 
 r[bound.satisfaction.impl]
 
-- a trait bound can be satisfied by using an implementation of that trait
-- an impl is applicable if, after instantiating its generic parameters with inference variables
-    - TODO: how to talk about "instantiate with infer vars"...
-    - the self type and trait arguments are equal to the trait bound,
-    - the where-bounds of the impl can be recursively satisfied
+A trait bound can be satisfied by using an implementation of that trait. An implementation is applicable if,
+after instantiating its generic parameters with new inference variables, the self type and trait arguments are
+equal to the trait bound and the where-bounds of the impl can be recursively satisfied.
 
-[bound.satisfaction.impl.builtin]
+r[bound.satisfaction.impl.builtin]
 
 There exist impls which are automatically generated by the compiler.
 
@@ -71,21 +69,51 @@ There exist impls which are automatically generated by the compiler.
 
 - alternative: mention this in item-kind impl
 
-[bound.satisfaction.impl.builtin.trait-object]
+r[bound.satisfaction.impl.builtin.trait-object]
 
 Trait objects implement their trait if TODO: lookup conditions, something something project bounds make sense
 
-[bound.satisfaction.bounds]
+r[bound.satisfaction.bounds]
 
 While inside of a generic item, trait bounds can be satisfied by using the where-bounds of the current item as the item is able to assume that its bounds are satisfied. For this, higher-ranked where-bounds can be instantiated with inference variables. The where-bound is then equated with the trait bound that needs to be satisfied.
 
-[bound.satisfaction.alias-bounds]
+r[bound.satisfaction.alias-bounds]
 
-- if an alias cannot be normalized in the current environment, trait bounds using this alias as a self type can be proven by using its item bounds
-- TODO: alias bounds from nested self-types github.com/rust-lang/rust/pull/120752
+If an alias type is rigid in the current environment, trait bounds using this alias as a self type can be satisfied by using its item bounds.
+
+```rust
+trait Trait {
+    type Assoc: Clone;
+}
+
+fn foo<T: Trait>(x: &T::Assoc) -> T::Assoc {
+    // The where-bound `T::Assoc: Clone` is satisfied using the `Clone` item-bound.
+    x.clone()
+}
+```
+
+r[bound.satisfaction.alias-bounds.nested]
+
+We also consider the item bounds of the self type of aliases to satisfy trait bounds.
+
+```rust
+trait Trait {
+    type Assoc: Iterator
+    where
+        <Self::Assoc as Iterator>::Item: Clone;
+    // equivalent to
+    //     type Assoc: Iterator<Item: Clone>;
+}
+
+fn item_is_clone<T: Trait>(iter: T::Assoc) {
+    for item in iter {
+        let _ = item.clone();
+    }
+}
+```
 
 
-[bound.satisfaction.candidate-preference]
+r[bound.satisfaction.candidate-preference]
 
 > This is purely descriptive. Candidate preference behavior may change in future releases and must not be relied upon for correctness or soundness.
 
@@ -99,10 +127,6 @@ If there are multiple ways to satisfy a trait bound, some groups of candidate ar
 
 > note: this candidate preference can result in incorrect errors and type mismatches, e.g. ...
 
-[bound.satisfaction.cycles]
-
-In case satisfying a bound requires recursively satisfying the same bound, we've encountered a *cycle*. TODO: terminology is iffy here .... can just drop this again
-
 r[bound.trait-object]
 Trait and lifetime bounds are also used to name [trait objects].
 

src/types.md

@@ -153,12 +153,14 @@ let a: List<i32> = List::Cons(7, Box::new(List::Cons(13, Box::new(List::Nil))));
 
 r[types.equality]
 
-Equality and subtyping of types is generally structural. If the outermost type constructors are the same,
-corresponding generic arguments are compared. The only exceptions from this rule are higher ranked types and alias types.
+Equality and subtyping of types is generally structural; if the outermost type constructors are the same,
+their corresponding generic arguments are pairwise compared. We say types with this equality behavior are *rigid*. The only exceptions from this rule are higher ranked types and alias types.
+
+r[types.equality.rigid]
 
 r[types.equality.aliases]
 
-Aliases are compared by first normalizing them to a *rigid* type? and then equating their type constructors and recursing into their generic arguments.
+Aliases are compared by first normalizing them to a *rigid* type and then equating their type constructors and recursing into their generic arguments.
 
 r[types.equality.higher-ranked]
 
@@ -172,7 +174,6 @@ r[types.equality.higher-ranked.eq]
 
 Equality is checked by both instantiating the `for` of the lhs with inference variables and the `for` of the rhs with placeholders before equating them, and also doing the opposite.
 
-
 [Array]: types/array.md
 [Boolean]: types/boolean.md
 [Closures]: types/closure.md