Sequence

Overview 概要

A sequence is a list of values that you can step through one at a time. The most common way to iterate over the elements of a sequence is to use a for-in loop: シーケンスは値のリストで、あなたが一度に１つずつ段階処理していくことができるものです。シーケンスの要素のすべてにわたって反復するための最も一般的な方法は、for-inループを使うことです：

let oneTwoThree = 1...3
for number in oneTwoThree {
    print(number)
}
// Prints "1"
// Prints "2"
// Prints "3"

While seemingly simple, this capability gives you access to a large number of operations that you can perform on any sequence. As an example, to check whether a sequence includes a particular value, you can test each value sequentially until you’ve found a match or reached the end of the sequence. This example checks to see whether a particular insect is in an array. 外見上は単純である一方、この能力はあなたにたくさんの演算へのアクセスを与え、それはあなたがあらゆるシーケンス上で実行可能です。１つの例として、あるシーケンスが特定の値を含むかどうか確認するために、あなたは各値を順次テストすることが、あなたが一致するものを見つけるかそのシーケンスの終わりに達するまで行えます。この例は、ある特定の昆虫が配列の中にあるかどうか見るために調べます。

let bugs = ["Aphid", "Bumblebee", "Cicada", "Damselfly", "Earwig"]
var hasMosquito = false
for bug in bugs {
    if bug == "Mosquito" {
        hasMosquito = true
        break
    }
}
print("'bugs' has a mosquito: \(hasMosquito)")
// Prints "'bugs' has a mosquito: false"

The Sequence protocol provides default implementations for many common operations that depend on sequential access to a sequence’s values. For clearer, more concise code, the example above could use the array’s contains(_:) method, which every sequence inherits from Sequence, instead of iterating manually: Sequenceプロトコルは、シーケンスのもつ値への順次的なアクセスを頼りにするような多くの一般的な演算に対して省略時の実装を提供します。より明確な、もっと簡潔なコードのために、上のコードは、すべてのシーケンスがSequenceから継承する、配列のもつcontains(_:)メソッドを使うことが、労力を要する反復の代わりに可能です：

if bugs.contains("Mosquito") {
    print("Break out the bug spray.")
} else {
    print("Whew, no mosquitos!")
}
// Prints "Whew, no mosquitos!"

Repeated Access 繰り返してアクセスする

The Sequence protocol makes no requirement on conforming types regarding whether they will be destructively consumed by iteration. As a consequence, don’t assume that multiple for-in loops on a sequence will either resume iteration or restart from the beginning: Sequenceプロトコルは、準拠する型に関して、それらが反復によって破壊的に消費されることになるかについて要件を設けません。結果として、あるシーケンス上での複数のfor-inループが反復を途中から再開するかまたは初めから再度着手するか、どちらかを決めてかからないでください：

for element in sequence {
    if ... some condition { break }
}


for element in sequence {
    // No defined behavior
}

In this case, you cannot assume either that a sequence will be consumable and will resume iteration, or that a sequence is a collection and will restart iteration from the first element. A conforming sequence that is not a collection is allowed to produce an arbitrary sequence of elements in the second for-in loop. この場合、あるシーケンスが消耗可能になっているそして反復を再開することになるか、またはあるシーケンスがコレクションであるそして最初の要素から反復を再度着手することになるか、あなたはどちらか決めてかかることはできません。準拠しているシーケンスでコレクションではないものは、２番目のfor-inループにおいて幾つかの要素からなる随意のシーケンスを生み出すことを許可されます。

To establish that a type you’ve created supports nondestructive iteration, add conformance to the Collection protocol. あなたが作成した型が非破壊反復をサポートすることを確立するには、Collectionプロトコルに対する準拠を加えてください。

Conforming to the Sequence Protocol Sequenceプロトコルに準拠する

Making your own custom types conform to Sequence enables many useful operations, like for-in looping and the contains method, without much effort. To add Sequence conformance to your own custom type, add a makeIterator() method that returns an iterator. あなたのあつらえの型をSequenceに準拠させることは、多くの有用な演算能力を与えます、for-inループおよびcontainsメソッドのように、あまり苦労せずに。Sequence準拠をあなた独自のあつらえの型に加えるには、あるイテレータを返すmakeIterator()メソッドを加えてください。

Alternatively, if your type can act as its own iterator, implementing the requirements of the IteratorProtocol protocol and declaring conformance to both Sequence and IteratorProtocol are sufficient. あるいはまた、あなたの型がそれ自身イテレータとして振る舞うならば、IteratorProtocolプロトコルの要件を実装することとSequenceおよびIteratorProtocolの両方に対する準拠を宣言することで十分です。

Here’s a definition of a Countdown sequence that serves as its own iterator. The makeIterator() method is provided as a default implementation. ここにCountdownシーケンスの定義があります、それはそれ自身イテレータとしての務めを果たします。makeIterator()メソッドは、省略時の実装として提供されます。

struct Countdown: Sequence, IteratorProtocol {
    var count: Int


    mutating func next() -> Int? {
        if count == 0 {
            return nil
        } else {
            defer { count -= 1 }
            return count
        }
    }
}


let threeToGo = Countdown(count: 3)
for i in threeToGo {
    print(i)
}
// Prints "3"
// Prints "2"
// Prints "1"

Expected Performance 期待される性能

A sequence should provide its iterator in O(1). The Sequence protocol makes no other requirements about element access, so routines that traverse a sequence should be considered O(n) unless documented otherwise. シーケンスはそれのイテレータをO(1)で提供すべきです。Sequenceプロトコルは要素アクセスについて他の要件を設けません、それでシーケンスを辿っていくおきまりの仕事はO(n)と考えるべきです、そうでないと文書化されるのでない限り。