Generic Parameters and Arguments

一般的なパラメータと引数

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

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

Generalize declarations to abstract away concrete types.

宣言を一般化して具体的な型を抽象化します。

This chapter describes parameters and arguments for generic types, functions, and initializers. When you declare a generic type, function, subscript, or initializer, you specify the type parameters that the generic type, function, or initializer can work with. These type parameters act as placeholders that are replaced by actual concrete type arguments when an instance of a generic type is created or a generic function or initializer is called.

この章では、ジェネリック型、関数、イニシャライザのパラメータと引数について説明します。 ジェネリック型、関数、添字、または初期化子を宣言するときは、ジェネリック型、関数、または初期化子が操作できる型パラメーターを指定します。 これらの型パラメーターは、ジェネリック型のインスタンスが作成されるとき、またはジェネリック関数または初期化子が呼び出されるときに、実際の具象型引数に置き換えられるプレースホルダーとして機能します。

For an overview of generics in Swift, see Generics.

Swift のジェネリックの概要については、「汎用」を参照してください。

Generic Parameter Clause

汎用パラメータ句

A generic parameter clause specifies the type parameters of a generic type or function, along with any associated constraints and requirements on those parameters. A generic parameter clause is enclosed in angle brackets (<>) and has the following form:

ジェネリック パラメーター句は、ジェネリック型または関数の型パラメーターと、それらのパラメーターに関する関連する制約および要件を指定します。 ジェネリック パラメータ句は山括弧 (<>) で囲まれ、次の形式になります。

<<#generic parameter list#>>

The generic parameter list is a comma-separated list of generic parameters, each of which has the following form:

汎用パラメータ リストは、汎用パラメータのカンマ区切りのリストで、それぞれの形式は次のとおりです。

<#type parameter#>: <#constraint#>

A generic parameter consists of a type parameter followed by an optional constraint. A type parameter is simply the name of a placeholder type (for example, T, U, V, Key, Value, and so on). You have access to the type parameters (and any of their associated types) in the rest of the type, function, or initializer declaration, including in the signature of the function or initializer.

汎用パラメータは、型パラメータとそれに続くオプションの制約で構成されます。 型 パラメータは、単なるプレースホルダ 型の名前です（たとえば、T、U、V、Key、Value など）。 関数またはイニシャライザのシグネチャを含む、型、関数、またはイニシャライザ宣言の残りの部分で、型パラメータ (およびそれらに関連する型) にアクセスできます。

func simpleMax<T: Comparable>(_ x: T, _ y: T) -> T {
    if x < y {
        return y
    }
    return x
}

The constraint specifies that a type parameter inherits from a specific class or conforms to a protocol or protocol composition. For example, in the generic function below, the generic parameter T: Comparable indicates that any type argument substituted for the type parameter T must conform to the Comparable protocol.

制約は、型パラメータが特定のクラスから継承するか、プロトコルまたはプロトコル構成に準拠するかを指定します。 たとえば、以下の汎用関数では、汎用パラメータ T: Comparable は、型パラメータ T の代わりに使用される型引数が Comparable プロトコルに準拠する必要があることを示します。

Because Int and Double, for example, both conform to the Comparable protocol, this function accepts arguments of either type. In contrast with generic types, you don’t specify a generic argument clause when you use a generic function or initializer. The type arguments are instead inferred from the type of the arguments passed to the function or initializer.

たとえば、Int と Double は両方とも Comparable プロトコルに準拠しているため、この関数はどちらの方の引数も受け入れます。 ジェネリック型とは対照的に、ジェネリック関数またはイニシャライザを使用する場合は、ジェネリック引数句を指定しません。 代わりに、型引数は、関数またはイニシャライザに渡された引数の型から推測されます。

simpleMax(17, 42) // T is inferred to be Int
simpleMax(3.14159, 2.71828) // T is inferred to be Double

Generic Where Clauses

汎用 Where 句

You can specify additional requirements on type parameters and their associated types by including a generic where clause right before the opening curly brace of a type or function’s body. A generic where clause consists of the where keyword, followed by a comma-separated list of one or more requirements.

型または関数の本体の左中括弧の直前に汎用の where 句を含めることで、型パラメータとそれに関連する型に関する追加の要件を指定できます。 一般的な where 句は、where キーワードと、その後に続く 1 つ以上の要件のカンマ区切りのリストで構成されます。

where <#requirements#>

The requirements in a generic where clause specify that a type parameter inherits from a class or conforms to a protocol or protocol composition. Although the generic where clause provides syntactic sugar for expressing simple constraints on type parameters (for example, <T: Comparable> is equivalent to <T> where T: Comparable and so on), you can use it to provide more complex constraints on type parameters and their associated types. For example, you can constrain the associated types of type parameters to conform to protocols. For example, <S: Sequence> where S.Iterator.Element: Equatable specifies that S conforms to the Sequence protocol and that the associated type S.Iterator.Element conforms to the Equatable protocol. This constraint ensures that each element of the sequence is equatable.

一般的な where 句の要件では、型パラメータがクラスから継承するか、プロトコルまたはプロトコル構成に準拠するかを指定します。 一般的な where 句は、型パラメータに対する単純な制約を表現するための糖衣構文を提供しますが（たとえば、 <T: Comparable>は <T> where T: Comparable などと同等です）、これを使用して型に対してより複雑な制約を提供することもできます。 パラメータとそれに関連付けられたタイプ。 たとえば、型パラメータの関連付けられた型をプロトコルに準拠するように制約できます。 たとえば、<S: Sequence> where S.Iterator.Element: Equatable は、S が Sequence プロトコルに準拠し、関連付けられた型 S.Iterator.Element が Equatable プロトコルに準拠することを指定します。 この制約により、シーケンスの各要素が同等であることが保証されます。

