Swift 5.8 日本語化計画　: Swift 5.8

ジェネリック(汎用)

複数の型で機能するコードを記述し、それらの型の要件を指定します。

汎用(Generic)コード を使用すると、定義する要件の対象として全ての型を扱うことができ、柔軟で再利用可能な関数と型を書くことができます。重複を避け、明確な、抽象化の方法でその意図を表現するコードを書くことができます。

ジェネリック (汎用)は、Swift の最も強力な機能の一つであり、そして Swift の標準ライブラリの多くは汎用(ジェネリック)コードでビルドされています。実際に、それを意識していない場合でも、言語ガイド 全体を通して汎用を使用してきました。たとえば、Swift の Array と Dictionary 型は、両方とも汎用のコレクションです。Int 値を保持する配列、または String 値を保持する配列、または実際に他の全ての型用の配列を Swift では作成できます。同様に、指定した全ての型の値を格納するための dictionary を作成でき、その型が何であろうと制限はありません。

汎用が解決する問題

ここで２つの Int 値を入れ替える、swapTwoInts(_:_:) と言う標準の、汎用でない関数を挙げます。

func swapTwoInts(_ a: inout Int, _ b: inout Int) {

let temporaryA = a

a = b

b = temporaryA

}

この関数は、In-Out パラメータで説明したように、a と b の値を入れ替えるのに in-out パラメータを使用しています。

swapTwoInts(_:_:) 関数は、b の元の値を、a と入れ替え、a の元の値を b と入れ替えます。２つの Int 変数の値を交換するために、この関数を呼び出せます。

var someInt = 3

var anotherInt = 107

swapTwoInts(&someInt, &anotherInt)

print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")

// prints "someInt is now 107, and anotherInt is now 3"

swapTwoInts(_:_:) 関数は有用ですが、それは Int 値でしか使用できません。２つの String 値、または２つの Double 値を入れ替えたい場合は、以下に示す様に、swapTwoStrings(_:_:) と swapTwoDoubles(_:_:) 関数など多くの関数を書かなければなりません：

func swapTwoStrings(_ a: inout String, _ b: inout String) {

let temporaryA = a

a = b

b = temporaryA

}

func swapTwoDoubles(_ a: inout Double, _ b: inout Double) {

let temporaryA = a

a = b

b = temporaryA

}

swapTwoInts(_:_:)、swapTwoStrings(_:_:)、および swapTwoDoubles(_:_:) 関数の本体が同一であることに気づいたかもしれません。唯一の違いは、それらが受け入れる値 (Int、String、および Double) の型だけです。

全ての型の２つの値を入れ替える一つの関数を書けば、はるかに有用で、著しく柔軟になります。汎用コードを使用すると、そのような関数を書くことができます。(これらの関数の汎用バージョンは後で定義します。)

注意： これら３つのすべての関数で、a と b の型は同じでなければなりません。a と b が同じ型ではなかった場合には、それらの値を入れ替えることは不可能です。Swift は、型安全な言語であり、(例えば) String 型の変数と Double 型の変数を互いに値を入れ替えるのは許可されていません。これを実行しようとすると、コンパイル時エラーになります。

汎用関数

汎用関数 は、全ての型を扱うことができます。ここで上に挙げた swapTwoInts(_:_:) 関数の汎用バージョンで、swapTwoValues(_:_:) と言う例を挙げます：

func swapTwoValues<T>(_ a: inout T, _ b: inout T) {

let temporaryA = a

a = b

b = temporaryA

}

swapTwoValues(_:_:) 関数の本体は swapTwoInts(_:_:) 関数の本体と同一です。しかし、swapTwoValues(_:_:) の最初の行は swapTwoInts(_:_:) とは少し異なります。ここで最初の行を比較してみましょう。

func swapTwoInts(_ a: inout Int, _ b: inout Int)

func swapTwoValues<T>(_ a: inout T, _ b: inout T)

関数の汎用 (ジェネリック) バージョンは、(この場合は、T と言う) プレースホルダ 型の名を、実際の 型の名 (Int、String、または Double など) の代わりに使用しています。プレースホルダ型の名は、T が何でなければならないとは言っていませんが、a と b の両方が、 T が表すのが何であれ、同じ型 T でなければならないと告げています。T の代わりに使われる実際の型は swapTwoValues(_:_:) 関数が呼び出されるたびに決定されます。

汎用関数と汎用でない関数の間の他の違いは、汎用関数の名前 (swapTwoValues(_:_:)) に山括弧 (<T>) 内にプレースホルダ型の名 (T) が続いているということです。括弧は T が swapTwoValues(_:_:) 関数定義内のプレースホルダ型の名だと Swift に教えています。T はプレースホルダであるため、Swift は T と言う実際の型は検索しません。

これらの値の両者が互いに同じ型のものである限り、全ての型の２つの値を渡すことができることを除いて、swapTwoValues(_:_:) 関数は、swapTwoInts と同じ方法で呼び出すことができます。swapTwoValues(_:_:) が呼び出されるたびに、T に使用する型は、関数に渡された値の型から推測されます。

以下の２つの例では、T は、それぞれ Int と String であることが推測されます。

var someInt = 3

var anotherInt = 107

swapTwoValues(&someInt, &anotherInt)

// someInt is now 107, and anotherInt is now 3

var someString = "hello"

var anotherString = "world"

swapTwoValues(&someString, &anotherString)

// someString is now "world", and anotherString is now "hello"

注意： 上記で定義された swapTwoValues(_:_:) 関数は、Swift の標準ライブラリの一部であり、そしてあなたのアプリで自動的に利用可能となる swap と言う汎用関数に触発されています。独自のコードで swapTwoValues(_:_:) 関数の動作が必要な場合は、独自の実装を提供するよりも、Swift の既存の swap(_:_:) 関数を使用できます。

型パラメータ

上記の swapTwoValues(_:_:) の例では、プレースホルダの型 T は、型パラメータ の例です。型パラメータは、プレースホルダ型を指定し、名前を付け、一致する山括弧の対の間に、関数名の直後に書かれています(<T> のように)。

型パラメータを指定するやいなや、関数のパラメータの型を定義するためにそれを使用でき(例えば swapTwoValues(_:_:) 関数の a と b のパラメータのように)、また関数の戻り値の型として、また関数の本体内の型注釈として使用できます。それぞれの場合、型パラメータは関数が呼び出されるたびに 実際の 型に置き換えられます。(上記の swapTwoValues(_:_:) の例では、T は、関数が呼び出された最初の時は Int 型で置き換えられ、呼び出された二度目には String に置き換えられます。)

カンマで区切り、山括弧内で複数の型パラメータ名を書くことによって、１つ以上の型パラメータを提供できます。

型パラメータの命名

ほとんどの場合、型パラメータおよび汎用型またはそれが中で使用されている関数との関係について、読者に伝える Dictionary<key, Value> での Key と Value や Array<Element> での Element などの説明的な名前を型パラメータは持っています。しかし、それらの間の意味のある関係がない場合、それは上記の swapTwoValues(_:_:) 関数内の T のような、 T、U、V のような単一の文字を使用して、それらに名前を付けるのが、従来のやり方です。

注意： 常にそれらが型のプレースホルダであり、値のものではないことを示すために、(例えば、T や MyTypeParameter のように) upper camel case の名前を型パラメータに与えて下さい。

汎用の型

汎用の関数に加えて、Swift では、自分で独自の 汎用の型 を定義できます。これらは、Array や Dictionary と同様に、全ての型を扱うことができる、カスタムクラス、構造体、および列挙型です。

このセクションでは、Stack と言う汎用のコレクション型を書く方法を説明します。スタックは配列に似た、値の順序付き集合ですが、Swift の Array 型より操作の制限が厳密に設定されています。配列には新しい項目が挿入でき、配列内の任意の場所から除去できます。スタックは、しかし、新しい項目はコレクションの最後にのみ追加することができ (スタック上に新たな値を プッシュする として知られてい) ます。同様に、スタックは、項目をコレクションの末尾からのみ削除する (スタックから値を ポップする として知られています)ことができます。

注意： スタックの概念は、そのナビゲーション階層における View Controller をモデル化する UINavigationController クラスによって使用されています。UINavigationController クラスの pushViewController(_:animated:) メソッドを呼び出してナビゲーションスタック上にビューコントローラを追加 (またはプッシュ) するのに使い、その popViewControllerAnimated(_:) メソッドを呼び出してナビゲーションスタックからビューコントローラを削除 (またはポップ) します。コレクションを管理するためのアプローチとして厳しい "ラストイン、ファーストアウト" が必要なときにはいつでも、スタックは便利なコレクションモデルです。

下のイラストは、スタックのプッシュ/ポップ動作を示しています。

スタック上には現在３つの値があります。
４番目の値が、スタックの最上部へ "プッシュ" されます。
スタックは最上部に最新のものを乗せ、現在４つの値を保持します。
スタック内の最上部の項目が "ポップ" されます。
値をポップした後、スタックは再び３つの値を保持します。

ここで Int 値のスタック用に、スタックの汎用でないバージョンを書く方法は以下のとおりです。

struct IntStack {

var items : [Int] =[]

mutating func push(_ item: Int) {

items.append(item)

}

mutating func pop() -> Int {

return items.removeLast()

}

この構造体は、スタック内に値を格納する items と言う Array プロパティを使用しています。Stack はスタックの上に値をプッシュする push と、スタックから値をポップする pop の２つのメソッドを提供します。これらのメソッドは構造体の items 配列を変更(または変異)する必要があるため、mutating としてマークされています。

しかし、上に示した IntStack 型は、Int 型の値でしか使用できません。値の 全ての 型のスタックを管理することができる 汎用の Stack 構造体を定義することは、はるかに有用でしょう。

ここで、同じコードの汎用バージョンを挙げます：

struct Stack<Element> {

var items : [Element] = []

mutating func push(_ item: Element) {

items.append(item)

}

mutating func pop() -> Element {

return items.removeLast()

}

Stack の汎用バージョンは本質的に汎用でないバージョンと同じであることに注目しましょう、しかし、Int の実際の型の代わりに、Element と言う型パラメータがあります。この型パラメータは、構造体の名前の直後に山括弧 (<Element>) のペアの中に書かれています。

Element は、後で提供される型のプレースホルダ名を定義しています。この将来の型は構造体の定義内のどこでも Element で参照できます。この場合は、Element は３つの場所でプレースホルダとして使用されています。

型 Element の値の空の配列で初期化されている、items と言うプロパティを作成する
push(_:) メソッドが、型 Element でなければならない item と言う一つのパラメータがあることを指定する
pop() メソッドによって返される値が型 Element の値になるように指定する

それは汎用型であるため、Stack は、Array や Dictionary と同様な方法で、Swift で有効な全ての型のスタックを作成するのに使用できます。

山括弧の中のスタックに格納する型を書くことによって、新しい Stack インスタンスを作成して下さい。たとえば、文字列の新しいスタックを作成するには、Stack<String>() と書いて下さい。

var stackOfStrings = Stack<String>()

stackOfStrings.push("uno")

stackOfStrings.push("dos")

stackOfStrings.push("tres")

stackOfStrings.push("cuatro")

// the stack now contains 4 strings

ここで stackOfStrings がスタック上にこれらの４つの値をプッシュした後どのように見えるかを示します：

スタックから値をポップし、一番上の値、"cuatro" を削除し、戻ります。

let fromTheTop = stackOfStrings.pop()

// fromTheTop is equal to "cuatro", and the stack now contains 3 strings

ここで、スタックがその一番上の値をポップした後にどのように見えるかを示します：

汎用型の拡張

汎用型を拡張するときは、拡張機能の定義の一部として型パラメータリストを提供しないで下さい。代わりに、元の型の定義から型パラメータリストが拡張機能の本体内で利用可能であり、元の型パラメータの名前は、元の定義から型パラメータを参照するために使用されます。

以下の例では、スタックからポップすることなく、スタック上の一番上の項目を返す、topItem と言う読み取り専用の計算されたプロパティを追加するために、汎用の Stack 型を拡張します。

extension Stack {

var topItem: Element? {

return items.isEmpty ? nil : items[items.count - 1]

}

topItem プロパティは Element 型の optional の値を返します。スタックが空の場合、topItem は nil を返します。スタックが空でない場合、topItem は items 配列内の最後の項目を返します。

この拡張機能は型パラメータリストを定義していないことに注意してください。代わりに、Stack 型の既存の型パラメータ名、Element が、topItem の計算されたプロパティの optional の型を示すために拡張機能内で使用されています。

topItem の計算されたプロパティは、どの Stack インスタンスでも使用できるようになり、それを削除する事なく、その先頭の項目にアクセスし、照会できるようになります。

if let topItem = stackOfStrings.topItem {

print("The top item on the stack is \(topItem).")

}

// prints "The top item on the stack is tres."

以下の汎用の Where 句を含む拡張機能で説明するように、汎用型の拡張機能には、新しい機能を取得するために拡張型のインスタンスが満たさなければならない要件も含まれます。

型制約

swapTwoValues(_:_:) 関数と Stack 型は全ての型を扱うことができます。しかし、汎用関数と汎用型で使用できる型に特定の 型制約 を強制すると便利な場合があります。型制約は、型パラメータが特定のクラスから継承しなければならず、特定のプロトコルまたはプロトコル構成に準拠することを指定します。

たとえば、Swift の Dictionary 型には辞書のキーとして使用できる型の制限があります。Dictionary で説明したように、辞書のキーの型は ハッシュ可能 (hashable) でなければなりません。つまり、それ自体を独自に表現可能にする方法を提供しなければなりません。Dictionary は、それが既に特定のキーの値を含んでいるかどうか確認できるようにそのキーがハッシュ可能である事を必要としています。この要件がなければ、Dictionary は、特定のキーの値を挿入または置き換える必要があるかどうかを見分けることができませんし、また辞書に既にある与えられたキーの値を見つけることもできないでしょう。

この要件は、Dictionary のキー型の、型制約により強制され、Swift 標準ライブラリで定義された特別なプロトコルの Hashable プロトコルに、そのキー型が準拠しなければならない事を指定します。(String、Int、Double、および bool のような) Swift の基本的なすべての型は、デフォルトでハッシュ可能です。独自のカスタム型を Hashable プロトコルに準拠させる方法については、Hashable プロトコルへの準拠を参照してください。

カスタムの汎用型を作成する時、独自の型制約を定義することができ、そしてこれらの制約は、汎用プログラミングに多くの力を提供します。Hashable のような抽象的な概念は、それらの具象的な型よりも、それらの概念的な特性の点で型を特徴づけます。

型制約の構文

型パラメータリストの一部として、コロンで区切って、型パラメータの名前の後に、一つのクラスまたはプロトコル制約を配置することにより、型制約を書く事ができます。(構文は汎用型と同じですが) 汎用関数での型制約の基本的な構文を以下に示します。

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {

// function body goes here

}

上記の仮の関数には、２つの型パラメータがあります。最初の型パラメータ T　には、SomeClass のサブクラスであるように T を要求する型制約があります。第二の型パラメータ、U には、プロトコル SomeProtocol に準拠するよう U に求める型制約があります。

実際の型制約

ここで検索すべき与えられた String 値と、それをその中で見つけるべき String 値の配列を与えられた、findIndex(ofString:in:) と言う汎用でない関数を示します。findIndex(ofString:in:) 関数は、それが見つかった場合配列内で最初に一致した文字列のインデックスの、optional の Int 値を返し、または文字列が見つからない場合は nil を返します：

func findIndex(ofString valueToFind: String, in array: [String]) -> Int? {

for (index, value) in array.enumerated() {

if value == valueToFind {

return index

}

return nil

}

findIndex(ofString:in:) 関数は、文字列の配列内の文字列値を見つけるために使用できます。

let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]

if let foundIndex = findIndex(ofString: "llama", in: strings) {

print("The index of llama is \(foundIndex)")

}

// prints "The index of llama is 2"

配列内の値のインデックスを見つける原理は、しかし、文字列のみのためだけに有用ではありません。代わりに何らかの型 T の値を使用して文字列の全ての言及を置き換える汎用関数として、同じ機能を書くことができます。

ここで、findIndex(of:in:) と言う findIndex(ofString:in:) の汎用バージョンを書けることを期待している方法を記します。この関数の戻り値の型は、配列からの optional の値ではなく、optional のインデックス番号を関数は返すため、まだ Int? であることに注意してください。しかし、注意して下さい、理由は例の後に説明しますが、この関数はコンパイルされません：

func findIndex<T>(of valueToFind :T, in array: [T]) -> Int? {

for (index, value) in array.enumerated() {

if value == valueToFind {

return index

}

return nil

}

上述したように、この関数は、コンパイルされません。問題は、"if value == valueToFind" の等価性チェックの所です。Swift のすべての型が、等価演算子 (==) で比較できるわけではありません。たとえば、複雑なデータモデルを表現するために、独自のクラスまたは構造体を作成した場合、その後そのクラスまたは構造体の"等しい" という意味が Swift に推測できるわけではありません。このため、このコードは、すべての 可能な型 T で動作することを保証できず、コードをコンパイルしようとすると、適切なエラーが報告されます。

すべては、しかし、失われません。Swift 標準ライブラリは、Equatable と言うプロトコルを定義し、その型の全ての２つの値を比較するために等価演算子 (==) と非等価演算子 (!=) を実装するように、全ての準拠型に要求しています。Swift の標準的な型すべてが自動的に Equatable プロトコルをサポートしています。

Equatable である全ての型は、findIndex(of:in:) 関数で安全に使用でき、というのもそれは等価演算子をサポートすることを保証しているためです。関数を定義するときに、この事実を表現するには、型パラメータの定義の一部として Equatable の型制約を書いて下さい。

func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {

for (index, value) in array.enumerated() {

if value == valueToFind {

return index

}

return nil

}

findIndex(of:in:) の一つの型パラメータは、T：Equatable と書かれ、これは "Equatable プロトコルに準拠する全ての型 T" を意味します。

findIndex(of:in:) 関数はうまくコンパイルするようになり、Double や String のような Equatable である全ての型で使用できるようになります：

let doubleIndex = findIndex(of:9.3, in: [3.14159, 0.1, 0.25])

// doubleIndex is an optional Int with no value, because 9.3 is not in the array

let stringIndex = findIndex(of:"Andrea", in: ["Mike", "Malcolm", "Andrea"])

// stringIndex is an optional Int containing a value of 2

// All items match, so return true.

return true

}

この関数は、someContainer と anotherContainer と言う２つの引数を取ります。someContainer 引数は C1 型のものであり、anotherContainer 引数は C2 型のものです。C1 と C2 は両方とも、２つのコンテナ型の型パラメータで、関数が呼び出された際に決定されます。

以下の要件が関数の２つの型パラメータに配置されています：

C1 は Container プロトコルに準拠しなければなりません (C1: Container と書かれています)。
C2 もまた Container プロトコルに準拠しなければなりません (C2: Container と書かれています)。
C1 の Item は C2 の Item と同じでなければなりません (C1.Item == C2.Item と書かれています)。
C1 の Item は Equatable プロトコルに準拠しなければなりません (C1.Item: Equatable と書かれています)。

第一および第二の要件は、関数の型パラメータリストに定義されており、第三および第四の要件は、関数の汎用 where 句で定義されています。

これらの要件は、以下を意味します：

someContainer は C1 型のコンテナです。
anotherContainer は、C2 型のコンテナです。
someContainer と anotherContainer は同じ型の項目を含んでいます。
someContainer 内の項目は、それらが互いに異なっているかを確認するために不等価演算子 (!=) で確認できます。

第三及び第四の要件を合わせると、anotherContainer 内の項目も、someContainer 内の項目と完全に同じ型であるため、!= 演算子で確認できることを意味します。

これらの要件は、それらが異なるコンテナ型であっても、allItemsMatch(_:_:) 関数で二つのコンテナを比較することを可能にします。

allItemsMatch(_:_:) 関数は、両方のコンテナが同じ数の項目を含んでいることをチェックすることによって始まります。それらが異なる数の項目を含んでいる場合、それらが一致できる方法はなく、関数は false を返します。

このチェックを行った後、関数は for-in ループと半開放範囲演算子 (..<) で someContainer 内のすべての項目にわたって反復処理します。各項目について、関数は someContainer からの項目が anotherContainer 内の対応する項目と同じではないかチェックします。２つの項目が等しくない場合、２つのコンテナは、一致しておらず、関数は false を返します。

ループが不一致を見つけることなく終了した場合、二つのコンテナは一致し、関数は true を返します。

ここで、allItemsMatch(_:_:) 関数が実際にどのように見えるかを示します：

var stackOfStrings = Stack<String>()

stackOfStrings.push("uno")

stackOfStrings.push("dos")

stackOfStrings.push("tres")

var arrayOfStrings = ["uno", "dos", "tres"]

if allItemsMatch(stackOfStrings, arrayOfStrings) {

print("All items match.")

} else {

print("Not all items match.")

}

// prints "All items match."

上記の例では、String 値を格納する Stack インスタンスを作成し、スタック上に３つの文字列をプッシュします。この例ではまた、スタックと同じ３つの文字列を含む配列リテラルで初期化された Array インスタンスも作成します。スタックと配列が異なる型のものであっても、それら両者は、Container プロトコルに準拠しており、両者は同じ型の値を含んでいます。そのため、その引数として、これら二つのコンテナで allItemsMatch(_:_:) 関数を呼び出すことができます。上記の例では、allItemsMatch(_:_:) 関数は二つのコンテナ内の項目がすべて一致していることを正しく報告します。

汎用の Where 句を含む拡張機能

また、汎用の where 句を拡張機能の一部として使用することもできます。以下の例では、以前の例の汎用の Stack 構造体を拡張して isTop(_:) メソッドを追加しています。

extension Stack where Element: Equatable {

func isTop(_ item: Element) -> Bool {

guard let topItem = items.last else {

return false

}

return topItem == item

}

この新しい isTop(_:) メソッドは、最初にスタックが空でないことを確認して、それから与えられた項目をスタックの最上位の項目と比較します。汎用の where 句を使わずにこれを実行しようとすると、問題が発生します。isTop(_:) の実装では、== 演算子を使用しますが、Stack の定義ではその項目が equatable である必要はありません。そのため、== 演算子を使用するとコンパイル時エラーを起こします。汎用の where 句を使用すると、拡張機能に新しい要件を追加できるので、スタック内の項目が equatable である場合にのみ、拡張機能は isTop(_:) メソッドを追加します。

isTop(_:) メソッドが実際にどうなるかは以下のとおりです。

if stackOfStrings.isTop("tres") {

print("Top element is tres.")

} else {

print("Top element is something else.")

}

// Prints "Top element is tres."

その要素が equatable でないスタックで isTop(_:) メソッドを呼び出そうとすると、コンパイル時エラーが発生します。

struct NotEquatable { }

var notEquatableStack = Stack<NotEquatable>()

let notEquatableValue = NotEquatable()

notEquatableStack.push(notEquatableValue)

notEquatableStack.isTop(notEquatableValue) // Error

汎用の where 句をプロトコルへの拡張機能とともに使用することができます。以下の例では、以前の例の Container プロトコルを拡張して startsWith(_:) メソッドを追加しています。

extension Container where Item: Equatable {

func startsWith(_ item: Item) -> Bool {

return count >= 1 && self[0] == item

}

startsWith(_:) メソッドは、コンテナに少なくとも 1 つの項目があることを最初に確認し、コンテナ内の最初の項目が与えられた項目と一致するかどうかをチェックします。この新しい startsWith(_:) メソッドは、コンテナの項目が equatable である限り、上記で使用されたスタックや配列を含め、Container プロトコルに準拠するすべての型で使用できます。

if [9, 9, 9].startsWith(42) {

print("Starts with 42.")

} else {

print("Starts with something else.")

}

// Prints "Starts with something else."

上記の例の汎用の where 句は、Item がプロトコルに準拠することを要求しますが、Item が特定の型である事を必要とする汎用の where 句を書くこともできます。例えば：

extension Container where Item == Double {

func average() -> Double {

var sum = 0.0

for index in 0..<count {

sum += self[index]

}

return sum / Double(count)

}

print([1260.0, 1200.0, 98.6, 37.0].average())

// Prints "648.9"

この例では、その Item 型が Double であるコンテナに average() メソッドを追加しています。コンテナ内の項目を繰り返し処理して追加し、コンテナのカウントで除算して平均を計算します。浮動小数点除算を行う事ができるようになるために、Int から Double へカウントを明示的に変換します。

拡張機能の一部である汎用の where 句に複数の要件を含めることができ、これは、他の場所で記述する汎用の where 句と同様です。リストの各要件をコンマで区切ります。

文脈上の Where 句

ジェネリック型の文脈で既に作業している場合は、独自の汎用型制約を持たない宣言の一部として汎用の where 句を記述できます。たとえば、汎用型のサブスクリプトまたは汎用型への拡張機能のメソッドに汎用の where 句を記述できます。Container 構造体は汎用であり、以下の例の where 句は、これらの新しいメソッドをコンテナで使用できるようにするために満たさなければならない型制約を指定します。

extension Container {

func average() -> Double where Item == Int {

var sum = 0.0

for index in 0..<count {

sum += Double(self[index])

}

return sum / Double(count)

}

func endsWith(_ item: Item) -> Bool where Item: Equatable {

return count >= 1 && self[count-1] == item

}

let numbers = [1260, 1200, 98, 37]

print(numbers.average())

// Prints "648.75"

print(numbers.endsWith(37))

// Prints "true"

この例では、Item (項目) が Int (整数) の場合は average() メソッドを Container に追加し、項目が equatable (同等) の場合は endsWith(_:) メソッドを追加します。どちらの関数にも、Container の元の宣言から汎用の Item の型パラメータに型制約を追加する汎用の where 句が含まれています。

文脈上の where 句を使用せずにこのコードを記述したい場合は、汎用の where 句ごとに 1 つずつ、合計 2 つの拡張機能を記述して下さい。上記の例と以下の例は同じ動作をします。

extension Container where Item == Int {

func average() -> Double {

var sum = 0.0

for index in 0..<count {

sum += Double(self[index])

}

return sum / Double(count)

}

extension Container where Item: Equatable {

func endsWith(_ item: Item) -> Bool {

return count >= 1 && self[count-1] == item

}

文脈上の where 句を使用するこの例のバージョンでは、average() と endsWith(_:) の実装は両方とも同じ拡張機能にあります。これは、各メソッドの汎用の where 句が、そのメソッドを使用可能にするために満たすべき要件を示しているためです。これらの要件を拡張機能の汎用の where 句に移動すると、同じ状況でメソッドを使用できるようになりますが、要件ごとに 1 つの拡張機能が必要になります。

汎用のサブスクリプト

サブスクリプトは汎用にする事ができ、汎用の where 句を含めることができます。subscript の後で角括弧の中にプレースホルダ型の名前を書いて、サブスクリプトの本体の開き中括弧の直前に汎用の where 句を書いて下さい。例えば：

extension Container {

subscript<Indices: Sequence>(indices: Indices) -> [Item]

where Indices.Iterator.Element == Int {

var result = [Item]()

for index in indices {

result.append(self[index])

}

return result

}

Container プロトコルへのこの拡張機能は、一連のインデックスを取り、与えられた各インデックスに項目を含む配列を返すサブスクリプトを追加します。この汎用のサブスクリプトは、以下のように制約されます。

山括弧内の汎用パラメータ Indices は、標準ライブラリの Sequence プロトコルに準拠した型でなければなりません。
サブスクリプトは単一のパラメータ、indices を取りますが、これはその Indices 型のインスタンスです。
汎用の where 句は、シーケンスの反復因子が Int 型の要素を横断しなければならないことを要求します。これにより、シーケンス内のインデックス (indices) は、コンテナに使用されるインデックス (indices) と同じ型である事を保証します。

まとめると、これらの制約は、indices パラメータに渡される値が整数のシーケンスであることを意味します。

前：プロトコル次：不透明な型

トップへ

トップへ

トップへ

トップへ

Swift 5.8 日本語化計画　: Swift 5.8

汎用が解決する問題

汎用関数

型パラメータ

型パラメータの命名

汎用の型

汎用型の拡張

型制約

型制約の構文

実際の型制約

関連型

実際の関連型

既存の型を拡張して関連型を指定

関連型に制約を追加

関連型の制約でプロトコルを使用

汎用のWhere 句

汎用の Where 句を含む拡張機能

文脈上の Where 句

関連型と汎用の Where 句

汎用のサブスクリプト

Swift 5.8 全メニュー

Swift 5.8 日本語化計画 : Swift 5.8

汎用が解決する問題

汎用関数

型パラメータ

型パラメータの命名

汎用の型

汎用型の拡張

型制約

型制約の構文

実際の型制約

関連型

実際の関連型

既存の型を拡張して関連型を指定

関連型に制約を追加

関連型の制約でプロトコルを使用

汎用のWhere 句

汎用の Where 句を含む拡張機能

文脈上の Where 句

関連型と汎用の Where 句

汎用のサブスクリプト

Swift 5.8 全メニュー

Swift 5.8 日本語化計画　: Swift 5.8