Restore availability and mark everything as 9999 to match stdlib availability for 5.7 for now (#82)

phausler · web-flow · commit 822ca9365c98 · 2022-03-15T09:21:51.000-07:00
diff --git a/Package.swift b/Package.swift
@@ -20,18 +20,12 @@ let package = Package(
   dependencies: [],
   targets: [
     .target(
-      name: "AsyncAlgorithms",
-      swiftSettings: [
-        .unsafeFlags([
-          "-Xfrontend", "-disable-availability-checking"
-        ])
-      ]),
+      name: "AsyncAlgorithms"),
     .target(
       name: "AsyncSequenceValidation",
       dependencies: ["_CAsyncSequenceValidationSupport"],
       swiftSettings: [
         .unsafeFlags([
-          "-Xfrontend", "-disable-availability-checking",
           "-Xfrontend", "-enable-experimental-pairwise-build-block"
         ])
       ]),
diff --git a/Sources/AsyncAlgorithms/AsyncChunksOfCountOrSignalSequence.swift b/Sources/AsyncAlgorithms/AsyncChunksOfCountOrSignalSequence.swift
@@ -26,18 +26,22 @@ extension AsyncSequence {
     chunked(by: signal, into: [Element].self)
   }
 
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func chunks<C: Clock, Collected: RangeReplaceableCollection>(ofCount count: Int, or timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
     AsyncChunksOfCountOrSignalSequence(self, count: count, signal: timer)
   }
 
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func chunks<C: Clock>(ofCount count: Int, or timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
     chunks(ofCount: count, or: timer, into: [Element].self)
   }
 
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func chunked<C: Clock, Collected: RangeReplaceableCollection>(by timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {
     AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: timer)
   }
 
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func chunked<C: Clock>(by timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {
     chunked(by: timer, into: [Element].self)
   }
diff --git a/Sources/AsyncAlgorithms/AsyncDebounceSequence.swift b/Sources/AsyncAlgorithms/AsyncDebounceSequence.swift
@@ -10,15 +10,18 @@
 //===----------------------------------------------------------------------===//
 
 extension AsyncSequence {
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func debounce<C: Clock>(for interval: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C) -> AsyncDebounceSequence<Self, C> {
     AsyncDebounceSequence(self, interval: interval, tolerance: tolerance, clock: clock)
   }
   
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func debounce(for interval: Duration, tolerance: Duration? = nil) -> AsyncDebounceSequence<Self, ContinuousClock> {
     debounce(for: interval, tolerance: tolerance, clock: .continuous)
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 public struct AsyncDebounceSequence<Base: AsyncSequence, C: Clock>: Sendable
   where Base.AsyncIterator: Sendable, Base.Element: Sendable, Base: Sendable {
   let base: Base
@@ -34,6 +37,7 @@ public struct AsyncDebounceSequence<Base: AsyncSequence, C: Clock>: Sendable
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncDebounceSequence: AsyncSequence {
   public typealias Element = Base.Element
   
diff --git a/Sources/AsyncAlgorithms/AsyncThrottleSequence.swift b/Sources/AsyncAlgorithms/AsyncThrottleSequence.swift
@@ -10,14 +10,17 @@
 //===----------------------------------------------------------------------===//
 
 extension AsyncSequence {
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func throttle<C: Clock, Reduced>(for interval: C.Instant.Duration, clock: C, reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced) -> AsyncThrottleSequence<Self, C, Reduced> {
     AsyncThrottleSequence(self, interval: interval, clock: clock, reducing: reducing)
   }
   
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func throttle<Reduced>(for interval: Duration, reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced) -> AsyncThrottleSequence<Self, ContinuousClock, Reduced> {
     throttle(for: interval, clock: .continuous, reducing: reducing)
   }
   
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func throttle<C: Clock>(for interval: C.Instant.Duration, clock: C, latest: Bool = true) -> AsyncThrottleSequence<Self, C, Element> {
     throttle(for: interval, clock: clock) { previous, element in
       if latest {
@@ -28,11 +31,13 @@ extension AsyncSequence {
     }
   }
   
+  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
   public func throttle(for interval: Duration, latest: Bool = true) -> AsyncThrottleSequence<Self, ContinuousClock, Element> {
     throttle(for: interval, clock: .continuous, latest: latest)
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 public struct AsyncThrottleSequence<Base: AsyncSequence, C: Clock, Reduced> {
   let base: Base
   let interval: C.Instant.Duration
@@ -47,6 +52,7 @@ public struct AsyncThrottleSequence<Base: AsyncSequence, C: Clock, Reduced> {
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncThrottleSequence: AsyncSequence {
   public typealias Element = Reduced
   
@@ -85,5 +91,8 @@ extension AsyncThrottleSequence: AsyncSequence {
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncThrottleSequence: Sendable where Base: Sendable, Element: Sendable { }
+
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncThrottleSequence.Iterator: Sendable where Base.AsyncIterator: Sendable { }
diff --git a/Sources/AsyncAlgorithms/AsyncTimerSequence.swift b/Sources/AsyncAlgorithms/AsyncTimerSequence.swift
@@ -9,6 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 public struct AsyncTimerSequence<C: Clock>: AsyncSequence {
   public typealias Element = C.Instant
   
@@ -67,18 +68,22 @@ public struct AsyncTimerSequence<C: Clock>: AsyncSequence {
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncTimerSequence {
   public static func repeating(every interval: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C) -> AsyncTimerSequence<C> {
     return AsyncTimerSequence(interval: interval, tolerance: tolerance, clock: clock)
   }
 }
 
-
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncTimerSequence where C == SuspendingClock {
   public static func repeating(every interval: Duration, tolerance: Duration? = nil) -> AsyncTimerSequence<SuspendingClock> {
     return AsyncTimerSequence(interval: interval, tolerance: tolerance, clock: SuspendingClock())
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncTimerSequence: Sendable { }
+
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncTimerSequence.Iterator: Sendable { }
diff --git a/Sources/AsyncSequenceValidation/AsyncSequenceValidationDiagram.swift b/Sources/AsyncSequenceValidation/AsyncSequenceValidationDiagram.swift
@@ -11,6 +11,7 @@
 
 import _CAsyncSequenceValidationSupport
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 @resultBuilder
 public struct AsyncSequenceValidationDiagram : Sendable {
   public struct Component<T> {
diff --git a/Sources/AsyncSequenceValidation/Clock.swift b/Sources/AsyncSequenceValidation/Clock.swift
@@ -9,6 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram {
   public struct Clock {
     let queue: WorkQueue
@@ -19,6 +20,7 @@ extension AsyncSequenceValidationDiagram {
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram.Clock: Clock {
   public struct Step: DurationProtocol, Hashable, CustomStringConvertible {
     internal var rawValue: Int
diff --git a/Sources/AsyncSequenceValidation/Event.swift b/Sources/AsyncSequenceValidation/Event.swift
@@ -9,6 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram {
   struct Failure: Error, Equatable { }
   
diff --git a/Sources/AsyncSequenceValidation/Expectation.swift b/Sources/AsyncSequenceValidation/Expectation.swift
@@ -9,6 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram {
   public struct ExpectationResult: Sendable {
     public struct Event: Sendable {
diff --git a/Sources/AsyncSequenceValidation/Input.swift b/Sources/AsyncSequenceValidation/Input.swift
@@ -9,6 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram {
   public struct Specification: Sendable {
     public let specification: String
diff --git a/Sources/AsyncSequenceValidation/Job.swift b/Sources/AsyncSequenceValidation/Job.swift
@@ -11,6 +11,7 @@
 
 import _CAsyncSequenceValidationSupport
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 struct Job: Hashable, @unchecked Sendable {
   let job: JobRef
   
diff --git a/Sources/AsyncSequenceValidation/TaskDriver.swift b/Sources/AsyncSequenceValidation/TaskDriver.swift
@@ -19,11 +19,13 @@ import _CAsyncSequenceValidationSupport
 #error("TODO: Port TaskDriver threading to windows")
 #endif
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 func start_thread(_ raw: UnsafeMutableRawPointer) -> UnsafeMutableRawPointer? {
   Unmanaged<TaskDriver>.fromOpaque(raw).takeRetainedValue().run()
   return nil
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 final class TaskDriver {
   let work: (TaskDriver) -> Void
   let queue: WorkQueue
diff --git a/Sources/AsyncSequenceValidation/Test.swift b/Sources/AsyncSequenceValidation/Test.swift
@@ -18,13 +18,15 @@ internal func _swiftJobRun(
   _ executor: UnownedSerialExecutor
 ) -> ()
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 public protocol AsyncSequenceValidationTest: Sendable {
   var inputs: [AsyncSequenceValidationDiagram.Specification] { get }
   var output: AsyncSequenceValidationDiagram.Specification { get }
   
   func test<C: Clock>(with clock: C, activeTicks: [C.Instant], output: AsyncSequenceValidationDiagram.Specification, _ event: (String) -> Void) async throws
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram {
   struct Test<Operation: AsyncSequence>: AsyncSequenceValidationTest, @unchecked Sendable where Operation.Element == String {
     let inputs: [Specification]
diff --git a/Sources/AsyncSequenceValidation/Theme.swift b/Sources/AsyncSequenceValidation/Theme.swift
@@ -9,18 +9,21 @@
 //
 //===----------------------------------------------------------------------===//
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 public protocol AsyncSequenceValidationTheme {
   func token(_ character: Character, inValue: Bool) -> AsyncSequenceValidationDiagram.Token
   
   func description(for token: AsyncSequenceValidationDiagram.Token) -> String
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationTheme where Self == AsyncSequenceValidationDiagram.ASCIITheme {
   public static var ascii: AsyncSequenceValidationDiagram.ASCIITheme {
     return AsyncSequenceValidationDiagram.ASCIITheme()
   }
 }
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 extension AsyncSequenceValidationDiagram {
   public enum Token: Sendable {
     case step
diff --git a/Sources/AsyncSequenceValidation/WorkQueue.swift b/Sources/AsyncSequenceValidation/WorkQueue.swift
@@ -9,6 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
 struct WorkQueue: Sendable {
   enum Item: CustomStringConvertible, Comparable {
     case blocked(Token, AsyncSequenceValidationDiagram.Clock.Instant, UnsafeContinuation<Void, Error>)

Original file line number	Diff line number	Diff line change
`@@ -26,18 +26,22 @@ extension AsyncSequence {`
`26`	`26`	`chunked(by: signal, into: [Element].self)`
`27`	`27`	`}`
`28`	`28`
	`29`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`29`	`30`	`public func chunks<C: Clock, Collected: RangeReplaceableCollection>(ofCount count: Int, or timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {`
`30`	`31`	`AsyncChunksOfCountOrSignalSequence(self, count: count, signal: timer)`
`31`	`32`	`}`
`32`	`33`
	`34`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`33`	`35`	`public func chunks<C: Clock>(ofCount count: Int, or timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {`
`34`	`36`	`chunks(ofCount: count, or: timer, into: [Element].self)`
`35`	`37`	`}`
`36`	`38`
	`39`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`37`	`40`	`public func chunked<C: Clock, Collected: RangeReplaceableCollection>(by timer: AsyncTimerSequence<C>, into: Collected.Type) -> AsyncChunksOfCountOrSignalSequence<Self, Collected, AsyncTimerSequence<C>> where Collected.Element == Element {`
`38`	`41`	`AsyncChunksOfCountOrSignalSequence(self, count: nil, signal: timer)`
`39`	`42`	`}`
`40`	`43`
	`44`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`41`	`45`	`public func chunked<C: Clock>(by timer: AsyncTimerSequence<C>) -> AsyncChunksOfCountOrSignalSequence<Self, [Element], AsyncTimerSequence<C>> {`
`42`	`46`	`chunked(by: timer, into: [Element].self)`
`43`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,15 +10,18 @@`
`10`	`10`	`//===----------------------------------------------------------------------===//`
`11`	`11`
`12`	`12`	`extension AsyncSequence {`
	`13`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`13`	`14`	`public func debounce<C: Clock>(for interval: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C) -> AsyncDebounceSequence<Self, C> {`
`14`	`15`	`AsyncDebounceSequence(self, interval: interval, tolerance: tolerance, clock: clock)`
`15`	`16`	`}`
`16`	`17`
	`18`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`17`	`19`	`public func debounce(for interval: Duration, tolerance: Duration? = nil) -> AsyncDebounceSequence<Self, ContinuousClock> {`
`18`	`20`	`debounce(for: interval, tolerance: tolerance, clock: .continuous)`
`19`	`21`	`}`
`20`	`22`	`}`
`21`	`23`
	`24`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`22`	`25`	`public struct AsyncDebounceSequence<Base: AsyncSequence, C: Clock>: Sendable`
`23`	`26`	`where Base.AsyncIterator: Sendable, Base.Element: Sendable, Base: Sendable {`
`24`	`27`	`let base: Base`
`@@ -34,6 +37,7 @@ public struct AsyncDebounceSequence<Base: AsyncSequence, C: Clock>: Sendable`
`34`	`37`	`}`
`35`	`38`	`}`
`36`	`39`
	`40`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`37`	`41`	`extension AsyncDebounceSequence: AsyncSequence {`
`38`	`42`	`public typealias Element = Base.Element`
`39`	`43`
Original file line number	Diff line number	Diff line change
`@@ -10,14 +10,17 @@`
`10`	`10`	`//===----------------------------------------------------------------------===//`
`11`	`11`
`12`	`12`	`extension AsyncSequence {`
	`13`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`13`	`14`	`public func throttle<C: Clock, Reduced>(for interval: C.Instant.Duration, clock: C, reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced) -> AsyncThrottleSequence<Self, C, Reduced> {`
`14`	`15`	`AsyncThrottleSequence(self, interval: interval, clock: clock, reducing: reducing)`
`15`	`16`	`}`
`16`	`17`
	`18`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`17`	`19`	`public func throttle<Reduced>(for interval: Duration, reducing: @Sendable @escaping (Reduced?, Element) async -> Reduced) -> AsyncThrottleSequence<Self, ContinuousClock, Reduced> {`
`18`	`20`	`throttle(for: interval, clock: .continuous, reducing: reducing)`
`19`	`21`	`}`
`20`	`22`
	`23`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`21`	`24`	`public func throttle<C: Clock>(for interval: C.Instant.Duration, clock: C, latest: Bool = true) -> AsyncThrottleSequence<Self, C, Element> {`
`22`	`25`	`throttle(for: interval, clock: clock) { previous, element in`
`23`	`26`	`if latest {`
`@@ -28,11 +31,13 @@ extension AsyncSequence {`
`28`	`31`	`}`
`29`	`32`	`}`
`30`	`33`
	`34`	`+ @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`31`	`35`	`public func throttle(for interval: Duration, latest: Bool = true) -> AsyncThrottleSequence<Self, ContinuousClock, Element> {`
`32`	`36`	`throttle(for: interval, clock: .continuous, latest: latest)`
`33`	`37`	`}`
`34`	`38`	`}`
`35`	`39`
	`40`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`36`	`41`	`public struct AsyncThrottleSequence<Base: AsyncSequence, C: Clock, Reduced> {`
`37`	`42`	`let base: Base`
`38`	`43`	`let interval: C.Instant.Duration`
`@@ -47,6 +52,7 @@ public struct AsyncThrottleSequence<Base: AsyncSequence, C: Clock, Reduced> {`
`47`	`52`	`}`
`48`	`53`	`}`
`49`	`54`
	`55`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`50`	`56`	`extension AsyncThrottleSequence: AsyncSequence {`
`51`	`57`	`public typealias Element = Reduced`
`52`	`58`
`@@ -85,5 +91,8 @@ extension AsyncThrottleSequence: AsyncSequence {`
`85`	`91`	`}`
`86`	`92`	`}`
`87`	`93`
	`94`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`88`	`95`	`extension AsyncThrottleSequence: Sendable where Base: Sendable, Element: Sendable { }`
	`96`	`+`
	`97`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`89`	`98`	`extension AsyncThrottleSequence.Iterator: Sendable where Base.AsyncIterator: Sendable { }`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`//`
`10`	`10`	`//===----------------------------------------------------------------------===//`
`11`	`11`
	`12`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`12`	`13`	`public struct AsyncTimerSequence<C: Clock>: AsyncSequence {`
`13`	`14`	`public typealias Element = C.Instant`
`14`	`15`
`@@ -67,18 +68,22 @@ public struct AsyncTimerSequence<C: Clock>: AsyncSequence {`
`67`	`68`	`}`
`68`	`69`	`}`
`69`	`70`
	`71`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`70`	`72`	`extension AsyncTimerSequence {`
`71`	`73`	`public static func repeating(every interval: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C) -> AsyncTimerSequence<C> {`
`72`	`74`	`return AsyncTimerSequence(interval: interval, tolerance: tolerance, clock: clock)`
`73`	`75`	`}`
`74`	`76`	`}`
`75`	`77`
`76`		`-`
	`78`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`77`	`79`	`extension AsyncTimerSequence where C == SuspendingClock {`
`78`	`80`	`public static func repeating(every interval: Duration, tolerance: Duration? = nil) -> AsyncTimerSequence<SuspendingClock> {`
`79`	`81`	`return AsyncTimerSequence(interval: interval, tolerance: tolerance, clock: SuspendingClock())`
`80`	`82`	`}`
`81`	`83`	`}`
`82`	`84`
	`85`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`83`	`86`	`extension AsyncTimerSequence: Sendable { }`
	`87`	`+`
	`88`	`+@available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)`
`84`	`89`	`extension AsyncTimerSequence.Iterator: Sendable { }`