[SE-0467] incorporate review feedback (#2737)

* [se0467] extract slicing from future directions

* [se0467] clean up element constraints

* [se0467] fix another typo

* [se0467] fix a typo and parameter name

Author: glessard

proposals/0467-MutableSpan.md

@@ -84,7 +84,7 @@ This lifetime relationship will apply to all the safe `var mutableSpan: MutableS
 An important category of use cases for `MutableSpan` and `MutableRawSpan` consists of bulk copying operations. Often times, such bulk operations do not necessarily start at the beginning of the span, thus having a method to select a sub-span is necessary. This means producing an instance derived from the callee instance. We adopt the nomenclature already introduced in [SE-0437][SE-0437], with a family of `extracting()` methods.
 
 ```swift
-extension MutableSpan where Element: ~Copyable & ~Escapable {
+extension MutableSpan where Element: ~Copyable {
   @_lifetime(inout self)
   public mutating func extracting(_ range: Range<Index>) -> Self
 }
@@ -114,20 +114,20 @@ As established in [SE-0437][SE-0437], the instance returned by the `extracting()
 
 ````swift
 @frozen
-public struct MutableSpan<Element: ~Copyable & ~Escapable>: ~Copyable, ~Escapable {
+public struct MutableSpan<Element: ~Copyable>: ~Copyable, ~Escapable {
   internal var _start: UnsafeMutableRawPointer?
   internal var _count: Int
 }
 
-extension MutableSpan: @unchecked Sendable where Element: Sendable {}
+extension MutableSpan: @unchecked Sendable where Element: Sendable & ~Copyable {}
 ````
 
 We store a `UnsafeMutableRawPointer` value internally in order to explicitly support reinterpreted views of memory as containing different types of `BitwiseCopyable` elements. Note that the the optionality of the pointer does not affect usage of `MutableSpan`, since accesses are bounds-checked and the pointer is only dereferenced when the `MutableSpan` isn't empty, when the pointer cannot be `nil`.
 
 Initializers, required for library adoption, will be proposed alongside [lifetime annotations][PR-2305]; for details, see "[Initializers](#initializers)" in the [future directions](#Directions) section.
 
 ```swift
-extension MutableSpan where Element: ~Copyable & ~Escapable {
+extension MutableSpan where Element: ~Copyable {
   /// The number of initialized elements in this `MutableSpan`.
   var count: Int { get }
 
@@ -172,7 +172,7 @@ We include functions to perform bulk copies of elements into the memory represen
 
 ```swift
 extension MutableSpan where Element: Copyable {
-  /// Updates every element of this span's to the given value.
+  /// Updates every element of this span to the given value.
   mutating func update(
     repeating repeatedValue: Element
   )
@@ -224,7 +224,7 @@ extension MutableSpan where Element: Copyable {
 These functions extract sub-spans of the callee. The first two perform strict bounds-checking. The last four return prefixes or suffixes, where the number of elements in the returned sub-span is bounded by the number of elements in the parent `MutableSpan`.
 
 ```swift
-extension MutableSpan where Element: ~Copable & ~Escapable {
+extension MutableSpan where Element: ~Copyable {
   /// Returns a span over the items within the supplied range of
   /// positions within this span.
   @_lifetime(inout self)
@@ -427,7 +427,7 @@ extension MutableRawSpan {
 
   /// Updates the span's bytes with the bytes of the elements from the source
   mutating func update<Element: BitwiseCopyable>(
-    from elements: inout some IteratorProtocol<Element>
+    from source: inout some IteratorProtocol<Element>
   ) -> Int
 
   /// Updates the span's bytes with every byte of the source.
@@ -669,28 +669,6 @@ Note: The future directions stated in [SE-0447](https://github.com/swiftlang/swi
 
 These annotations have been [pitched][PR-2305-pitch] and, after revision, are expected to be pitched again soon. `MutableSpan` initializers using lifetime annotations will be proposed alongside the annotations themselves.
 
-#### Functions providing variants of `MutableRawSpan` to `MutableSpan`
-
-`MutableSpan`s representing subsets of consecutive elements could be extracted out of a larger `MutableSpan` with an API similar to the `extracting()` functions recently added to `UnsafeBufferPointer` in support of non-copyable elements:
-
-```swift
-extension MutableSpan where Element: ~Copyable {
-  public mutating func extracting(_ bounds: Range<Index>) -> Self
-}
-```
-
-These functions would require a lifetime dependency annotation.
-
-Similarly, a `MutableRawSpan` could provide a function to mutate a range of its bytes as a typed `MutableSpan`:
-
-```swift
-extension MutableRawSpan {
-  @unsafe
-  public mutating func unsafeMutableView<T: BitwiseCopyable>(as type: T.Type) -> MutableSpan<T>
-}
-```
-We are subsetting functions that require lifetime annotations until such annotations are [proposed][PR-2305].
-
 #### Splitting `MutableSpan` instances – `MutableSpan` in divide-and-conquer algorithms
 
 It is desirable to have a way to split a `MutableSpan` in multiple parts, for divide-and-conquer algorithms or other reasons: