Patterns

パターン

下記URLから引用し、日本語訳をつけてみました

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/patterns

Match and destructure values.

値を照合して構造化します。

A pattern represents the structure of a single value or a composite value. For example, the structure of a tuple (1, 2) is a comma-separated list of two elements. Because patterns represent the structure of a value rather than any one particular value, you can match them with a variety of values. For instance, the pattern (x, y) matches the tuple (1, 2) and any other two-element tuple. In addition to matching a pattern with a value, you can extract part or all of a composite value and bind each part to a constant or variable name.

パターンは、単一の値または複合値の構造を表します。 たとえば、タプル (1, 2) の構造は、2 つの要素のカンマ区切りリストです。 パターンは特定の 1 つの値ではなく値の構造を表すため、パターンをさまざまな値と照合できます。 たとえば、パターン (x, y) はタプル (1, 2) およびその他の 2 要素タプルと一致します。 パターンと値を照合するだけでなく、複合値の一部またはすべてを抽出し、各部分を定数または変数名にバインドすることもできます。

In Swift, there are two basic kinds of patterns: those that successfully match any kind of value, and those that may fail to match a specified value at runtime.

Swift には、基本的に 2 種類のパターンがあります。1 つはあらゆる種類の値に一致するパターン、もう 1 つは実行時に指定された値に一致しない可能性があるパターンです。

The first kind of pattern is used for destructuring values in simple variable, constant, and optional bindings. These include wildcard patterns, identifier patterns, and any value binding or tuple patterns containing them. You can specify a type annotation for these patterns to constrain them to match only values of a certain type.

最初の種類のパターンは、単純な変数、定数、およびオプションのバインディングの値を構造化するために使用されます。 これらには、ワイルドカード パターン、識別子パターン、およびそれらを含む値バインディングまたはタプル パターンが含まれます。 これらのパターンに型アノテーションを指定して、特定の型の値のみに一致するように制約できます。

The second kind of pattern is used for full pattern matching, where the values you’re trying to match against may not be there at runtime. These include enumeration case patterns, optional patterns, expression patterns, and type-casting patterns. You use these patterns in a case label of a switch statement, a catch clause of a do statement, or in the case condition of an if, while, guard, or for–in statement.

2 番目の種類のパターンは、完全なパターン マッチングに使用されます。この場合、照合しようとしている値は実行時には存在しない可能性があります。 これらには、列挙型パターン、オプション パターン、式パターン、および型キャスト パターンが含まれます。 これらのパターンは、switch ステートメントの case ラベル、do ステートメントの catch 節、または if、while、guard、または for-in ステートメントの case 条件で使用します。

Wildcard Pattern

ワイルドカードパターン

A wildcard pattern matches and ignores any value and consists of an underscore (_). Use a wildcard pattern when you don’t care about the values being matched against. For example, the following code iterates through the closed range 1...3, ignoring the current value of the range on each iteration of the loop:

ワイルドカード パターンは、アンダースコア（_）で構成され、任意の値と一致し、無視されます。 照合される値を気にしない場合は、ワイルドカード パターンを使用します。 たとえば、次のコードは、ループの各反復で範囲の現在の値を無視して、閉じた範囲 1...3 を反復処理します。

for _ in 1...3 {
    // Do something three times.
}

Identifier Pattern

識別子パターン

An identifier pattern matches any value and binds the matched value to a variable or constant name. For example, in the following constant declaration, someValue is an identifier pattern that matches the value 42 of type Int:

識別子パターンは任意の値と一致し、一致した値を変数または定数名にバインドします。 たとえば、次の定数宣言では、someValue は、Int 型の値 42 に一致する識別子パターンです。

let someValue = 42

When the match succeeds, the value 42 is bound (assigned) to the constant name someValue.

一致が成功すると、値 42 が定数名 someValue にバインド（割り当て）されます。

When the pattern on the left-hand side of a variable or constant declaration is an identifier pattern, the identifier pattern is implicitly a subpattern of a value-binding pattern.

変数または定数宣言の左側のパターンが識別子パターンである場合、その識別子パターンは暗黙的に値バインディング パターンのサブパターンになります。

Value-Binding Pattern

値バインディングパターン

A value-binding pattern binds matched values to variable or constant names. Value-binding patterns that bind a matched value to the name of a constant begin with the let keyword; those that bind to the name of variable begin with the var keyword.

値バインディング パターンは、一致した値を変数名または定数名にバインドします。 一致した値を定数の名前にバインドする値バインディング パターンは、let キーワードで始まります。 変数名にバインドされるものは、var キーワードで始まります。

