AsyncIteratorProtocol

Overview 概要

The AsyncIteratorProtocol defines the type returned by the makeAsyncIterator() method of the AsyncSequence protocol. In short, the iterator is what produces the asynchronous sequence’s values. The protocol defines a single asynchronous method, next(), which either produces the next element of the sequence, or returns nil to signal the end of the sequence. AsyncIteratorProtocolは、AsyncSequenceプロトコルのmakeAsyncIterator()メソッドによって返される型を定義します。要約すれば、そのイテレータは、非同期シーケンスのもつ値それらを取り出すものです。プロトコルは、ただ１つの非同期メソッドnext()を定義します、それはシーケンスの次の要素を取り出すか、またはnilを返してシーケンスの終わりを合図するかのどちらかです。

To implement your own AsyncSequence, implement a wrapped type that conforms to AsyncIteratorProtocol. The following example shows a Counter type that uses an inner iterator to monotonically generate Int values until reaching a howHigh value. While this example isn’t itself asychronous, it shows the shape of a custom sequence and iterator, and how to use it as if it were asynchronous: あなた独自のAsyncSequenceを実装するには、AsyncIteratorProtocolに準拠するあるラップ型を実装してください。以下の例は、あるCounter型を示します、それはある内部イテレータを使ってInt値を、howHigh値に到達するまで単調に生成します。この例はそれ自体は非同期でない一方で、それはあるあつらえのシーケンスとイテレータの輪郭、そしてまるでそれが非同期だったかのようにそれを使う方法を示します：

struct Counter : AsyncSequence {
    typealias Element = Int
    let howHigh: Int


    struct AsyncIterator : AsyncIteratorProtocol {
        let howHigh: Int
        var current = 1
        mutating func next() async -> Int?{
            // A genuinely asychronous implementation uses the `Task`（ 真に非同期の実装は `Task`）
            // API to check for cancellation here and return early.（ API を使用して取り消しをここで調べて、より早くに復帰します。）
            guard current <= howHigh else {
                return nil
            }


            let result = current
            current += 1
            return result
        }
    }


    func makeAsyncIterator() -> AsyncIterator {
        return AsyncIterator(howHigh: howHigh)
    }
}

At the call site, this looks like: 呼び出し場所で、これは次のように見えます：

for await i in Counter(howHigh: 10) {
  print(i, terminator: " ")
}
// Prints: 1 2 3 4 5 6 7 8 9 10

End of Iteration 反復の終わり

The iterator returns nil to indicate the end of the sequence. After returning nil (or throwing an error) from next(), the iterator enters a terminal state, and all future calls to next() must return nil. イテレータ（反復子）は、nilを返すことでシーケンスの終わりを指し示します。next()からnilを返す（またはエラーをスローする）後、イテレータはある終端状態に入ります、そしてnext()への全ての未来の呼び出しは、nilを返さなければなりません。

Cancellation 取り消し

Types conforming to AsyncIteratorProtocol should use the cancellation primitives provided by Swift’s Task API. The iterator can choose how to handle and respond to cancellation, including: AsyncIteratorProtocolに準拠する型は、SwiftのもつTask APIによって提供される取り消し原始関数を使うべきです。イテレータは、どのように取り消しを処理してそして応答するかを選択できます、それは次を含みます：

• Checking the isCancelled value of the current Task inside next() and returning nil to terminate the sequence. next()の内部の現在のTaskのisCancelled値を調べるそしてnilを返してシーケンスを終端する。

• Calling checkCancellation() on the Task, which throws a CancellationError. checkCancellation()をTask上で呼び出す、それはCancellationErrorをスローします。

• Implementing next() with a withTaskCancellationHandler(handler:operation:) invocation to immediately react to cancellation. next()をあるwithTaskCancellationHandler(handler:operation:)発動をつかって実装して、直接に取り消しに反応を示す。

If the iterator needs to clean up on cancellation, it can do so after checking for cancellation as described above, or in deinit if it’s a reference type. イテレータが取り消しに関して片付けを必要とするならば、それはそうすることが可能です、上で記述されるように取り消しを確認した後に、またはそれが参照型であるならばdeinitにおいて。