Generics¶ 総称体¶

The Problem That Generics Solve¶ 総称体が解決する問題¶

Here’s a standard, nongeneric function called swapTwoInts(_:_:), which swaps two Int values: ここに、通常の、非総称体のswapTwoInts(_:_:)と呼ばれる関数があります、それは、２つのInt値を交換します：

This function makes use of in-out parameters to swap the values of a and b, as described in In-Out Parameters. この関数は、値aとbを交換するためにin-outパラメータの利用を行います、In-Outパラメータで記述されるように。

The swapTwoInts(_:_:) function swaps the original value of b into a, and the original value of a into b. You can call this function to swap the values in two Int variables: swapTwoInts(_:_:)関数は、bの元々の値をaの中へ、そしてaの元々の値をbの中へと交換します、そして、最初の値のにb。あなたは、２つのInt変数の値を交換するためにこの関数を呼ぶことができます：

The swapTwoInts(_:_:) function is useful, but it can only be used with Int values. If you want to swap two String values, or two Double values, you have to write more functions, such as the swapTwoStrings(_:_:) and swapTwoDoubles(_:_:) functions shown below: swapTwoInts(_:_:)関数は役に立ちます、しかし、それはInt値で使われることができるだけです。あなたが２つのString値、または２つのDoubleの値を交換したいならば、あなたはより多くの関数を書かなければなりません、例えば以下で示されるswapTwoStrings(_:_:)とswapTwoDoubles(_:_:)関数のように：

You may have noticed that the bodies of the swapTwoInts(_:_:), swapTwoStrings(_:_:), and swapTwoDoubles(_:_:) functions are identical. The only difference is the type of the values that they accept (Int, String, and Double). あなたは、swapTwoInts(_:_:)、swapTwoStrings(_:_:)、そしてswapTwoDoubles(_:_:)関数の本文が同一であると気がついたかもしれません。唯一の違いは、それらが受け入れる値の型（Int、String、そしてDouble）です。

It’s more useful, and considerably more flexible, to write a single function that swaps two values of any type. Generic code enables you to write such a function. (A generic version of these functions is defined below.) さらに役に立ち、そしてよりずっと柔軟であるのは、あらゆる型の２つの値を交換できるただ１つの関数を書くことです。総称体コードは、あなたにこのような関数を書くことを可能にします。（これらの関数の総称体版は、下で定義されます）。

Generic Functions¶ 総称体関数¶

Generic functions can work with any type. Here’s a generic version of the swapTwoInts(_:_:) function from above, called swapTwoValues(_:_:): 総称体関数は、どんな型でも扱うことができます。ここに、上記のswapTwoInts(_:_:)関数の総称体版があります、それはswapTwoValues(_:_:)と呼ばれます：

The body of the swapTwoValues(_:_:) function is identical to the body of the swapTwoInts(_:_:) function. However, the first line of swapTwoValues(_:_:) is slightly different from swapTwoInts(_:_:). Here’s how the first lines compare: swapTwoValues(_:_:)関数の本文は、swapTwoInts(_:_:)関数の本文と同一です。しかし、swapTwoValues(_:_:)の最初の行は、わずかにswapTwoInts(_:_:)と異なります。最初の行がどのくらい似ているかが、ここにあります：

The generic version of the function uses a placeholder type name (called T, in this case) instead of an actual type name (such as Int, String, or Double). The placeholder type name doesn’t say anything about what T must be, but it does say that both a and b must be of the same type T, whatever T represents. The actual type to use in place of T is determined each time the swapTwoValues(_:_:) function is called. この関数の総称体版は、プレースホルダ型名（この場合、Tと呼ばれるもの）を実際の型名（例えばInt、String、またはDouble）の代わりに使用します。プレースホルダ型名はTが何でなければならないかについて何も言いません、しかし、aとbの両方ともが同じ型Tでなければならないと述べます、Tが表わすものが何であれ。Tの代わりに実際に使われる型は、swapTwoValues(_:_:)関数が呼ばれるたびに決定されます。

The other difference between a generic function and a nongeneric function is that the generic function’s name (swapTwoValues(_:_:)) is followed by the placeholder type name (T) inside angle brackets (<T>). The brackets tell Swift that T is a placeholder type name within the swapTwoValues(_:_:) function definition. Because T is a placeholder, Swift doesn’t look for an actual type called T. 総称体関数と非総称体関数の間の他の違いは、総称体関数の名前（swapTwoValues(_:_:)）は、後ろにプレースホルダ型名（T）が山形括弧内部（<T>）で続くということです。この括弧は、TがswapTwoValues(_:_:)関数定義内のプレースホルダ型名であるとスウィフトに教えます。Tがプレースホルダであるので、スウィフトはTと呼ばれる実際の型を捜しません。

