[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