Incorporate further review comments

Author: xwu

stdlib/public/core/AnyHashable.swift

@@ -109,29 +109,31 @@ internal struct _ConcreteHashableBox<Base: Hashable>: _AnyHashableBox {
 /// The `AnyHashable` type forwards equality comparisons and hashing operations
 /// to an underlying hashable value, hiding the type of the wrapped value.
 ///
-/// For types that support conversions between each other using `as` or `as?`
-/// (such as `Int` and `NSNumber`), `AnyHashable` treats their values
-/// equivalently when type-erased by forwarding operations to canonical
-/// representations of the wrapped values.
+/// Where conversion using `as` or `as?` is possible between two types (such as
+/// `Int` and `NSNumber`), `AnyHashable` uses a canonical representation of the
+/// type-erased value so that instances wrapping the same value of either type
+/// compare as equal. For example, `AnyHashable(42)` compares as equal to
+/// `AnyHashable(42 as NSNumber)`.
 ///
 /// You can store mixed-type keys in dictionaries and other collections that
 /// require `Hashable` conformance by wrapping mixed-type keys in
 /// `AnyHashable` instances:
 ///
 ///     let descriptions: [AnyHashable: Any] = [
-///         AnyHashable(42): "an Int",
-///         AnyHashable(Int8(43)): "an Int8",
-///         AnyHashable(Set(["a", "b"])): "a set of strings"
+///         42: "an Int",
+///         43 as Int8: "an Int8",
+///         ["a", "b"] as Set: "a set of strings"
 ///     ]
-///     print(descriptions[AnyHashable(42)]!)       // prints "an Int"
-///     print(descriptions[AnyHashable(Int8(42))]!) // prints "an Int"
-///     print(descriptions[AnyHashable(Int8(43))]!) // prints "an Int8"
-///     print(descriptions[AnyHashable(44)])        // prints "nil"
-///     print(descriptions[AnyHashable(Set(["a", "b"]))]!) // prints "a set of strings"
+///     print(descriptions[42]!)                // prints "an Int"
+///     print(descriptions[42 as Int8]!)        // prints "an Int"
+///     print(descriptions[43 as Int8]!)        // prints "an Int8"
+///     print(descriptions[44])                 // prints "nil"
+///     print(descriptions[["a", "b"] as Set]!) // prints "a set of strings"
 ///
-/// Note that `AnyHashable` instances are not guaranteed to preserve the hash
-/// encoding of their wrapped values, even in cases where hash values appear to
-/// match in a particular release of the standard library.
+/// Note that `AnyHashable` does not guarantee that it preserves the hash
+/// encoding of wrapped values. Do not rely on `AnyHashable` generating such
+/// compatible hashes, as the hash encoding that it uses may change between any
+/// two releases of the standard library.
 @frozen
 public struct AnyHashable {
   internal var _box: _AnyHashableBox
@@ -198,13 +200,13 @@ public struct AnyHashable {
 
 extension AnyHashable: Equatable {
   /// Returns a Boolean value indicating whether two type-erased hashable
-  /// instances wrap the same underlying value.
+  /// instances wrap the same value.
   ///
   /// `AnyHashable` considers bridged counterparts (such as a `String` and an
-  /// `NSString`) of the same value to be equivalent when type-erased. Where
-  /// those compatible types have different definitions of equality comparisons,
-  /// values that originally compare as not equal may then compare as equal when
-  /// they are type-erased by conversion to `AnyHashable`:
+  /// `NSString`) of the same value to be equivalent when type-erased. If those
+  /// compatible types use different definitions for equality, values that were
+  /// originally distinct might compare as equal when they are converted to
+  /// `AnyHashable`:
   ///
   ///     let string1 = "café"
   ///     let string2 = "cafe\u{301}" // U+301 COMBINING ACUTE ACCENT