[stdlib] Adopt primary associated types in the stdlib

Author: lorentey

stdlib/public/core/BidirectionalCollection.swift

@@ -39,7 +39,7 @@
 /// Valid indices are exactly those indices that are reachable from the
 /// collection's `startIndex` by repeated applications of `index(after:)`, up
 /// to, and including, the `endIndex`.
-public protocol BidirectionalCollection: Collection
+public protocol BidirectionalCollection<Element>: Collection
 where SubSequence: BidirectionalCollection, Indices: BidirectionalCollection {
   // FIXME: Only needed for associated type inference.
   override associatedtype Element

stdlib/public/core/Codable.swift

@@ -183,7 +183,7 @@ public protocol Decoder {
 ///
 /// Encoders should provide types conforming to
 /// `KeyedEncodingContainerProtocol` for their format.
-public protocol KeyedEncodingContainerProtocol {
+public protocol KeyedEncodingContainerProtocol<Key> {
   associatedtype Key: CodingKey
 
   /// The path of coding keys taken to get to this point in encoding.
@@ -938,7 +938,7 @@ public struct KeyedEncodingContainer<K: CodingKey> :
 ///
 /// Decoders should provide types conforming to `UnkeyedDecodingContainer` for
 /// their format.
-public protocol KeyedDecodingContainerProtocol {
+public protocol KeyedDecodingContainerProtocol<Key> {
   associatedtype Key: CodingKey
 
   /// The path of coding keys taken to get to this point in decoding.

stdlib/public/core/Collection.swift

@@ -335,7 +335,7 @@ extension IndexingIterator: Sendable
 /// or bidirectional collection must traverse the entire collection to count
 /// the number of contained elements, accessing its `count` property is an
 /// O(*n*) operation.
-public protocol Collection: Sequence {
+public protocol Collection<Element>: Sequence {
   // FIXME: ideally this would be in MigrationSupport.swift, but it needs
   // to be on the protocol instead of as an extension
   @available(*, deprecated/*, obsoleted: 5.0*/, message: "all index distances are now of type Int")

stdlib/public/core/CompilerProtocols.swift

@@ -98,7 +98,7 @@
 ///     // Prints "false"
 ///     print(allowedMoves.rawValue & Directions.right.rawValue)
 ///     // Prints "0"
-public protocol RawRepresentable {
+public protocol RawRepresentable<RawValue> {
   /// The raw type that can be used to represent all values of the conforming
   /// type.
   ///

stdlib/public/core/Identifiable.swift

@@ -39,7 +39,7 @@
 /// lifetime of an object. If an object has a stronger notion of identity, it
 /// may be appropriate to provide a custom implementation.
 @available(SwiftStdlib 5.1, *)
-public protocol Identifiable {
+public protocol Identifiable<ID> {
 
   /// A type representing the stable identity of the entity associated with
   /// an instance.

stdlib/public/core/Instant.swift

@@ -12,7 +12,7 @@
 
 // A type that defines a specific point in time for a given `Clock`.
 @available(SwiftStdlib 5.7, *)
-public protocol InstantProtocol: Comparable, Hashable, Sendable {
+public protocol InstantProtocol<Duration>: Comparable, Hashable, Sendable {
   associatedtype Duration: DurationProtocol
   func advanced(by duration: Duration) -> Self
   func duration(to other: Self) -> Duration

stdlib/public/core/LazyCollection.swift

@@ -10,8 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-public protocol LazyCollectionProtocol: Collection, LazySequenceProtocol 
-where Elements: Collection {	}
+public protocol LazyCollectionProtocol<Elements>
+: Collection, LazySequenceProtocol
+where Elements: Collection {}
 
 extension LazyCollectionProtocol {
    // Lazy things are already lazy

stdlib/public/core/LazySequence.swift

@@ -128,7 +128,8 @@
 /// and discards the resulting array. Instead, use `reduce` for summing 
 /// operations, or `forEach` or a `for`-`in` loop for operations with side 
 /// effects.
-public protocol LazySequenceProtocol: Sequence {
+public protocol LazySequenceProtocol<Elements>: Sequence
+where Elements.Element == Element {
   /// A `Sequence` that can contain the same elements as this one,
   /// possibly with a simpler type.
   ///
@@ -138,11 +139,8 @@ public protocol LazySequenceProtocol: Sequence {
   /// A sequence containing the same elements as this one, possibly with
   /// a simpler type.
   ///
-  /// When implementing lazy operations, wrapping `elements` instead
-  /// of `self` can prevent result types from growing an extra
-  /// `LazySequence` layer.  For example,
-  ///
-  /// _prext_ example needed
+  /// When implementing lazy operations, wrapping `elements` instead of `self`
+  /// can prevent result types from growing an extra `LazySequence` layer.
   ///
   /// Note: this property need not be implemented by conforming types,
   /// it has a default implementation in a protocol extension that

stdlib/public/core/MutableCollection.swift

@@ -57,7 +57,7 @@
 ///     // Must be equivalent to:
 ///     a[i] = x
 ///     let y = x
-public protocol MutableCollection: Collection
+public protocol MutableCollection<Element>: Collection
 where SubSequence: MutableCollection
 {
   // FIXME: Associated type inference requires these.

stdlib/public/core/OptionSet.swift

@@ -83,7 +83,7 @@
 ///         print("Add more to your cart for free priority shipping!")
 ///     }
 ///     // Prints "You've earned free priority shipping!"
-public protocol OptionSet: SetAlgebra, RawRepresentable {
+public protocol OptionSet<Element>: SetAlgebra, RawRepresentable {
   // We can't constrain the associated Element type to be the same as
   // Self, but we can do almost as well with a default and a
   // constrained extension

stdlib/public/core/RandomAccessCollection.swift

@@ -30,7 +30,7 @@
 /// collection, either the index for your custom type must conform to the
 /// `Strideable` protocol or you must implement the `index(_:offsetBy:)` and
 /// `distance(from:to:)` methods with O(1) efficiency.
-public protocol RandomAccessCollection: BidirectionalCollection
+public protocol RandomAccessCollection<Element>: BidirectionalCollection
 where SubSequence: RandomAccessCollection, Indices: RandomAccessCollection
 {
   // FIXME: Associated type inference requires these.

stdlib/public/core/Range.swift

@@ -14,7 +14,7 @@
 ///
 /// A type that conforms to `RangeExpression` can convert itself to a
 /// `Range<Bound>` of indices within a given collection.
-public protocol RangeExpression {
+public protocol RangeExpression<Bound> {
   /// The type for which the expression describes a range.
   associatedtype Bound: Comparable
 

stdlib/public/core/RangeReplaceableCollection.swift

@@ -61,8 +61,8 @@
 /// `replaceSubrange(_:with:)` with an empty collection for the `newElements`
 /// parameter. You can override any of the protocol's required methods to
 /// provide your own custom implementation.
-public protocol RangeReplaceableCollection: Collection
-  where SubSequence: RangeReplaceableCollection {
+public protocol RangeReplaceableCollection<Element>: Collection
+where SubSequence: RangeReplaceableCollection {
   // FIXME: Associated type inference requires this.
   override associatedtype SubSequence
 

stdlib/public/core/SIMDVector.swift

@@ -71,11 +71,13 @@ public protocol SIMDScalar {
 }
 
 /// A SIMD vector of a fixed number of elements.
-public protocol SIMD: SIMDStorage,
-                      Codable,
-                      Hashable,
-                      CustomStringConvertible,
-                      ExpressibleByArrayLiteral {
+public protocol SIMD<Scalar>:
+  SIMDStorage,
+  Codable,
+  Hashable,
+  CustomStringConvertible,
+  ExpressibleByArrayLiteral
+{
   /// The mask type resulting from pointwise comparisons of this vector type.
   associatedtype MaskStorage: SIMD
     where MaskStorage.Scalar: FixedWidthInteger & SignedInteger

stdlib/public/core/Sequence.swift

@@ -174,7 +174,7 @@
 ///     // Prints "3..."
 ///     // Prints "2..."
 ///     // Prints "1..."
-public protocol IteratorProtocol {
+public protocol IteratorProtocol<Element> {
   /// The type of element traversed by the iterator.
   associatedtype Element
 
@@ -322,7 +322,7 @@ public protocol IteratorProtocol {
 /// makes no other requirements about element access, so routines that
 /// traverse a sequence should be considered O(*n*) unless documented
 /// otherwise.
-public protocol Sequence {
+public protocol Sequence<Element> {
   /// A type representing the sequence's elements.
   associatedtype Element
 

stdlib/public/core/SetAlgebra.swift

@@ -52,7 +52,7 @@
 /// - `x.isStrictSuperset(of: y)` if and only if
 ///   `x.isSuperset(of: y) && x != y`
 /// - `x.isStrictSubset(of: y)` if and only if `x.isSubset(of: y) && x != y`
-public protocol SetAlgebra: Equatable, ExpressibleByArrayLiteral {
+public protocol SetAlgebra<Element>: Equatable, ExpressibleByArrayLiteral {
   /// A type for which the conforming type provides a containment test.
   associatedtype Element
 

stdlib/public/core/Stride.swift

@@ -96,7 +96,7 @@
 ///   `Stride` type's implementations. If a type conforming to `Strideable` is
 ///   its own `Stride` type, it must provide concrete implementations of the
 ///   two operators to avoid infinite recursion.
-public protocol Strideable: Comparable {
+public protocol Strideable<Stride>: Comparable {
   /// A type that represents the distance between two values.
   associatedtype Stride: SignedNumeric, Comparable