You can also specify the requirement that two types be identical, using the == operator. For example, <S1: Sequence, S2: Sequence> where S1.Iterator.Element == S2.Iterator.Element expresses the constraints that S1 and S2 conform to the Sequence protocol and that the elements of both sequences must be of the same type.

== 演算子を使用して、2 つの型が同一であるという要件を指定することもできます。 たとえば、 <S1: Sequence, S2: Sequence> where S1.Iterator.Element == S2.Iterator.Element は、S1 と S2 が Sequence プロトコルに準拠し、両方のシーケンスの要素が同じ型でなければならないという制約を表します。 。

Any type argument substituted for a type parameter must meet all the constraints and requirements placed on the type parameter.

型パラメーターの代わりに使用される型引数は、型パラメーターに設定されたすべての制約と要件を満たしている必要があります。

A generic where clause can appear as part of a declaration that includes type parameters, or as part of a declaration that’s nested inside of a declaration that includes type parameters. The generic where clause for a nested declaration can still refer to the type parameters of the enclosing declaration; however, the requirements from that where clause apply only to the declaration where it’s written.

一般的な where 句は、型パラメータを含む宣言の一部として、または型パラメータを含む宣言内にネストされた宣言の一部として使用できます。 ネストされた宣言の一般的な where 句は、外側の宣言の型パラメータを参照できます。 ただし、where 句の要件は、where 句が記述されている宣言にのみ適用されます。

If the enclosing declaration also has a where clause, the requirements from both clauses are combined. In the example below, startsWithZero() is available only if Element conforms to both SomeProtocol and Numeric.

囲んでいる宣言にも where 句がある場合は、両方の句の要件が結合されます。 以下の例では、startsWithZero() は、Element が SomeProtocol と Numeric の両方に準拠している場合にのみ使用できます。

extension Collection where Element: SomeProtocol {
    func startsWithZero() -> Bool where Element: Numeric {
        return first == .zero
    }
}

You can overload a generic function or initializer by providing different constraints, requirements, or both on the type parameters. When you call an overloaded generic function or initializer, the compiler uses these constraints to resolve which overloaded function or initializer to invoke.

型パラメーターにさまざまな制約、要件、またはその両方を指定することで、ジェネリック関数またはイニシャライザーをオーバーロードできます。 オーバーロードされたジェネリック関数またはイニシャライザを呼び出すと、コンパイラはこれらの制約を使用して、どのオーバーロードされた関数またはイニシャライザを呼び出すかを解決します。

For more information about generic where clauses and to see an example of one in a generic function declaration, see Generic Where Clauses.

一般的な where 句の詳細と、一般的な関数宣言の例については、「汎用 Where 句」を参照してください。

Generic Argument Clause

汎用引数句

A generic argument clause specifies the type arguments of a generic type. A generic argument clause is enclosed in angle brackets (<>) and has the following form:

ジェネリック引数句は、ジェネリック型の型引数を指定します。 一般的な引数句は山かっこ (<>) で囲まれ、次の形式になります。

<<#generic argument list#>>

The generic argument list is a comma-separated list of type arguments. A type argument is the name of an actual concrete type that replaces a corresponding type parameter in the generic parameter clause of a generic type. The result is a specialized version of that generic type. The example below shows a simplified version of the Swift standard library’s generic dictionary type.

一般的な引数リストは、型引数のカンマ区切りのリストです。 型引数は、ジェネリック型のジェネリック パラメーター句内の対応する型パラメーターを置き換える実際の具象型の名前です。 その結果、そのジェネリック型の特殊なバージョンが作成されます。 以下の例は、Swift 標準ライブラリの汎用辞書タイプの簡略化されたバージョンを示しています。

struct Dictionary<Key: Hashable, Value>: Collection, ExpressibleByDictionaryLiteral {
    /* ... */
}

The specialized version of the generic Dictionary type, Dictionary<String, Int> is formed by replacing the generic parameters Key: Hashable and Value with the concrete type arguments String and Int. Each type argument must satisfy all the constraints of the generic parameter it replaces, including any additional requirements specified in a generic where clause. In the example above, the Key type parameter is constrained to conform to the Hashable protocol and therefore String must also conform to the Hashable protocol.

汎用 Dictionary 型の特殊バージョンである Dictionary<String, Int> は、汎用パラメータ Key: Hashable および Value を具体的な型引数 String および Int に置き換えることによって形成されます。 各型引数は、汎用の where 句で指定された追加要件を含め、置き換えられる汎用パラメータのすべての制約を満たす必要があります。 上の例では、Key タイプのパラメータは Hashable プロトコルに準拠するように制約されているため、String も Hashable プロトコルに準拠する必要があります。

You can also replace a type parameter with a type argument that’s itself a specialized version of a generic type (provided it satisfies the appropriate constraints and requirements). For example, you can replace the type parameter Element in Array<Element> with a specialized version of an array, Array<Int>, to form an array whose elements are themselves arrays of integers.

また、型パラメーターを、ジェネリック型の特殊バージョンである型引数に置き換えることもできます (適切な制約と要件を満たしている場合)。 たとえば、Array<Element> の型パラメータ Element を配列の特殊バージョン Array<Int> に置き換えて、要素自体が整数の配列である配列を形成できます。

let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

As mentioned in Generic Parameter Clause, you don’t use a generic argument clause to specify the type arguments of a generic function or initializer.

「汎用パラメーター句」で説明したように、ジェネリック関数またはイニシャライザの型引数を指定するためにジェネリック引数句を使用することはありません。