Merge pull request #24814 from steveklabnik/doc_backport

Doc backport

Author: steveklabnik

src/doc/complement-design-faq.md

@@ -56,7 +56,7 @@ Types which are [`Sync`][sync] are thread-safe when multiple shared
 references to them are used concurrently. Types which are not `Sync` are not
 thread-safe, and thus when used in a global require unsafe code to use.
 
-[sync]: core/kinds/trait.Sync.html
+[sync]: core/marker/trait.Sync.html
 
 ### If mutable static items that implement `Sync` are safe, why is taking &mut SHARABLE unsafe?
 
@@ -139,7 +139,7 @@ and explicitly calling the `clone` method. Making user-defined copy operators
 explicit surfaces the underlying complexity, forcing the developer to opt-in
 to potentially expensive operations.
 
-[copy]: core/kinds/trait.Copy.html
+[copy]: core/marker/trait.Copy.html
 [clone]: core/clone/trait.Clone.html
 
 ## No move constructors
@@ -165,12 +165,13 @@ particularly easy to read.
 
 ## Why is `let` used to introduce variables?
 
-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.
+Instead of the term "variable", we use "variable bindings". The
+simplest way for creating a binding is by using the `let` syntax.
+Other ways include `if let`, `while let`, and `match`. Bindings also
+exist in function argument 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
+to declare mutability. One can also re-declare 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.

src/doc/complement-lang-faq.md

@@ -42,10 +42,7 @@ Let the fact that this is an easily countable number be a warning.
 
 ## Does it run on Windows?
 
-Yes. All development happens in lockstep on all 3 target platforms (using MinGW, not Cygwin). Note that the Windows implementation currently has some limitations; in particular, the 64-bit build is [not fully supported yet][win64], and all executables created by rustc [depend on libgcc DLL at runtime][libgcc].
-
-[win64]: https://github.com/rust-lang/rust/issues/1237
-[libgcc]: https://github.com/rust-lang/rust/issues/11782
+Yes. All development happens in lockstep on all 3 target platforms (using MinGW, not Cygwin).
 
 ## Is it OO? How do I do this thing I normally do in an OO language?