Fixes to Rust 1.64 blog post

Author: joshtriplett

posts/2022-09-22-Rust-1.64.0.md

@@ -31,17 +31,17 @@ might come across!
 
 ## What's in 1.64.0 stable
 
-### C-compatible ffi types in core and alloc
+### C-compatible FFI types in core and alloc
 
-When calling or being called by C ABIs, Rust code can use types like `c_uint`
-or `c_ulong` to match the corresponding types from C on any target, without
-requiring target-specific code or conditionals.
+When calling or being called by C ABIs, Rust code can use type aliases like
+`c_uint` or `c_ulong` to match the corresponding types from C on any target,
+without requiring target-specific code or conditionals.
 
-Previously, these types were only available in `std`, so code written for
-embedded targets and other scenarios that could only use `core` or `alloc`
+Previously, these type aliases were only available in `std`, so code written
+for embedded targets and other scenarios that could only use `core` or `alloc`
 could not use these types.
 
-Rust 1.64 now provides all of the `c_*` types in
+Rust 1.64 now provides all of the `c_*` type aliases in
 [`core::ffi`](https://doc.rust-lang.org/core/ffi/index.html), as well as
 [`core::ffi::CStr`](https://doc.rust-lang.org/core/ffi/struct.CStr.html) for
 working with C strings. Rust 1.64 also provides
@@ -72,7 +72,9 @@ Such internal implementation details of the standard library are *never*
 considered a stable interface. Nonetheless, because multiple crates relied on
 this, we first worked with the authors of all of the still-maintained crates
 doing so to arrange for the release of new versions, and to yank the old ones,
-before making this change.
+before making this change. New releases for known affected crates have been out
+for typically over a year, and the vast majority of impacted users should be
+able to mitigate with a `cargo update` if needed."
 
 See <https://github.com/rust-lang/rust/pull/78802> for more details.
 
@@ -94,9 +96,9 @@ Rust 1.64 stabilizes the
 trait. `IntoFuture` is a trait similar to
 [`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html),
 but rather than supporting `for ... in ...` loops, `IntoFuture` changes how
-`.await` works. With `IntoFuture`, the `.await` keyword can await mor ethan
-just futures; it can await _anything which can be converted into a `Future` via
-`IntoFuture`_ - which can help make your APIs more user-friendly!
+`.await` works. With `IntoFuture`, the `.await` keyword can await more than
+just futures; it can await *anything which can be converted into a `Future` via
+`IntoFuture`* - which can help make your APIs more user-friendly!
 
 Take for example a builder which constructs requests to some storage provider
 over the network:
@@ -128,6 +130,7 @@ let response = StorageRequest::new()  // 1. create a new instance
 This is not bad, but we can do better here. Using `IntoFuture` we can combine
 _"construct the future"_ (line 3) and _"run the future"_ (line 4) into a single
 step:
+
 ```rust
 let response = StorageRequest::new()  // 1. create a new instance
     .set_debug(true)                  // 2. set some option
@@ -168,6 +171,7 @@ impl IntoFuture for StorageRequest {
     }
 }
 ```
+
 This takes a bit more code to implement, but provides a simpler API for users.
 
 In the future, the Rust Async WG hopes to simplify the creating new named