project: address Swiftlint issues

Author: Thibault Wittemberg

Sources/AsyncSequences/AsyncSequences+Merge.swift

@@ -90,7 +90,6 @@ public struct AsyncMergeSequence<UpstreamAsyncSequence: AsyncSequence>: AsyncSeq
     //    }
 
     public struct Iterator: AsyncIteratorProtocol {
-
         var downstreamIterator: AsyncStreams.Passthrough<UpstreamElement>.AsyncIterator
         let upstreamAsyncSequenceRegulators: [ConcurrentAccessRegulator<UpstreamAsyncSequence>]
         // let elementCounter = ElementCounter()

Sources/AsyncStreams/AsyncStreams+Passthrough.swift

@@ -43,7 +43,7 @@ public final class AsyncPassthroughStream<Element>: Stream, @unchecked Sendable
     // because of its async nature. Doing so, it means that we could call `send` while the registration is not done and we
     // would loose the value.
     let serialQueue = DispatchQueue(label: UUID().uuidString)
-    
+
     let continuations = AsyncStreams.Continuations<Element>()
 
     public init() {}

Sources/AsyncStreams/AsyncStreams+Replay.swift

@@ -63,7 +63,7 @@ public final class AsyncReplayStream<Element>: Stream, @unchecked Sendable {
     // because of its async nature. Doing so, it means that we could call `send` while the registration is not done and we
     // would loose the value.
     let serialQueue = DispatchQueue(label: UUID().uuidString)
-    
+
     let continuations = AsyncStreams.Continuations<Element>()
     let storage: Storage
 

Sources/AsyncStreams/AsyncStreams.swift

@@ -17,7 +17,7 @@ public enum AsyncStreams {}
 extension AsyncStreams {
     // Continuations can be accessed in a concurrent context. It is up to the caller to ensure
     // the usage in a safe way (cf Passthrough, CurrrentValue and Replay)
-    final class Continuations<Element>{
+    final class Continuations<Element> {
         var continuations = [AnyHashable: AsyncThrowingStream<Element, Error>.Continuation]()
 
         func send(_ element: Element) {

Sources/Internal/ConcurrentAccessRegulator.swift

@@ -59,9 +59,9 @@ final class ConcurrentAccessRegulator<UpstreamAsyncSequence: AsyncSequence>: @un
         do {
             let next = try await self.upstreamAsyncIterator?.next()
             await self.onNext(next)
-            
+
             await self.gate.unlock()
-            
+
             // yield allows to promote other tasks to resume, giving a chance to request a next element
             await Task.yield()
         } catch is CancellationError {

Sources/Operators/AsyncSequence+Multicast.swift

@@ -44,7 +44,8 @@ public extension AsyncSequence {
     ///     // Stream 2 received: ("Third", 61)
     ///     // Stream 1 received: ("Third", 61)
     /// ```
-    /// In this example, the output shows that the upstream async sequence produces each random value only one time, and then sends the value to both client loops.
+    /// In this example, the output shows that the upstream async sequence produces each random value only one time,
+    /// and then sends the value to both client loops.
     ///
     /// - Parameter stream: A `Stream` to deliver elements to downstream client loops.
     func multicast<S: Stream>(_ stream: S) -> AsyncMulticastSequence<Self, S> where S.Element == Element {
@@ -79,7 +80,7 @@ where UpstreamAsyncSequence.Element == DownstreamStream.Element {
 
     /// Automates the process of connecting the multicasted async sequence.
     ///
-    ///```
+    /// ```
     ///     let stream = AsyncStreams.Passthrough<(String, Int)>()
     ///     let multicastedAsyncSequence = ["First", "Second", "Third"]
     ///         .asyncElements

Sources/Operators/AsyncSequence+Share.swift

@@ -10,8 +10,8 @@ public extension AsyncSequence {
     ///
     ///  - Tip: ``share()`` is effectively a shortcut for ``multicast()`` using a ``Passthrough`` stream, with an implicit ``autoconnect()``.
     ///
-    /// The following example uses an async sequence as a counter to emit three random numbers. Each element is delayed by 1s to give the seconf loop a chance to
-    /// catch all the values.
+    /// The following example uses an async sequence as a counter to emit three random numbers.
+    /// Each element is delayed by 1s to give the seconf loop a chance to catch all the values.
     ///
     /// ```
     ///     let sharedAsyncSequence = AsyncSequences.From(["first", "second", "third"], interval: .seconds(1))
@@ -40,7 +40,8 @@ public extension AsyncSequence {
     ///     // Stream 2 received: ("Third", 61)
     ///     // Stream 1 received: ("Third", 61)
     /// ```
-    /// In this example, the output shows that the upstream async sequence produces each random value only one time, and then sends the value to both client loops.
+    /// In this example, the output shows that the upstream async sequence produces each random value only one time,
+    /// and then sends the value to both client loops.
     ///
     /// Without the ``share()`` operator, loop 1 receives three random values, followed by loop 2 receiving three different random values.
     ///
@@ -53,7 +54,6 @@ public extension AsyncSequence {
     }
 }
 
-extension AsyncSequences {
-    public typealias AsyncShareSequence<UpstreamAsyncSequence: AsyncSequence> =
-    AsyncMulticastSequence<UpstreamAsyncSequence,AsyncStreams.Passthrough<UpstreamAsyncSequence.Element>>
+public extension AsyncSequences {
+    typealias AsyncShareSequence<S: AsyncSequence> = AsyncMulticastSequence<S, AsyncStreams.Passthrough<S.Element>>
 }