The swapTwoValues(_:_:) function can now be called in the same way as swapTwoInts, except that it can be passed two values of any type, as long as both of those values are of the same type as each other. Each time swapTwoValues(_:_:) is called, the type to use for T is inferred from the types of values passed to the function. swapTwoValues(_:_:)関数は現在swapTwoIntsと同じやり方で呼ばれることができます、しかしそれがあらゆる型の２つの値を渡されることが、それらの値の両方が互いに同じ型である限り可能であるのを除きます。swapTwoValues(_:_:)が呼ばれるたびに、Tのために使われる型は関数に渡される値の型から推論されます。

In the two examples below, T is inferred to be Int and String respectively: 下の２つの例で、TはそれぞれIntとStringであると推測されます：

Type Parameters¶ 型パラメータ¶

In the swapTwoValues(_:_:) example above, the placeholder type T is an example of a type parameter. Type parameters specify and name a placeholder type, and are written immediately after the function’s name, between a pair of matching angle brackets (such as <T>). 上のswapTwoValues(_:_:)例で、プレースホルダ型Tは型パラメータの一例です。型パラメータは、プレースホルダ型を指定して命名します、そして関数の名前の直後に一対の山形括弧の間で書かれます（例えば<T>）。

Once you specify a type parameter, you can use it to define the type of a function’s parameters (such as the a and b parameters of the swapTwoValues(_:_:) function), or as the function’s return type, or as a type annotation within the body of the function. In each case, the type parameter is replaced with an actual type whenever the function is called. (In the swapTwoValues(_:_:) example above, T was replaced with Int the first time the function was called, and was replaced with String the second time it was called.) 一旦あなたが型パラメータを指定するならば、あなたはそれを、関数のパラメータの型を定義するために（例えば、 swapTwoValues(_:_:)関数のaとbパラメータのように）、または関数の戻り型として、あるいは関数の本文内の型注釈として使用することができます。それぞれの場合において、型パラメータは、その関数が呼ばれるときはいつでも実際の型と取り替えられます。（上のswapTwoValues(_:_:)の例では、Tは関数が呼ばれた最初の時にIntと取り替えられて、それが呼ばれた２番目の時にStringと取り替えられました）。

You can provide more than one type parameter by writing multiple type parameter names within the angle brackets, separated by commas. あなたは、山形括弧内に複数の型パラメータ名をコンマで区切って書くことによって、複数の型パラメータを提供することができます。

Naming Type Parameters¶ 型パラメータに名をつける¶

In most cases, type parameters have descriptive names, such as Key and Value in Dictionary<Key, Value> and Element in Array<Element>, which tells the reader about the relationship between the type parameter and the generic type or function it’s used in. However, when there isn’t a meaningful relationship between them, it’s traditional to name them using single letters such as T, U, and V, such as T in the swapTwoValues(_:_:) function above. ほとんどの場合には、型パラメータは描写的な名前を持ちます、たとえばDictionary<Key, Value>におけるKeyとValueおよびArray<Element>におけるElementなど、それは読み手に型パラメータとそれがその中で使われる総称体型や関数との関係について語ります。しかしながら、意味がある関係がそれらの間に無かった時、T、U、そしてVなどの一文字を使ってそれらに名前をつけるのが伝統的です、例えば上のswapTwoValues(_:_:)関数におけるTのように。

Generic Types¶ 総称体型¶

In addition to generic functions, Swift enables you to define your own generic types. These are custom classes, structures, and enumerations that can work with any type, in a similar way to Array and Dictionary. 総称体関数に加えて、スウィフトはあなたに独自の総称体型を定義することを可能にします。これらは、ArrayとDictionaryに類似した方法で、あらゆる型で扱うことができる特注のクラス、構造体、そして列挙があります。

This section shows you how to write a generic collection type called Stack. A stack is an ordered set of values, similar to an array, but with a more restricted set of operations than Swift’s Array type. An array allows new items to be inserted and removed at any location in the array. A stack, however, allows new items to be appended only to the end of the collection (known as pushing a new value on to the stack). Similarly, a stack allows items to be removed only from the end of the collection (known as popping a value off the stack). この節は、あなたにStackと呼ばれる総称体コレクション型を書く方法を示します。スタックは、順序付けられたいくつかの値の集合であり、配列に似ています、しかしスウィフトのArray型より制限された操作具合を持つものです。配列は、新しい項目を差し込まれたり取り外除かれることがその配列のどんな場所においても許されます。スタックは、しかし、新しい項目をコレクション終わりにのみ追加されることが許されます（新しい値をスタックにプッシュするとして知られます）。同じように、スタックは項目をコレクションの終わりからだけ取り除かれることが許されます（値をスタックからポップするとして知られます）。

The illustration below shows the push and pop behavior for a stack: 下のイラストは、あるスタックのプッシュおよびポップ挙動を示します：

1. There are currently three values on the stack. 現在は３つの値がこのスタックにはあります。
2. A fourth value is pushed onto the top of the stack. 第４の値がスタックのてっぺんに押し込まれ（プッシュされ）ます。
3. The stack now holds four values, with the most recent one at the top. スタックは現在は４つの値を持ちます、最も最近のものは一番上にあります。
4. The top item in the stack is popped. スタックでの一番上の項目がポンと取り出され（ポップされ）ます。
5. After popping a value, the stack once again holds three values. 値をポップした後では、スタックは再び３つの値を持ちます。

Here’s how to write a nongeneric version of a stack, in this case for a stack of Int values: スタックの非総称体版を書く方法がここにあります、これはInt値のスタックの場合です：

This structure uses an Array property called items to store the values in the stack. Stack provides two methods, push and pop, to push and pop values on and off the stack. These methods are marked as mutating, because they need to modify (or mutate) the structure’s items array. この構造体は、itemsと呼ばれるArrayプロパティを使って値をスタックに格納します。Stackは２つのメソッド、pushとpopを提供します、それでスタック上に値を押し込んだり飛び出させたりします。これらのメソッドはmutatingとして印されます、なぜなら、それらが構造体のitems配列を修正する（または変化させる）必要があるためです。

The IntStack type shown above can only be used with Int values, however. It would be much more useful to define a generic Stack structure, that can manage a stack of any type of value. しかし、上で示されるIntStack型は、Int値で使われることができるだけです。それをもっと役に立つようにするには、総称体 Stack構造体を定義することです、それはあらゆる型の値のスタックを管理することができるものです。

Here’s a generic version of the same code: 同じコードの総称体版は、ここにあります：

Note how the generic version of Stack is essentially the same as the nongeneric version, but with a type parameter called Element instead of an actual type of Int. This type parameter is written within a pair of angle brackets (<Element>) immediately after the structure’s name. Stackの総称体版が、本質的にどれほど非総称体版と同じものであるかに注意してください、しかしElementと呼ばれる型パラメータを実際の型Intの代わりに持つことは除きます。この型パラメータは、構造体の名前の直後に一対の山形括弧の内部で（<Element>）書かれます。

Element defines a placeholder name for a type to be provided later. This future type can be referred to as Element anywhere within the structure’s definition. In this case, Element is used as a placeholder in three places: Elementは、プレースホルダ名を、後で提供されることになるある型に対して定義します。この将来の型は、構造体の定義の範囲内のどこででも「Element」として参照されることができます。この場合、Elementはプレースホルダとして３つの場所で使われます：

• To create a property called items, which is initialized with an empty array of values of type Element itemsと呼ばれるプロパティをつくる所で、それは、型Elementの値が入る空の配列で初期化されます
• To specify that the push(_:) method has a single parameter called item, which must be of type Element push(_:)メソッドが１つのパラメータ、itemと呼ばれるものを持つことを指定する所で、それは、型Elementでなければなりません
• To specify that the value returned by the pop() method will be a value of type Element pop()メソッドによって返される値が型Elementの値であることを示す所で

Because it’s a generic type, Stack can be used to create a stack of any valid type in Swift, in a similar manner to Array and Dictionary. それが総称体型であるので、Stackは、ArrayとDictionaryに類似したやり方で、スウィフトにおけるあらゆる有効な型のスタックを作るために使われることができます。

You create a new Stack instance by writing the type to be stored in the stack within angle brackets. For example, to create a new stack of strings, you write Stack<String>(): あなたは、新しいStackインスタンスを、角括弧の内側にそのスタックの中に格納される型を書くことによって作成します。例えば、新しく文字列のスタックを作成するために、あなたはStack<String>()を書きます：

Here’s how stackOfStrings looks after pushing these four values on to the stack: これらの４つの値をそのスタックにプッシュした後でstackOfStringsがどのように見えるかは、ここにあります：

Popping a value from the stack removes and returns the top value, "cuatro": このスタックから値をボップすることは、一番上の値、"cuatro"を削除して、返します：

Here’s how the stack looks after popping its top value: スタックがその一番上の値をポップした後にどう見えるかは、ここにあります：

Extending a Generic Type¶ 総称体型を拡張する¶

When you extend a generic type, you don’t provide a type parameter list as part of the extension’s definition. Instead, the type parameter list from the original type definition is available within the body of the extension, and the original type parameter names are used to refer to the type parameters from the original definition. あなたがある総称体型を拡張する時、あなたは型パラメーターリストを拡張の定義の一部として提供しません。そうしなくても、元々の型定義からの型パラメーターリストは、その拡張の本文内で利用可能です、そして元々の型パラメーター名は、元々の定義からの型パラメーターを参照するために使われます。

The following example extends the generic Stack type to add a read-only computed property called topItem, which returns the top item on the stack without popping it from the stack: 以下の例は総称体Stack型を拡張して、topItemと呼ばれる読み出し専用の計算プロパティを加えます、それは、スタックの一番上の項目をスタックからそれをポップすることなく返します：

The topItem property returns an optional value of type Element. If the stack is empty, topItem returns nil; if the stack isn’t empty, topItem returns the final item in the items array. topItemプロパティは型Elementのオプショナルの値を返します。スタックが空ならば、topItemはnilを返します；スタックが空でないならば、topItemはitems配列の最後の項目を返します。

Note that this extension doesn’t define a type parameter list. Instead, the Stack type’s existing type parameter name, Element, is used within the extension to indicate the optional type of the topItem computed property. この拡張は型パラメーターリストを定義しないことに注意してください。そうしなくても、Stack型の既存の型パラメーター名、Elementは、拡張の内部でtopItem計算プロパティの元々の型を指し示すために使われることができます。

The topItem computed property can now be used with any Stack instance to access and query its top item without removing it. topItem計算プロパティは、今やあらゆるStackインスタンスで、それの一番上の項目にそれを取り除くことなくアクセスおよび問い合わせるために使われることができます。

Extensions of a generic type can also include requirements that instances of the extended type must satisfy in order to gain the new functionality, as discussed in Extensions with a Generic Where Clause below. ある総称体型のそれぞれの拡張はまた、拡張された型のインスタンスが新しい機能性を獲得する手段として満たさなければならない要件を含むことができます、下の総称体where節を持つ拡張で議論されるように。

Type Constraints¶ 型制約¶

The swapTwoValues(_:_:) function and the Stack type can work with any type. However, it’s sometimes useful to enforce certain type constraints on the types that can be used with generic functions and generic types. Type constraints specify that a type parameter must inherit from a specific class, or conform to a particular protocol or protocol composition. swapTwoValues(_:_:)関数とStack型は、どんな型でも扱うことができます。しかし、総称体関数と総称体型で使われることができる型に、特定の型制約を強制することは、時々役に立ちます。型制約は、型パラメータが特定のクラスから継承しなければならない、もしくはある特定のプロトコルまたはプロトコル合成に準拠しなければならないことを指定します。

For example, Swift’s Dictionary type places a limitation on the types that can be used as keys for a dictionary. As described in Dictionaries, the type of a dictionary’s keys must be hashable. That is, it must provide a way to make itself uniquely representable. Dictionary needs its keys to be hashable so that it can check whether it already contains a value for a particular key. Without this requirement, Dictionary couldn’t tell whether it should insert or replace a value for a particular key, nor would it be able to find a value for a given key that’s already in the dictionary. 例えば、スウィフトのDictionary型は、辞書のキーとして使われることができる型に制限を置きます。辞書で記述されるように、辞書のキーの型は、ハッシュ化できなければなりません。すなわち、それはそれ自身を特有に表わすことを可能にする方法を提供しなければなりません。Dictionaryは、それが特定のキーのためにすでに値を含むかどうか確認できるように、そのキーにハッシュ化できることを必要とします。この要件なしでは、Dictionaryはそれが特定のキーのために値を差し込んだり取り替えたりするべきかどうか伝えることができませんし、それはすでに辞書の中にある指定されたキーに対する値を見つけることもできません。

This requirement is enforced by a type constraint on the key type for Dictionary, which specifies that the key type must conform to the Hashable protocol, a special protocol defined in the Swift standard library. All of Swift’s basic types (such as String, Int, Double, and Bool) are hashable by default. For information about making your own custom types conform to the Hashable protocol, see Conforming to the Hashable Protocol. この要件は、Dictionaryのためのキー型に関する型制約によって強制されます、それは、キー型がスウィフト標準ライブラリで定義される特別なプロトコル、Hashableプロトコルに準拠しなければならないことを示します。スウィフトの基本の型（例えばString、Int、Double、そしてBool）の全ては、初期状態でハッシュ化されます。あなた独自のあつらえの型をHashableプロトコルに準拠させることについての情報として、Hashableプロトコルに準拠するを見てください。

You can define your own type constraints when creating custom generic types, and these constraints provide much of the power of generic programming. Abstract concepts like Hashable characterize types in terms of their conceptual characteristics, rather than their concrete type. あなたは、独自の型制約をあつらえの総称体型を作成する時に定義することができます、そして、それらの制約は総称体プログラミングの力の多くを提供します。Hashableのような抽象的な概念それらは、それらの概念上の特徴の観点から型を特徴づけます、その具象型そのものではなく。

Associated Types¶ 関連型¶

When defining a protocol, it’s sometimes useful to declare one or more associated types as part of the protocol’s definition. An associated type gives a placeholder name to a type that’s used as part of the protocol. The actual type to use for that associated type isn’t specified until the protocol is adopted. Associated types are specified with the associatedtype keyword. プロトコルを定義するとき、時々役に立つのは、プロトコルの定義の一部として１つ以上の関連型を宣言することです。関連型は、プロトコルの一部として使われる型にプレースホルダ名を与えます。その関連型のために使われる実際の型は、プロトコルが採用されるまでは指定されません。関連型は、associatedtypeキーワードで指定されます。

Generic Where Clauses¶ 総称体where節¶

Type constraints, as described in Type Constraints, enable you to define requirements on the type parameters associated with a generic function, subscript, or type. 型制約は、「型制約」で記述されるように、総称体の関数、添え字、または型と関連した型パラメータに要件を定義することをあなたに可能にします。

It can also be useful to define requirements for associated types. You do this by defining a generic where clause. A generic where clause enables you to require that an associated type must conform to a certain protocol, or that certain type parameters and associated types must be the same. A generic where clause starts with the where keyword, followed by constraints for associated types or equality relationships between types and associated types. You write a generic where clause right before the opening curly brace of a type or function’s body. 関連型のために要件を定義することは、また同様に役に立ちます。あなたはこれを総称体where節を定義する事によって行います。総称体where節は、ある関連型が特定のプロトコルに準拠しなければならないこと、または特定の型パラメータおよび関連型が同じでなければならないことをあなたが要求できるようにします。総称体where節は、whereキーワードで始まり、関連型に対する制約がいくつか、または型と関連型の間の同等関係性がいくつか続きます。あなたは、総称体where節を、型や関数のもつ本文の開き波括弧のまさに前に記述します。

The example below defines a generic function called allItemsMatch, which checks to see if two Container instances contain the same items in the same order. The function returns a Boolean value of true if all items match and a value of false if they don’t. 下の例はallItemsMatchと呼ばれる総称体関数を定義します、それは、２つのContainerインスタンスが同じ順序で同じ項目を含むかどうか見るために調べます。この関数は全ての項目が合致するならばブール値のtrueを、それらがそうしないならばfalseの値を返します。

The two containers to be checked don’t have to be the same type of container (although they can be), but they do have to hold the same type of items. This requirement is expressed through a combination of type constraints and a generic where clause: 調べられる２つのコンテナは、同じ型のコンテナである必要はありません（とは言えそうでもよい）、しかしそれらは同じ型の項目を持たなければなりません。この要件は、型制約と総称体where節の組合せによって表されます：

This function takes two arguments called someContainer and anotherContainer. The someContainer argument is of type C1, and the anotherContainer argument is of type C2. Both C1 and C2 are type parameters for two container types to be determined when the function is called. この関数は、someContainerとanotherContainerと呼ばれる２つの引数をとります。someContainer引数は型C1です、そしてanotherContainer引数は型C2です。C1とC2の両方は、２つのコンテナ型のための型パラメータで、関数が呼ばれるときに決定されます。

The following requirements are placed on the function’s two type parameters: 以下の要件は、この関数の持つ２つの型パラメータ上に置かれます：

• C1 must conform to the Container protocol (written as C1: Container). C1は、Containerプロトコルに準拠しなければなりません（C1: Containerのように書かれます）。
• C2 must also conform to the Container protocol (written as C2: Container). C2もまた、Containerプロトコルに準拠しなければなりません（C2: Containerのように書かれます）。
• The Item for C1 must be the same as the Item for C2 (written as C1.Item == C2.Item). C1のためのItemは、C2のためのItemと同じものでなければなりません（C1.Item == C2.Itemのように書かれます）。
• The Item for C1 must conform to the Equatable protocol (written as C1.Item: Equatable). C1のためのItemは、Equatableプロトコルに準拠しなければなりません（C1.Item: Equatableのように書かれます）。

The first and second requirements are defined in the function’s type parameter list, and the third and fourth requirements are defined in the function’s generic where clause. 最初と２番目の要件は関数のもつ型パラメータリストにおいて定義されます、そして３番目と４番目の要件は関数のもつ総称体where節において定義されます。

These requirements mean: これらの要件が意味するのは：

• someContainer is a container of type C1. someContainerは、型C1のコンテナです。
• anotherContainer is a container of type C2. anotherContainerは、型C2のコンテナです。
• someContainer and anotherContainer contain the same type of items. someContainerとanotherContainerは、同じ型の項目を含みます。
• The items in someContainer can be checked with the not equal operator (!=) to see if they’re different from each other. someContainerの中の項目は、それらがお互いと異なるかどうか見るために不等演算子（!=）を使って確認されることができます。

The third and fourth requirements combine to mean that the items in anotherContainer can also be checked with the != operator, because they’re exactly the same type as the items in someContainer. ３番目と４番目の要件は組み合わされて、anotherContainerの中の項目が!=演算子を使って確認されることが同様に可能なことを意味します、なぜなら、それらはsomeContainerの中の項目と同じ正確に型であるからです。

These requirements enable the allItemsMatch(_:_:) function to compare the two containers, even if they’re of a different container type. これらの要件は、allItemsMatch(_:_:)関数に２つのコンテナを比較するのを可能にします、たとえそれらが異なるコンテナ型であるとしてもです。

The allItemsMatch(_:_:) function starts by checking that both containers contain the same number of items. If they contain a different number of items, there’s no way that they can match, and the function returns false. allItemsMatch(_:_:)関数は、両方のコンテナが同じ数の項目を含むことを確認することによって始まります。それらが異なる数の項目を含むならば、それらが合致することができる術はありません、そして関数はfalseを返します。

After making this check, the function iterates over all of the items in someContainer with a for-in loop and the half-open range operator (..<). For each item, the function checks whether the item from someContainer isn’t equal to the corresponding item in anotherContainer. If the two items aren’t equal, then the two containers don’t match, and the function returns false. この確認の後、関数はsomeContainerの項目の全てに渡ってfor-inループと半開範囲演算子（..<）を使って繰り返します。各項目のために、関数はsomeContainerからの項目がanotherContainerでの対応する項目と同等でないかどうか確認します。２つの項目が等しくないならば、２つのコンテナは合致しません、そして関数はfalseを返します。

If the loop finishes without finding a mismatch, the two containers match, and the function returns true. ループが一致しない組合せを見つけることなく終わるならば、２つのコンテナは合致します、そして関数はtrueを返します。

Here’s how the allItemsMatch(_:_:) function looks in action: 動作中のallItemsMatch(_:_:)関数がどのように見えるかが、ここにあります：

The example above creates a Stack instance to store String values, and pushes three strings onto the stack. The example also creates an Array instance initialized with an array literal containing the same three strings as the stack. Even though the stack and the array are of a different type, they both conform to the Container protocol, and both contain the same type of values. You can therefore call the allItemsMatch(_:_:) function with these two containers as its arguments. In the example above, the allItemsMatch(_:_:) function correctly reports that all of the items in the two containers match. 上の例は、StackインスタンスをつくってString値を格納します、そしてスタック上へ３つの文字列をプッシュします。この例はまた、このスタックと同じ３つの文字列を含む配列リテラルで初期化されるArrayインスタンスをつくります。たとえスタックと配列が異なる型であるとしても、それらは両方ともContainerプロトコルに準拠して、両方とも同じ型の値を含みます。あなたは、したがって、allItemsMatch(_:_:)関数をその引数としてこれらの２つのコンテナを使って呼ぶことができます。上の例で、allItemsMatch(_:_:)関数は、２つのコンテナの中の項目の全てが一致すると正しく報告します。

Extensions with a Generic Where Clause¶ 総称体where節を持つ拡張¶

You can also use a generic where clause as part of an extension. The example below extends the generic Stack structure from the previous examples to add an isTop(_:) method. あなたまた、総称体where節を拡張の一部として使うことができます。下の例は、以前の例の総称体Stack構造体を拡張して、isTop(_:)メソッドを加えます。

This new isTop(_:) method first checks that the stack isn’t empty, and then compares the given item against the stack’s topmost item. If you tried to do this without a generic where clause, you would have a problem: The implementation of isTop(_:) uses the == operator, but the definition of Stack doesn’t require its items to be equatable, so using the == operator results in a compile-time error. Using a generic where clause lets you add a new requirement to the extension, so that the extension adds the isTop(_:) method only when the items in the stack are equatable. この新しいisTop(_:)メソッドは、まずスタックが空でないことを確認します、それから与えられた項目をスタックの持つ最も上の項目と比較します。あなたが総称体where節なしにこれをしようとするならば、あなたは問題を抱えることになるでしょう：isTop(_:)の実装は==演算子を使います、しかしStackの定義はそれの項目に同等評価可能であることを要求しません、それで==演算子の使用はコンパイル時エラーという結果になります。総称体where節を使うことは、あなたに新しい要件をその拡張に追加させます、それで拡張はisTop(_:)メソッドをスタックの中の項目が同等評価可能なものである時のみ加えます。

Here’s how the isTop(_:) method looks in action: 動作中のisTop(_:)メソッドがどのように見えるかが、ここにあります：

If you try to call the isTop(_:) method on a stack whose elements aren’t equatable, you’ll get a compile-time error. あなたがisTop(_:)メソッドを、それの持つ要素が同等評価可能でないスタック上で呼び出そうとするならば、あなたはコンパイル時エラーを得るでしょう。

You can use a generic where clause with extensions to a protocol. The example below extends the Container protocol from the previous examples to add a startsWith(_:) method. あなたは、総称体where節をプロトコルに対する拡張で使うことができます。下の例は、以前の例のContainerプロトコルを拡張して、startsWith(_:)メソッドを追加します。

The startsWith(_:) method first makes sure that the container has at least one item, and then it checks whether the first item in the container matches the given item. This new startsWith(_:) method can be used with any type that conforms to the Container protocol, including the stacks and arrays used above, as long as the container’s items are equatable. startsWith(_:)メソッドはまず、コンテナが少なくとも１つの項目を持つことを確かめます、それからそれはそのコンテナの最初の項目が与えられた項目と合致するかどうか調べます。この新しいstartsWith(_:)メソッドはContainerプロトコルに準拠するあらゆる型で使われることができます、上で使われるスタックと配列を含めて、コンテナの持つ項目が同等評価可能である限りは。

The generic where clause in the example above requires Item to conform to a protocol, but you can also write a generic where clauses that require Item to be a specific type. For example: 上の例の総称体where節は、Itemに要求してあるプロトコルに準拠させます、しかしあなたはまたItemに特定の型であることを要求する総称体where節を書くことができます。例えば：

This example adds an average() method to containers whose Item type is Double. It iterates over the items in the container to add them up, and divides by the container’s count to compute the average. It explicitly converts the count from Int to Double to be able to do floating-point division. この例は、average()メソッドを、Item型がDoubleであるコンテナに追加します。それは、コンテナの中の項目すべてにわたって繰り返していき、それらを合計します、そしてコンテナの総数で除算することで平均を計算します。それは、明示的に総数をIntからDoubleへ変換して、浮動小数点除算ができるようにします。

You can include multiple requirements in a generic where clause that’s part of an extension, just like you can for a generic where clause that you write elsewhere. Separate each requirement in the list with a comma. あなたは、複数の要件を拡張の一部であるひとつのwhere節の中に含めることができます、ちょうどあなたがどこか他で書く総称体where節に対してできるように。リストの中の各要件をコンマで区切ってください。

Contextual Where Clauses¶ 文脈where節¶

You can write a generic where clause as part of a declaration that doesn’t have its own generic type constraints, when you’re already working in the context of generic types. For example, you can write a generic where clause on a subscript of a generic type or on a method in an extension to a generic type. The Container structure is generic, and the where clauses in the example below specify what type constraints have to be satisfied to make these new methods available on a container. あなたは総称体where節を、それ自身の総称体型制約を持たないある宣言の一部として書くことが、あなたが既に総称体型の文脈の中で作業している時は可能です。例えば、あなたは総称体where節をある総称体型の添え字上でまたはある総称体型への拡張の中のメソッド上で書くことができます。Container構造体は総称体です、そして下の例の中のwhere節は、どんな型制約がそれら新しいメソッドをあるコンテナ上で利用可能にするためには満たされなければならないかを指定します。

This example adds an average() method to Container when the items are integers, and it adds an endsWith(_:) method when the items are equatable. Both functions include a generic where clause that adds type constraints to the generic Item type parameter from the original declaration of Container. この例は、average()メソッドをContainerへとその項目が整数である場合は加えます、そしてそれはendsWith(_:)メソッドを項目が同等評価可能である場合は加えます。両方の関数は、ある総称体where節を含みます、それは型制約をContainerの元の宣言由来の総称体Item型パラメータに加えます。

If you want to write this code without using contextual where clauses, you write two extensions, one for each generic where clause. The example above and the example below have the same behavior. あなたがこのコードを文脈where節を使うことなく書きたいならば、あなたは２つの拡張を書きます、各where節のために１つ。上の例と下の例は同じ挙動を持ちます。

In the version of this example that uses contextual where clauses, the implementation of average() and endsWith(_:) are both in the same extension because each method’s generic where clause states the requirements that need to be satisfied to make that method available. Moving those requirements to the extensions’ generic where clauses makes the methods available in the same situations, but requires one extension per requirement. この例の文脈where節を使うバージョンでは、average()とendsWith(_:)の実装は両方とも同じ拡張の中にあります、なぜなら各メソッドのもつ総称体where節それらが、そのメソッドを利用可能にするのに満足させる必要がある要件を述べるからです。それらの要件を拡張のもつ総称体where節に移動することは、メソッドそれらを同じ状況で利用可能にします、しかし要件ごとに１つの拡張を要します。

Associated Types with a Generic Where Clause¶ 総称体where節を持つ関連型¶

You can include a generic where clause on an associated type. For example, suppose you want to make a version of Container that includes an iterator, like what the Sequence protocol uses in the standard library. Here’s how you write that: あなたは、総称体where節を関連型に関して含めることができます。例えば、あなたがContainerのあるバージョンを作りたいと仮定してください、それはあるイテレータ、標準ライブラリで使われているSequenceプロトコルのようなものを含みます。あなたがそれをどう書くかここにあります：

The generic where clause on Iterator requires that the iterator must traverse over elements of the same item type as the container’s items, regardless of the iterator’s type. The makeIterator() function provides access to a container’s iterator. この総称体where節がIterator上で要求するのは、そのイテレータがコンテナのもつ要素と同じ項目型の要素に対して見ていくことです、そのイテレータの持つ型に関係なく。makeIterator()関数は、コンテナの持つイテレータに対するアクセスを提供します。

For a protocol that inherits from another protocol, you add a constraint to an inherited associated type by including the generic where clause in the protocol declaration. For example, the following code declares a ComparableContainer protocol that requires Item to conform to Comparable: 別のプロトコルから継承するプロトコルに対して、あなたは継承された関連型への制約の追加を、総称体where節をそのプロトコル宣言の中で含めることによって行います。例えば、以下のコードはComparableContainerプロトコルを宣言します、それはItemがComparableに準拠することを要求します：

Generic Subscripts¶ 総称体添え字¶

Subscripts can be generic, and they can include generic where clauses. You write the placeholder type name inside angle brackets after subscript, and you write a generic where clause right before the opening curly brace of the subscript’s body. For example: 添え字は総称体であることができます、そしてそれらは総称体where節を含むことができます。あなたは、プレースホルダ型名を山括弧の内部にsubscriptの後に書きます、そしてあなたは総称体where節を添え字本文の開き波括弧の直前に書きます。例えば：

This extension to the Container protocol adds a subscript that takes a sequence of indices and returns an array containing the items at each given index. This generic subscript is constrained as follows: このContainerプロトコルに対する拡張は、ある添え字を追加します、それはインデックスのシーケンスをとって、与えられたインデックスそれぞれでの項目を含んでいる配列を返します。この総称体添え字は、以下のように制約されます：

• The generic parameter Indices in angle brackets has to be a type that conforms to the Sequence protocol from the standard library. 山括弧の中の総称体パラメータIndicesは、それは標準ライブラリからのSequenceプロトコルに準拠する型でなければなりません。
• The subscript takes a single parameter, indices, which is an instance of that Indices type. この添え字は、ただ１つだけのパラメータ、indicesをとります、それはIndices型のインスタンスです。
• The generic where clause requires that the iterator for the sequence must traverse over elements of type Int. This ensures that the indices in the sequence are the same type as the indices used for a container. この総称体where節が要求するのは、このシーケンスのためのイテレータが型Intの要素について見ていかなければなければならないことです。これは、このシーケンスのインデックスがコンテナに対して使われるインデックスと同じ型であるのを保証することになります。

Taken together, these constraints mean that the value passed for the indices parameter is a sequence of integers. 総合すると、これらの制約が意味するのは、indicesパラメータに対して渡される値は整数からなるシーケンスであるということです。