Address feedback

Author: bstrie

posts/2023-12-10-2024-Edition-CFP.md

@@ -52,7 +52,7 @@ and Rust is no exception.
 So if you've got ideas for how Rust could be better if only that pesky stability guarantee
 weren't around, now's the time to share!
 Also note that potential Edition-related changes aren't just limited to the language itself:
-we'll also consider proposed changes to the standard library, Cargo, and rustfmt.
+we'll also consider changes to both Cargo and rustfmt as well.
 
 Please keep in mind that the following criteria determine the sort of changes we're looking for:
 
@@ -79,22 +79,38 @@ unblocking future feature development, and making the language easier and more c
 
 [jeff]: https://www.youtube.com/watch?v=9nazm3_OXac
 
-As an example, in the 2015 Edition a dynamically-dispatched trait object
-has a type that looks like `Box<Foo>`.
-In the 2018 Edition, in order to distinguish this from the then-new,
-statically-dispatched `impl Trait` syntax, trait objects began to require the `dyn` keyword,
-so `Box<Foo>` became `Box<dyn Foo>`.
-To make this migration automatic, `cargo fix` gained the ability to rewrite the types
-of trait objects,
-as well as to rewrite identifiers in case any code out there was using `dyn` as a variable name.
+To spark your imagination, here's a real-world example.
+In the 2015 and 2018 Editions, iterating over a fixed-length array via `[foo].into_iter()`
+will yield *references* to the iterated elements;
+this is is surprising because, on other types, calling `.into_iter()` produces an iterator
+[that yields owned values rather than references][iters].
+This limitation existed because older versions of Rust lacked the ability to implement
+traits for all possible fixed-length arrays in a generic way.
+Once Rust finally [became able to express this][notes],
+*all* Editions at last gained the ability to iterate over owned values in fixed-length arrays;
+however, in the specific case of `[foo].into_iter()`,
+altering the existing behavior would have broken lots of code in the wild.
+Therefore, we used the 2021 Edition to fix this inconsistency
+for the specific case of `[foo].into_iter()`,
+allowing us to address [this long-standing issue][25725] while
+preserving Rust's stability guarantees.
+
+[iters]: https://doc.rust-lang.org/std/iter/#the-three-forms-of-iteration
+
+[notes]: https://blog.rust-lang.org/2021/06/17/Rust-1.53.0.html#intoiterator-for-arrays
+
+[25725]: https://github.com/rust-lang/rust/issues/25725
 
 ## How to contribute
 
 Just like other changes to Rust, Edition-related proposals follow the RFC process,
 as documented in [the Rust RFCs repository][rfcs].
+Please follow the process documented there, and please consider [publicizing a draft of your RFC][rfcs2] to collect preliminary feedback before officially submitting it, in order to expedite the RFC process once you've filed it for real! (And in addition to the venues mentioned in the prior link, please feel free to announce your pre-RFC to [our Zulip channel][zulip].)
 
 [rfcs]: https://github.com/rust-lang/rfcs/#rust-rfcs---rfc-book---active-rfc-list
 
+[rfcs2]: https://github.com/rust-lang/rfcs/#before-creating-an-rfc
+
 Please file your RFCs as soon as possible!
 Our goal is to release the 2024 Edition in the second half of 2024,
 which means we would like to get everything *implemented*