Identifiers patterns within a value-binding pattern bind new named variables or constants to their matching values. For example, you can decompose the elements of a tuple and bind the value of each element to a corresponding identifier pattern.

値バインディング パターン内の識別子パターンは、新しい名前付き変数または定数を、一致する値にバインドします。 たとえば、タプルの要素を分解し、各要素の値を対応する識別子パターンにバインドできます。

let point = (3, 2)
switch point {
// Bind x and y to the elements of point.
case let (x, y):
    print("The point is at (\(x), \(y)).")
}
// Prints "The point is at (3, 2)."

In the example above, let distributes to each identifier pattern in the tuple pattern (x, y). Because of this behavior, the switch cases case let (x, y): and case (let x, let y): match the same values.

上の例では、タプル パターン (x, y) 内の各識別子パターンに分散させます。 この動作により、switch の case case let (x, y): と case (let x, let y): は同じ値に一致します。

Tuple Pattern

タプルパターン

A tuple pattern is a comma-separated list of zero or more patterns, enclosed in parentheses. Tuple patterns match values of corresponding tuple types.

タプル パターンは、括弧で囲まれた 0 個以上のパターンのカンマ区切りのリストです。 タプル パターンは、対応するタプル タイプの値と一致します。

You can constrain a tuple pattern to match certain kinds of tuple types by using type annotations. For example, the tuple pattern (x, y): (Int, Int) in the constant declaration let (x, y): (Int, Int) = (1, 2) matches only tuple types in which both elements are of type Int.

型アノテーションを使用すると、タプル パターンが特定の種類のタプル型に一致するように制約できます。 たとえば、定数宣言let (x, y): (Int, Int) = (1, 2) のタプル パターン (x, y): (Int, Int)は、両方の要素がInt型であるタプル タイプのみと一致します。

When a tuple pattern is used as the pattern in a for–in statement or in a variable or constant declaration, it can contain only wildcard patterns, identifier patterns, optional patterns, or other tuple patterns that contain those. For example, the following code isn’t valid because the element 0 in the tuple pattern (x, 0) is an expression pattern:

タプル パターンが for-in ステートメント、または変数や定数の宣言のパターンとして使用される場合、タプル パターンには、ワイルドカード パターン、識別子パターン、オプション パターン、またはそれらを含む他のタプル パターンのみを含めることができます。 たとえば、タプル パターン (x, 0) の要素 0 は式パターンであるため、次のコードは無効です。

let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
// This code isn't valid.
for (x, 0) in points {
    /* ... */
}

The parentheses around a tuple pattern that contains a single element have no effect. The pattern matches values of that single element’s type. For example, the following are equivalent:

単一の要素を含むタプル パターンを囲む括弧は効果がありません。 パターンは、その単一要素の型の値と一致します。 たとえば、次は同等です。

let a = 2        // a: Int = 2
let (a) = 2      // a: Int = 2
let (a): Int = 2 // a: Int = 2

Enumeration Case Pattern

列挙型ケースのパターン

An enumeration case pattern matches a case of an existing enumeration type. Enumeration case patterns appear in switch statement case labels and in the case conditions of if, while, guard, and for–in statements.

列挙型のケース パターンは、既存の列挙型のケースと一致します。 列挙型のケース パターンは、switch ステートメントのケース ラベルと、if、while、guard、for-in ステートメントの case 条件に表示されます。

If the enumeration case you’re trying to match has any associated values, the corresponding enumeration case pattern must specify a tuple pattern that contains one element for each associated value. For an example that uses a switch statement to match enumeration cases containing associated values, see Associated Values.

照合しようとしている列挙型ケースに関連する値がある場合、対応する列挙型ケース パターンでは、関連する値ごとに 1 つの要素を含むタプル パターンを指定する必要があります。 switch ステートメントを使用して、関連する値を含む列挙ケースを照合する例については、「関連する値」を参照してください。

An enumeration case pattern also matches values of that case wrapped in an optional. This simplified syntax lets you omit an optional pattern. Note that, because Optional is implemented as an enumeration, .none and .some can appear in the same switch as the cases of the enumeration type.

列挙型ケース パターンは、オプションでラップされたケースの値とも一致します。 この簡略化された構文を使用すると、オプションのパターンを省略できます。 Optional は列挙型として実装されているため、.none と .some は列挙型の場合と同じスイッチに出現する可能性があることに注意してください。

enum SomeEnum { case left, right }
let x: SomeEnum? = .left
switch x {
case .left:
    print("Turn left")
case .right:
    print("Turn right")
case nil:
    print("Keep going straight")
}
// Prints "Turn left"

Optional Pattern

オプションのパターン

