[stdlib] Various minor documentation revisions

Author: natecook1000

stdlib/public/core/Builtin.swift

@@ -831,7 +831,7 @@ public func type<T, Metatype>(of value: T) -> Metatype {
 ///         }
 ///     }
 ///
-/// - Important: The escapable copy of `closure` passed as `body` is only valid
+/// - Important: The escapable copy of `closure` passed to `body` is only valid
 ///   during the call to `withoutActuallyEscaping(_:do:)`. It is undefined
 ///   behavior for the escapable closure to be stored, referenced, or executed
 ///   after the function returns.

stdlib/public/core/Collection.swift

@@ -499,7 +499,7 @@ public struct IndexingIterator<
 /// and shares the original collection's semantics.
 ///
 /// The following example creates a `firstWord` constant by using the
-/// `prefix(where:)` method to get a slice of the `text` string.
+/// `prefix(while:)` method to get a slice of the `text` string.
 ///
 ///     let firstWord = text.prefix(while: { $0 != " " })
 ///     print(firstWord)

stdlib/public/core/HashedCollections.swift.gyb

@@ -5439,11 +5439,10 @@ extension ${Self} {
 %{
 if Self == 'Set':
   SubscriptingWithIndexDoc = """\
-/// Used to access the members in an instance of `Set<Element>`."""
+/// The position of an element in a set."""
 elif Self == 'Dictionary':
   SubscriptingWithIndexDoc = """\
-/// Used to access the key-value pairs in an instance of
-/// `Dictionary<Key, Value>`.
+/// The position of a key-value pair in a dictionary.
 ///
 /// Dictionary has two subscripting interfaces:
 ///

stdlib/public/core/Range.swift.gyb

@@ -855,21 +855,22 @@ public struct PartialRangeFrom<Bound: Comparable>: RangeExpression {
   }
 }
 
-/// A partial interval extending upward from a lower bound.
+/// A partial interval extending upward from a lower bound that forms a
+/// sequence of increasing values.
 ///
-/// You create `PartialRangeFrom` instances by using the postfix range operator
-/// (postfix `...`).
+/// You create `CountablePartialRangeFrom` instances by using the postfix range
+/// operator (postfix `...`).
 ///
 ///     let atLeastFive = 5.0...
 ///
-/// You can use a `PartialRangeFrom` instance to quickly check if a value is
+/// You can use a countable partial range to quickly check if a value is
 /// contained in a particular range of values. For example:
 ///
 ///     atLeastFive.contains(4.0)     // false
 ///     atLeastFive.contains(5.0)     // true
 ///     atLeastFive.contains(6.0)     // true
 ///
-/// You can use a `PartialRangeFrom` instance of a collection's indices to
+/// You can use a countable partial range of a collection's indices to
 /// represent the range from the partial range's lower bound up to the end of
 /// the collection.
 ///
@@ -885,9 +886,8 @@ public struct PartialRangeFrom<Bound: Comparable>: RangeExpression {
 /// Using a Partial Range as a Sequence
 /// ===================================
 ///
-/// You can iterate over a `PartialRangeFrom` instance using a `for`-`in` loop,
-/// or call any sequence method that doesn't require that the sequence is
-/// finite.
+/// You can iterate over a countable partial range using a `for`-`in` loop, or
+/// call any sequence method that doesn't require that the sequence is finite.
 ///
 ///     func isTheMagicNumber(_ x: Int) -> Bool {
 ///         return x == 3
@@ -906,8 +906,8 @@ public struct PartialRangeFrom<Bound: Comparable>: RangeExpression {
 ///     // "3 is the magic number!"
 ///
 /// Because a `CountablePartialRangeFrom` sequence counts upward indefinitely,
-/// do not use one with methods such as `map(_:)`, `filter(_:)`, or
-/// `suffix(_:)` that read the entire sequence before returning. It is safe to
+/// do not use one with methods that read the entire sequence before
+/// returning, such as `map(_:)`, `filter(_:)`, or `suffix(_:)`. It is safe to
 /// use operations that put an upper limit on the number of elements they
 /// access, such as `prefix(_:)` or `dropFirst(_:)`, and operations that you
 /// can guarantee will terminate, such as passing a closure you know will