Auto merge of #24195 - steveklabnik:rollup, r=steveklabnik

- Successful merges: #24143, #24149, #24167, #24178
- Failed merges:

Author: bors

src/doc/complement-design-faq.md

@@ -163,13 +163,17 @@ This is to make the language easier to parse for humans, especially in the face
 of higher-order functions. `fn foo<T>(f: fn(int): int, fn(T): U): U` is not
 particularly easy to read.
 
-## `let` is used to introduce variables
+## Why is `let` used to introduce variables?
 
-`let` not only defines variables, but can do pattern matching. One can also
-redeclare immutable variables with `let`. This is useful to avoid unnecessary
-`mut` annotations. An interesting historical note is that Rust comes,
-syntactically, most closely from ML, which also uses `let` to introduce
-bindings.
+We don't use the term "variable", instead, we use "variable bindings". The
+simplest way for binding is the `let` syntax, other ways including `if let`,
+`while let` and `match`. Bindings also exist in function arguments positions.
+
+Bindings always happen in pattern matching positions, and it's also Rust's way
+to declare mutability. One can also redeclare mutability of a binding in
+pattern matching. This is useful to avoid unnecessary `mut` annotations. An
+interesting historical note is that Rust comes, syntactically, most closely
+from ML, which also uses `let` to introduce bindings.
 
 See also [a long thread][alt] on renaming `let mut` to `var`.
 

src/doc/trpl/SUMMARY.md

@@ -1,48 +1,69 @@
 # Summary
 
-* [The Basics](basic.md)
+* [Getting Started](getting-started.md)
     * [Installing Rust](installing-rust.md)
     * [Hello, world!](hello-world.md)
     * [Hello, Cargo!](hello-cargo.md)
+* [Learn Rust](learn-rust.md)
+* [Effective Rust](effective-rust.md)
+    * [The Stack and the Heap](the-stack-and-the-heap.md)
+    * [`Debug` and `Display`](debug-and-display.md)
+    * [Testing](testing.md)
+    * [Documentation](documentation.md)
+    * [Iterators](iterators.md)
+    * [Concurrency](concurrency.md)
+    * [Error Handling](error-handling.md)
+    * [FFI](ffi.md)
+    * [`Deref` coercions](deref-coercions.md)
+* [Syntax and Semantics](syntax-and-semantics.md)
     * [Variable Bindings](variable-bindings.md)
-    * [If](if.md)
+    * [Primitive Types](primitive-types.md)
     * [Functions](functions.md)
     * [Comments](comments.md)
-    * [Compound Data Types](compound-data-types.md)
+    * [Structs](structs.md)
+    * [Mutability](mutability.md)
+    * [Method Syntax](method-syntax.md)
+    * [Enums](enums.md)
+    * [`if`](if.md)
     * [Match](match.md)
-    * [Looping](looping.md)
+    * [Patterns](patterns.md)
+    * [`for` loops](for-loops.md)
+    * [`while` loops](while-loops.md)
+    * [Ownership](ownership.md)
+    * [References and Borrowing](references-and-borrowing.md)
+    * [Lifetimes](lifetimes.md)
+    * [Move semantics](move-semantics.md)
+    * [Drop](drop.md)
+    * [Vectors](vectors.md)
+    * [Arrays](arrays.md)
+    * [Slices](slices.md)
     * [Strings](strings.md)
-    * [Arrays, Vectors, and Slices](arrays-vectors-and-slices.md)
-* [Intermediate Rust](intermediate.md)
+    * [Traits](traits.md)
+    * [Operators and Overloading](operators-and-overloading.md)
+    * [Generics](generics.md)
+    * [Trait Objects](trait-objects.md)
+    * [Closures](closures.md)
+    * [Universal Function Call Syntax](ufcs.md)
     * [Crates and Modules](crates-and-modules.md)
-    * [Testing](testing.md)
-    * [Pointers](pointers.md)
-    * [Ownership](ownership.md)
-    * [More Strings](more-strings.md)
-    * [Patterns](patterns.md)
-    * [Method Syntax](method-syntax.md)
+    * [`static`](static.md)
+    * [`const`](const.md)
+    * [Tuples](tuples.md)
+    * [Tuple Structs](tuple-structs.md)
+    * [Attributes](attributes.md)
+    * [Conditional Compilation](conditional-compilation.md)
+    * [`type` aliases](type-aliases.md)
+    * [Casting between types](casting-between-types.md)
     * [Associated Types](associated-types.md)
-    * [Closures](closures.md)
-    * [Iterators](iterators.md)
-    * [Generics](generics.md)
-    * [Traits](traits.md)
-    * [Static and Dynamic Dispatch](static-and-dynamic-dispatch.md)
+    * [Unsized Types](unsized-types.md)
     * [Macros](macros.md)
-    * [Concurrency](concurrency.md)
-    * [Error Handling](error-handling.md)
-    * [Documentation](documentation.md)
-* [Advanced Topics](advanced.md)
-    * [FFI](ffi.md)
-    * [Unsafe Code](unsafe.md)
-    * [Advanced Macros](advanced-macros.md)
-* [Unstable Rust](unstable.md)
-    * [Compiler Plugins](plugins.md)
+    * [`unsafe` Code](unsafe-code.md)
+* [Nightly Rust](nightly-rust.md)
+    * [Compiler Plugins](compiler-plugins.md)
     * [Inline Assembly](inline-assembly.md)
     * [No stdlib](no-stdlib.md)
     * [Intrinsics](intrinsics.md)
     * [Lang items](lang-items.md)
     * [Link args](link-args.md)
     * [Benchmark Tests](benchmark-tests.md)
     * [Box Syntax and Patterns](box-syntax-and-patterns.md)
-* [Conclusion](conclusion.md)
 * [Glossary](glossary.md)