An optional pattern matches values wrapped in a some(Wrapped) case of an Optional<Wrapped> enumeration. Optional patterns consist of an identifier pattern followed immediately by a question mark and appear in the same places as enumeration case patterns.

オプションのパターンは、 Optional<Wrapped> の some(Wrapped) ケースでラップされた値と一致します。 オプションのパターンは、疑問符の直後に続く識別子パターンで構成され、列挙型ケース パターンと同じ場所に表示されます。

Because optional patterns are syntactic sugar for Optional enumeration case patterns, the following are equivalent:

オプションのパターンは、Optional列挙ケース パターンの糖衣構文であるため、以下は同等です。

let someOptional: Int? = 42
// Match using an enumeration case pattern.
if case .some(let x) = someOptional {
    print(x)
}


// Match using an optional pattern.
if case let x? = someOptional {
    print(x)
}

The optional pattern provides a convenient way to iterate over an array of optional values in a for–in statement, executing the body of the loop only for non-nil elements.

オプションのパターンは、for-in ステートメント内のオプションの値の配列を反復処理し、非 nil 要素に対してのみループの本体を実行する便利な方法を提供します。

let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
// Match only non-nil values.
for case let number? in arrayOfOptionalInts {
    print("Found a \(number)")
}
// Found a 2
// Found a 3
// Found a 5

Type-Casting Patterns

型キャストパターン

There are two type-casting patterns, the is pattern and the as pattern. The is pattern appears only in switch statement case labels. The is and as patterns have the following form:

型キャスト パターンには、is パターンと as パターンの 2 つがあります。 is パターンは switch ステートメントの case ラベルにのみ表示されます。 is および as パターンは次の形式になります。

is <#type#>
<#pattern#> as <#type#>

The is pattern matches a value if the type of that value at runtime is the same as the type specified in the right-hand side of the is pattern — or a subclass of that type. The is pattern behaves like the is operator in that they both perform a type cast but discard the returned type.

実行時の値の型が、is パターンの右側で指定された型、またはその型のサブクラスと同じである場合、is パターンは値と一致します。 is パターンは、どちらも型キャストを実行しますが、返された型を破棄するという点で is 演算子と同様に動作します。

The as pattern matches a value if the type of that value at runtime is the same as the type specified in the right-hand side of the as pattern — or a subclass of that type. If the match succeeds, the type of the matched value is cast to the pattern specified in the right-hand side of the as pattern.

as パターンは、実行時の値の型が as パターンの右側で指定された型、またはその型のサブクラスと同じである場合に値と一致します。 一致が成功した場合、一致した値の型は as パターンの右側で指定されたパターンにキャストされます。

For an example that uses a switch statement to match values with is and as patterns, see Type Casting for Any and AnyObject.

switch ステートメントを使用して値を is および as パターンと照合する例については、「Any および AnyObject の型キャスト」を参照してください。

Expression Pattern

式パターン

An expression pattern represents the value of an expression. Expression patterns appear only in switch statement case labels.

式パターンは式の値を表します。 式パターンは switch ステートメントの case ラベルにのみ表示されます。

The expression represented by the expression pattern is compared with the value of an input expression using the Swift standard library ~= operator. The matches succeeds if the ~= operator returns true. By default, the ~= operator compares two values of the same type using the == operator. It can also match a value with a range of values, by checking whether the value is contained within the range, as the following example shows.

式パターンで表される式は、Swift 標準ライブラリ ~= 演算子を使用して入力式の値と比較されます。 ~= 演算子が true を返す場合、一致は成功します。 デフォルトでは、~= 演算子は、== 演算子を使用して同じ型の 2 つの値を比較します。 次の例に示すように、値が範囲内に含まれているかどうかを確認することで、値を値の範囲と照合することもできます。

let point = (1, 2)
switch point {
case (0, 0):
    print("(0, 0) is at the origin.")
case (-2...2, -2...2):
    print("(\(point.0), \(point.1)) is near the origin.")
default:
    print("The point is at (\(point.0), \(point.1)).")
}
// Prints "(1, 2) is near the origin."

You can overload the ~= operator to provide custom expression matching behavior. For example, you can rewrite the above example to compare the point expression with a string representations of points.

~= 演算子をオーバーロードして、カスタム式一致動作を提供できます。 たとえば、上記の例を書き換えて、ポイント式をポイントの文字列表現と比較できます。

// Overload the ~= operator to match a string with an integer.
func ~= (pattern: String, value: Int) -> Bool {
    return pattern == "\(value)"
}
switch point {
case ("0", "0"):
    print("(0, 0) is at the origin.")
default:
    print("The point is at (\(point.0), \(point.1)).")
}
// Prints "The point is at (1, 2)."