Reorder try await to latest syntax

phausler · phausler · commit 10feb16b8af0 · 2021-01-12T10:58:53.000-08:00
diff --git a/stdlib/public/Concurrency/AllSatisfy.swift b/stdlib/public/Concurrency/AllSatisfy.swift
@@ -15,8 +15,8 @@ import Swift
 extension AsyncSequence {
   public func allSatisfy(_ predicate: (Element) async throws -> Bool) async rethrows -> Bool {
     var it = makeAsyncIterator()
-    while let element = await try it.next() {
-      if !(await try predicate(element)) {
+    while let element = try await it.next() {
+      if !(try await predicate(element)) {
         return false
       }
     }
diff --git a/stdlib/public/Concurrency/AsyncCompactMapSequence.swift b/stdlib/public/Concurrency/AsyncCompactMapSequence.swift
@@ -37,7 +37,7 @@ public struct AsyncCompactMapSequence<Upstream, ElementOfResult>: AsyncSequence
     
     public mutating func next() async rethrows -> ElementOfResult? {
       while true {
-        guard let item = await try upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator?.next() else {
           return nil
         }
         if let transformed = await transform(item) {
@@ -80,11 +80,11 @@ public struct AsyncTryCompactMapSequence<Upstream, ElementOfResult>: AsyncSequen
     
     public mutating func next() async throws -> ElementOfResult? {
       while true {
-        guard let item = await try upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator?.next() else {
           return nil
         }
         do {
-          if let transformed = await try transform(item) {
+          if let transformed = try await transform(item) {
             return transformed
           }
         } catch {
diff --git a/stdlib/public/Concurrency/AsyncConcatSequence.swift b/stdlib/public/Concurrency/AsyncConcatSequence.swift
@@ -36,11 +36,11 @@ public struct AsyncConcatSequence<Prefix, Suffix>: AsyncSequence where Prefix: A
     }
     
     public mutating func next() async rethrows -> Prefix.Element? {
-      if let item = await try prefixIterator?.next() {
+      if let item = try await prefixIterator?.next() {
         return item
       }
       prefixIterator = nil
-      return await try suffixIterator?.next()
+      return try await suffixIterator?.next()
     }
     
     public mutating func cancel() {
diff --git a/stdlib/public/Concurrency/AsyncDropWhileSequence.swift b/stdlib/public/Concurrency/AsyncDropWhileSequence.swift
@@ -37,7 +37,7 @@ public struct AsyncDropWhileSequence<Upstream>: AsyncSequence where Upstream: As
     
     public mutating func next() async rethrows -> Upstream.Element? {
       while true {
-        guard let item = await try upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator?.next() else {
           return nil
         }
         if let predicate = self.predicate {
@@ -85,12 +85,12 @@ public struct AsyncTryDropWhileSequence<Upstream>: AsyncSequence where Upstream:
     
     public mutating func next() async throws -> Upstream.Element? {
       while true {
-        guard let item = await try upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator?.next() else {
           return nil
         }
         if let predicate = self.predicate {
           do {
-            if !(await try predicate(item)) {
+            if !(try await predicate(item)) {
               self.predicate = nil
               return item
             }
diff --git a/stdlib/public/Concurrency/AsyncFilterSequence.swift b/stdlib/public/Concurrency/AsyncFilterSequence.swift
@@ -41,7 +41,7 @@ public struct AsyncFilterSequence<Upstream>: AsyncSequence where Upstream: Async
     }
     
     public mutating func next() async rethrows -> Upstream.Element? {
-      guard let item = await try upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator?.next() else {
         return nil
       }
       guard await predicate(item) else {
@@ -87,10 +87,10 @@ public struct AsyncTryFilterSequence<Upstream>: AsyncSequence where Upstream: As
     }
     
     public mutating func next() async throws -> Upstream.Element? {
-      guard let item = await try upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator?.next() else {
         return nil
       }
-      guard await try predicate(item) else {
+      guard try await predicate(item) else {
       upstreamIterator?.cancel()
       upstreamIterator = nil
       return nil
diff --git a/stdlib/public/Concurrency/AsyncFlatMapSequence.swift b/stdlib/public/Concurrency/AsyncFlatMapSequence.swift
@@ -37,15 +37,15 @@ public struct AsyncFlatMapSequence<Upstream, SegmentOfResult: AsyncSequence>: As
     }
     
     public mutating func next() async rethrows -> SegmentOfResult.Element? {
-      if let item = await try currentIterator?.next() {
+      if let item = try await currentIterator?.next() {
         return item
       } else {
-        guard let item = await try upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator?.next() else {
           return nil
         }
         let segment = await transform(item)
         currentIterator = segment.makeAsyncIterator()
-        return await try currentIterator?.next()
+        return try await currentIterator?.next()
       }
     }
     
@@ -85,15 +85,15 @@ public struct AsyncTryFlatMapSequence<Upstream, SegmentOfResult: AsyncSequence>:
     }
     
     public mutating func next() async throws -> SegmentOfResult.Element? {
-      if let item = await try currentIterator?.next() {
+      if let item = try await currentIterator?.next() {
         return item
       } else {
-        guard let item = await try upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator?.next() else {
           return nil
         }
-        let segment = await try transform(item)
+        let segment = try await transform(item)
         currentIterator = segment.makeAsyncIterator()
-        return await try currentIterator?.next()
+        return try await currentIterator?.next()
       }
     }
     
diff --git a/stdlib/public/Concurrency/AsyncMapSequence.swift b/stdlib/public/Concurrency/AsyncMapSequence.swift
@@ -38,7 +38,7 @@ public struct AsyncMapSequence<Upstream, Transformed>: AsyncSequence where Upstr
     }
     
     public mutating func next() async rethrows -> Transformed? {
-      guard let item = await try upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator?.next() else {
         return nil
       }
       return await transform(item)
@@ -79,10 +79,10 @@ public struct AsyncTryMapSequence<Upstream, Transformed>: AsyncSequence where Up
     }
     
     public mutating func next() async throws -> Transformed? {
-      guard let item = await try upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator?.next() else {
         return nil
       }
-      return await try transform(item)
+      return try await transform(item)
     }
     
     public mutating func cancel() {
diff --git a/stdlib/public/Concurrency/AsyncPrefixWhileSequence.swift b/stdlib/public/Concurrency/AsyncPrefixWhileSequence.swift
@@ -36,7 +36,7 @@ public struct AsyncPrefixWhileSequence<Upstream>: AsyncSequence where Upstream:
     }
     
     public mutating func next() async rethrows -> Element? {
-      guard let item = await try upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator?.next() else {
         return nil
       }
       guard await predicate(item) else {
@@ -80,10 +80,10 @@ public struct AsyncTryPrefixWhileSequence<Upstream>: AsyncSequence where Upstrea
     }
     
     public mutating func next() async throws -> Element? {
-      guard let item = await try upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator?.next() else {
         return nil
       }
-      guard await try predicate(item) else {
+      guard try await predicate(item) else {
         upstreamIterator?.cancel()
         upstreamIterator = nil
         return nil
diff --git a/stdlib/public/Concurrency/Contains.swift b/stdlib/public/Concurrency/Contains.swift
@@ -15,8 +15,8 @@ import Swift
 extension AsyncSequence {
   public func contains(where predicate: (Element) async throws -> Bool) async rethrows -> Bool {
     var it = makeAsyncIterator()
-    while let e = await try it.next() {
-      if await try predicate(e) {
+    while let e = try await it.next() {
+      if try await predicate(e) {
         return true
       }
     }
diff --git a/stdlib/public/Concurrency/Count.swift b/stdlib/public/Concurrency/Count.swift
@@ -16,7 +16,7 @@ extension AsyncSequence {
   public func count() async rethrows -> Int {
     var count = 0
     var it = makeAsyncIterator()
-    while await try it.next() != nil {
+    while try await it.next() != nil {
       count += 1
     }
     return count
diff --git a/stdlib/public/Concurrency/First.swift b/stdlib/public/Concurrency/First.swift
@@ -15,8 +15,8 @@ import Swift
 extension AsyncSequence {
   public func first(where predicate: (Element) async throws -> Bool) async rethrows -> Element? {
     var it = makeAsyncIterator()
-    while let element = await try it.next() {
-      if await try predicate(element) {
+    while let element = try await it.next() {
+      if try await predicate(element) {
         return element
       }
     }
@@ -25,6 +25,6 @@ extension AsyncSequence {
   
   public func first() async rethrows -> Element? {
     var it = makeAsyncIterator()
-    return await try it.next()
+    return try await it.next()
   }
 }
diff --git a/stdlib/public/Concurrency/MinMax.swift b/stdlib/public/Concurrency/MinMax.swift
@@ -15,29 +15,29 @@ import Swift
 extension AsyncSequence {
   public func min(by areInIncreasingOrder: (Element, Element) async throws -> Bool) async rethrows -> Element? {
     var it = makeAsyncIterator()
-    guard var result = await try it.next() else { return nil }
-    while let e = await try it.next() {
-      if await try areInIncreasingOrder(e, result) { result = e }
+    guard var result = try await it.next() else { return nil }
+    while let e = try await it.next() {
+      if try await areInIncreasingOrder(e, result) { result = e }
     }
     return result
   }
   
   public func max(by areInIncreasingOrder: (Element, Element) async throws -> Bool) async rethrows -> Element? {
     var it = makeAsyncIterator()
-    guard var result = await try it.next() else { return nil }
-    while let e = await try it.next() {
-      if await try areInIncreasingOrder(result, e) { result = e }
+    guard var result = try await it.next() else { return nil }
+    while let e = try await it.next() {
+      if try await areInIncreasingOrder(result, e) { result = e }
     }
     return result
   }
 }
 
 extension AsyncSequence where Element: Comparable {
   public func min() async rethrows -> Element? {
-    return await try min(by: <)
+    return try await min(by: <)
   }
   
   public func max() async rethrows -> Element? {
-    return await try max(by: <)
+    return try await max(by: <)
   }
 }
diff --git a/stdlib/public/Concurrency/Reduce.swift b/stdlib/public/Concurrency/Reduce.swift
@@ -16,17 +16,17 @@ extension AsyncSequence {
   public func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (_ partialResult: Result, Element) async throws -> Result) async rethrows -> Result {
     var accumulator = initialResult
     var it = makeAsyncIterator()
-    while let element = await try it.next() {
-      accumulator = await try nextPartialResult(accumulator, element)
+    while let element = try await it.next() {
+      accumulator = try await nextPartialResult(accumulator, element)
     }
     return accumulator
   }
   
   public func reduce<Result>(into initialResult: __owned Result, _ updateAccumulatingResult: (_ partialResult: inout Result, Element) async throws -> Void) async rethrows -> Result {
     var accumulator = initialResult
     var it = makeAsyncIterator()
-    while let element = await try it.next() {
-      await try updateAccumulatingResult(&accumulator, element)
+    while let element = try await it.next() {
+      try await updateAccumulatingResult(&accumulator, element)
     }
     return accumulator
   }

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,8 @@ import Swift`
`15`	`15`	`extension AsyncSequence {`
`16`	`16`	`public func allSatisfy(_ predicate: (Element) async throws -> Bool) async rethrows -> Bool {`
`17`	`17`	`var it = makeAsyncIterator()`
`18`		`- while let element = await try it.next() {`
`19`		`- if !(await try predicate(element)) {`
	`18`	`+ while let element = try await it.next() {`
	`19`	`+ if !(try await predicate(element)) {`
`20`	`20`	`return false`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,11 +36,11 @@ public struct AsyncConcatSequence<Prefix, Suffix>: AsyncSequence where Prefix: A`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public mutating func next() async rethrows -> Prefix.Element? {`
`39`		`- if let item = await try prefixIterator?.next() {`
	`39`	`+ if let item = try await prefixIterator?.next() {`
`40`	`40`	`return item`
`41`	`41`	`}`
`42`	`42`	`prefixIterator = nil`
`43`		`- return await try suffixIterator?.next()`
	`43`	`+ return try await suffixIterator?.next()`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public mutating func cancel() {`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ public struct AsyncFilterSequence<Upstream>: AsyncSequence where Upstream: Async`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public mutating func next() async rethrows -> Upstream.Element? {`
`44`		`- guard let item = await try upstreamIterator?.next() else {`
	`44`	`+ guard let item = try await upstreamIterator?.next() else {`
`45`	`45`	`return nil`
`46`	`46`	`}`
`47`	`47`	`guard await predicate(item) else {`
`@@ -87,10 +87,10 @@ public struct AsyncTryFilterSequence<Upstream>: AsyncSequence where Upstream: As`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`public mutating func next() async throws -> Upstream.Element? {`
`90`		`- guard let item = await try upstreamIterator?.next() else {`
	`90`	`+ guard let item = try await upstreamIterator?.next() else {`
`91`	`91`	`return nil`
`92`	`92`	`}`
`93`		`- guard await try predicate(item) else {`
	`93`	`+ guard try await predicate(item) else {`
`94`	`94`	`upstreamIterator?.cancel()`
`95`	`95`	`upstreamIterator = nil`
`96`	`96`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -37,15 +37,15 @@ public struct AsyncFlatMapSequence<Upstream, SegmentOfResult: AsyncSequence>: As`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public mutating func next() async rethrows -> SegmentOfResult.Element? {`
`40`		`- if let item = await try currentIterator?.next() {`
	`40`	`+ if let item = try await currentIterator?.next() {`
`41`	`41`	`return item`
`42`	`42`	`} else {`
`43`		`- guard let item = await try upstreamIterator?.next() else {`
	`43`	`+ guard let item = try await upstreamIterator?.next() else {`
`44`	`44`	`return nil`
`45`	`45`	`}`
`46`	`46`	`let segment = await transform(item)`
`47`	`47`	`currentIterator = segment.makeAsyncIterator()`
`48`		`- return await try currentIterator?.next()`
	`48`	`+ return try await currentIterator?.next()`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`@@ -85,15 +85,15 @@ public struct AsyncTryFlatMapSequence<Upstream, SegmentOfResult: AsyncSequence>:`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`public mutating func next() async throws -> SegmentOfResult.Element? {`
`88`		`- if let item = await try currentIterator?.next() {`
	`88`	`+ if let item = try await currentIterator?.next() {`
`89`	`89`	`return item`
`90`	`90`	`} else {`
`91`		`- guard let item = await try upstreamIterator?.next() else {`
	`91`	`+ guard let item = try await upstreamIterator?.next() else {`
`92`	`92`	`return nil`
`93`	`93`	`}`
`94`		`- let segment = await try transform(item)`
	`94`	`+ let segment = try await transform(item)`
`95`	`95`	`currentIterator = segment.makeAsyncIterator()`
`96`		`- return await try currentIterator?.next()`
	`96`	`+ return try await currentIterator?.next()`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public struct AsyncMapSequence<Upstream, Transformed>: AsyncSequence where Upstr`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`public mutating func next() async rethrows -> Transformed? {`
`41`		`- guard let item = await try upstreamIterator?.next() else {`
	`41`	`+ guard let item = try await upstreamIterator?.next() else {`
`42`	`42`	`return nil`
`43`	`43`	`}`
`44`	`44`	`return await transform(item)`
`@@ -79,10 +79,10 @@ public struct AsyncTryMapSequence<Upstream, Transformed>: AsyncSequence where Up`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`public mutating func next() async throws -> Transformed? {`
`82`		`- guard let item = await try upstreamIterator?.next() else {`
	`82`	`+ guard let item = try await upstreamIterator?.next() else {`
`83`	`83`	`return nil`
`84`	`84`	`}`
`85`		`- return await try transform(item)`
	`85`	`+ return try await transform(item)`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`public mutating func cancel() {`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public struct AsyncPrefixWhileSequence<Upstream>: AsyncSequence where Upstream:`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public mutating func next() async rethrows -> Element? {`
`39`		`- guard let item = await try upstreamIterator?.next() else {`
	`39`	`+ guard let item = try await upstreamIterator?.next() else {`
`40`	`40`	`return nil`
`41`	`41`	`}`
`42`	`42`	`guard await predicate(item) else {`
`@@ -80,10 +80,10 @@ public struct AsyncTryPrefixWhileSequence<Upstream>: AsyncSequence where Upstrea`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`public mutating func next() async throws -> Element? {`
`83`		`- guard let item = await try upstreamIterator?.next() else {`
	`83`	`+ guard let item = try await upstreamIterator?.next() else {`
`84`	`84`	`return nil`
`85`	`85`	`}`
`86`		`- guard await try predicate(item) else {`
	`86`	`+ guard try await predicate(item) else {`
`87`	`87`	`upstreamIterator?.cancel()`
`88`	`88`	`upstreamIterator = nil`
`89`	`89`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ extension AsyncSequence {`
`16`	`16`	`public func count() async rethrows -> Int {`
`17`	`17`	`var count = 0`
`18`	`18`	`var it = makeAsyncIterator()`
`19`		`- while await try it.next() != nil {`
	`19`	`+ while try await it.next() != nil {`
`20`	`20`	`count += 1`
`21`	`21`	`}`
`22`	`22`	`return count`
Original file line number	Diff line number	Diff line change
`@@ -15,29 +15,29 @@ import Swift`
`15`	`15`	`extension AsyncSequence {`
`16`	`16`	`public func min(by areInIncreasingOrder: (Element, Element) async throws -> Bool) async rethrows -> Element? {`
`17`	`17`	`var it = makeAsyncIterator()`
`18`		`- guard var result = await try it.next() else { return nil }`
`19`		`- while let e = await try it.next() {`
`20`		`- if await try areInIncreasingOrder(e, result) { result = e }`
	`18`	`+ guard var result = try await it.next() else { return nil }`
	`19`	`+ while let e = try await it.next() {`
	`20`	`+ if try await areInIncreasingOrder(e, result) { result = e }`
`21`	`21`	`}`
`22`	`22`	`return result`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public func max(by areInIncreasingOrder: (Element, Element) async throws -> Bool) async rethrows -> Element? {`
`26`	`26`	`var it = makeAsyncIterator()`
`27`		`- guard var result = await try it.next() else { return nil }`
`28`		`- while let e = await try it.next() {`
`29`		`- if await try areInIncreasingOrder(result, e) { result = e }`
	`27`	`+ guard var result = try await it.next() else { return nil }`
	`28`	`+ while let e = try await it.next() {`
	`29`	`+ if try await areInIncreasingOrder(result, e) { result = e }`
`30`	`30`	`}`
`31`	`31`	`return result`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`extension AsyncSequence where Element: Comparable {`
`36`	`36`	`public func min() async rethrows -> Element? {`
`37`		`- return await try min(by: <)`
	`37`	`+ return try await min(by: <)`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`public func max() async rethrows -> Element? {`
`41`		`- return await try max(by: <)`
	`41`	`+ return try await max(by: <)`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,17 +16,17 @@ extension AsyncSequence {`
`16`	`16`	`public func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (_ partialResult: Result, Element) async throws -> Result) async rethrows -> Result {`
`17`	`17`	`var accumulator = initialResult`
`18`	`18`	`var it = makeAsyncIterator()`
`19`		`- while let element = await try it.next() {`
`20`		`- accumulator = await try nextPartialResult(accumulator, element)`
	`19`	`+ while let element = try await it.next() {`
	`20`	`+ accumulator = try await nextPartialResult(accumulator, element)`
`21`	`21`	`}`
`22`	`22`	`return accumulator`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public func reduce<Result>(into initialResult: __owned Result, _ updateAccumulatingResult: (_ partialResult: inout Result, Element) async throws -> Void) async rethrows -> Result {`
`26`	`26`	`var accumulator = initialResult`
`27`	`27`	`var it = makeAsyncIterator()`
`28`		`- while let element = await try it.next() {`
`29`		`- await try updateAccumulatingResult(&accumulator, element)`
	`28`	`+ while let element = try await it.next() {`
	`29`	`+ try await updateAccumulatingResult(&accumulator, element)`
`30`	`30`	`}`
`31`	`31`	`return accumulator`
`32`	`32`	`}`