Types¶ 型¶

Type Annotation¶ 型注釈¶

A type annotation explicitly specifies the type of a variable or expression. Type annotations begin with a colon (:) and end with a type, as the following examples show: ある型注釈は、明確に変数または式の型を指定します。型注釈は、以下の例が示すように、コロン（:）で始まりひとつの型で終わります：

In the first example, the expression someTuple is specified to have the tuple type (Double, Double). In the second example, the parameter a to the function someFunction is specified to have the type Int. 最初の例で、式someTupleは、タプル型(Double, Double)を持つと指定されます。第二の例で関数someFunctionのためのパラメータaは、型Intを持つ指定されます。

Type annotations can contain an optional list of type attributes before the type. 型注釈は、型の前に任意の型属性のリストを含むことができます。

Type Identifier¶ 型識別子¶

A type identifier refers to either a named type or a type alias of a named or compound type. 型識別子は、名前付きの型か、名前付きまたは複合の型の型エイリアスに言及します。

Most of the time, a type identifier directly refers to a named type with the same name as the identifier. For example, Int is a type identifier that directly refers to the named type Int, and the type identifier Dictionary<String, Int> directly refers to the named type Dictionary<String, Int>. ほとんどの場合、型識別子は、名前付きの型に、その識別子と同じ名前で直接に言及します。例えば、Intは、直接に名前付きの型Intに言及する型識別子です、そして型識別子Dictionary<String, Int>は、直接に名前付きの型Dictionary<String, Int>に言及します。

There are two cases in which a type identifier doesn’t refer to a type with the same name. In the first case, a type identifier refers to a type alias of a named or compound type. For instance, in the example below, the use of Point in the type annotation refers to the tuple type (Int, Int). ある型識別子がある型に同じ名前で言及しない２つの場合があります。第一の場合には、型識別子は、名前付きまたは複合の型の型エイリアスに言及します。たとえば、下記の例で、型注釈においてPointを使うことは、タプル型(Int, Int)に言及します。

In the second case, a type identifier uses dot (.) syntax to refer to named types declared in other modules or nested within other types. For example, the type identifier in the following code references the named type MyType that’s declared in the ExampleModule module. 第二の場合には、型識別子は、他のモジュールで宣言される、または他の型の内部で入れ子にされる名前付きの型を参照するためにドット（.）構文を使用します。例えば、以下のコードの型識別子は、ExampleModuleモジュールで宣言される名前付きの型MyTypeを参照します。

Tuple Type¶ タプル型¶

A tuple type is a comma-separated list of types, enclosed in parentheses. タプル型は、丸括弧で囲まれた、いくつかの型からなるコンマ区切りのリストです。

You can use a tuple type as the return type of a function to enable the function to return a single tuple containing multiple values. You can also name the elements of a tuple type and use those names to refer to the values of the individual elements. An element name consists of an identifier followed immediately by a colon (:). For an example that demonstrates both of these features, see Functions with Multiple Return Values. あなたは、関数の戻り型としてタプル型を使って、その関数に複数の値を含んでいる１つのタプルを返すのを可能にすることができます。あなたは、また、タプル型の要素に名をつけることができて、それらの名前を個々の要素の値に言及するために使用することができます。要素名は、識別子に直ちにコロン（：）が続くものから成ります。これらの特徴の両方を示す例のために、複数の戻り値をもつ関数を見てください。

When an element of a tuple type has a name, that name is part of the type. あるタプル型の要素が名前を持つ場合、その名前は型の一部です。

All tuple types contain two or more types, except for Void which is a type alias for the empty tuple type, (). すべてのタプル型は２つまたはそれ以上の型を含みます、しかし空のタプル型、()に対する型エイリアスであるVoidを除きます。

Function Type¶ 関数型¶

A function type represents the type of a function, method, or closure and consists of a parameter and return type separated by an arrow (->): 関数型は、ある関数、メソッド、またはクロージャの型を表して、矢印（->）で区切られたパラメータと戻り型から成ります：

The parameter type is comma-separated list of types. Because the return type can be a tuple type, function types support functions and methods that return multiple values. parameter typeはコンマ区切りの型のリストです。return typeはタプル型であることが可能なので、関数型は複数の値を返す関数およびメソッドをサポートします。

A parameter of the function type () -> T (where T is any type) can apply the autoclosure attribute to implicitly create a closure at its call sites. This provides a syntactically convenient way to defer the evaluation of an expression without needing to write an explicit closure when you call the function. For an example of an autoclosure function type parameter, see Autoclosures. 関数型() -> T（ここでTはどんな型でも）のあるパラメータは、autoclosure属性を適用することによって、あるクロージャを暗黙的にそれの呼び出し領域で作成することができます。これは、あなたがその関数を呼び出す時に明示的なクロージャを書く必要なしに、ある式の評価を延期する統語的に便利な方法を提供します。自動クロージャ関数型パラメータの例として、自動クロージャを見てください。

A function type can have variadic parameters in its parameter type. Syntactically, a variadic parameter consists of a base type name followed immediately by three dots (...), as in Int.... A variadic parameter is treated as an array that contains elements of the base type name. For instance, the variadic parameter Int... is treated as [Int]. For an example that uses a variadic parameter, see Variadic Parameters. 関数型は、そのパラメータ型において可変長パラメータいくつかを持つことができます。統語的には、可変長パラメータは、Int...のように、基となる型名に直ちに３つの点（...）が続くものから成ります。可変長パラメータは、基本の型の名前の要素それらが入っている配列とみなされます。たとえば、可変長パラメータInt...は[Int]とみなされます。可変長パラメータを使う例のために、可変長パラメータを見てください。

To specify an in-out parameter, prefix the parameter type with the inout keyword. You can’t mark a variadic parameter or a return type with the inout keyword. In-out parameters are discussed in In-Out Parameters. in-outパラメータを指定するために、inoutキーワードをそのパラメータ型の前に置いてください。あなたは、可変長パラメータまたは戻り型にinoutキーワードで印をつけることができません。in-outパラメータは、in-outパラメータで議論されます。

If a function type has only one parameter and that parameter’s type is a tuple type, then the tuple type must be parenthesized when writing the function’s type. For example, ((Int, Int)) -> Void is the type of a function that takes a single parameter of the tuple type (Int, Int) and doesn’t return any value. In contrast, without parentheses, (Int, Int) -> Void is the type of a function that takes two Int parameters and doesn’t return any value. Likewise, because Void is a type alias for (), the function type (Void) -> Void is the same as (()) -> ()—a function that takes a single argument that’s an empty tuple. These types aren’t the same as () -> ()—a function that takes no arguments. ある関数型がただ１つだけのパラメータを持ちそしてそのパラメータの型がタプル型であるならば、その場合そのタプル型は関数の型を記述する時に丸括弧に入れられなければなりません。例えば、((Int, Int)) -> Voidは、タプル型(Int, Int)の単一のパラメータを取り、何ら値を返さない関数の型です。対して、丸括弧なしで、(Int, Int) -> Voidは、２つのIntパラメータを取り、何ら値を返さない関数の型です。同様に、Voidが()に対する型エイリアスであることから、関数型(Void) -> Voidは(()) -> () — ただ１つの引数を取りそれが空のタプルである関数、と同じです。これらの型は、() -> () — 引数を取らない関数、と同じではありません。

Argument names in functions and methods aren’t part of the corresponding function type. For example: 関数やメソッドの引数名は、対応する関数型の一部ではありません。例えば：

Because argument labels aren’t part of a function’s type, you omit them when writing a function type. 引数ラベルは関数の型の一部ではないことから、あなたはそれらを関数型を書く時に省略します。

If a function type includes more than a single arrow (->), the function types are grouped from right to left. For example, the function type (Int) -> (Int) -> Int is understood as (Int) -> ((Int) -> Int)—that is, a function that takes an Int and returns another function that takes and returns an Int. ある関数型がただ１つだけの矢印（->）ではなくもっと多く含むならば、その関数型は右から左にグループにされます。例えば、関数型(Int) -> (Int) -> Intは、(Int) -> ((Int) -> Int)として理解されます ― すなわち、ひとつのIntを取って、ひとつのIntを取りそして返す別の関数を返す関数。

Function types that can throw or rethrow an error must be marked with the throws keyword. The throws keyword is part of a function’s type, and nonthrowing functions are subtypes of throwing functions. As a result, you can use a nonthrowing function in the same places as a throwing one. Throwing and rethrowing functions are described in Throwing Functions and Methods and Rethrowing Functions and Methods. エラーをスローまたは再スローできる関数型は、throwsキーワードで印されなければなりません。throwsキーワードは関数の型の一部です、そしてスローを行わない関数はスロー関数の下位型です。結果として、あなたは非スロー関数をスロー関数と同じ場所で使うことができます。スローおよび再スロー関数は、スロー関数とメソッドと再スロー関数とメソッドにおいて記述されます。

Array Type¶ 配列型¶

The Swift language provides the following syntactic sugar for the Swift standard library Array<Element> type: スウィフト言語は、スウィフト標準ライブラリのArray<Element>型のために以下の糖衣構文を提供します：

In other words, the following two declarations are equivalent: 言い換えると、以下の２つの宣言は、等しいです：

In both cases, the constant someArray is declared as an array of strings. The elements of an array can be accessed through subscripting by specifying a valid index value in square brackets: someArray[0] refers to the element at index 0, "Alex". 両方の場合で、定数のsomeArrayは、文字列の配列として宣言されます。配列の要素は、角括弧の中に有効なインデックス値を指定することによる添え字指定を通してアクセスされることができます：someArray[0]]は、インデックス0での要素、"Alex"に言及します。

You can create multidimensional arrays by nesting pairs of square brackets, where the name of the base type of the elements is contained in the innermost pair of square brackets. For example, you can create a three-dimensional array of integers using three sets of square brackets: あなたは、角括弧の対を入れにすることによって多次元配列をつくることができます、そこで要素の基本型の名前は最も内側の角括弧の対の中に含まれます。例えば、あなたは３つ固めた角括弧を使って整数の三次元配列をつくることができます：

When accessing the elements in a multidimensional array, the left-most subscript index refers to the element at that index in the outermost array. The next subscript index to the right refers to the element at that index in the array that’s nested one level in. And so on. This means that in the example above, array3D[0] refers to [[1, 2], [3, 4]], array3D[0][1] refers to [3, 4], and array3D[0][1][1] refers to the value 4. 多次元配列の要素にアクセスするとき、最も左の添え字インデックスは、最も外側の配列の中のそのインデックスでの要素に言及します。次の右の添え字インデックスは、１段階内側の入れ子にされた配列の中のそのインデックスでの要素に言及します。などなど。これは、上の例で、array3D[0]は[[1, 2], [3, 4]]に言及し、array3D[0][1]は[3, 4]に言及し、そしてarray3D[0][1][1]は値４に言及することを意味します。

For a detailed discussion of the Swift standard library Array type, see Arrays. スウィフト標準ライブラリArray型の詳細な議論のために、配列を見てください。

Dictionary Type¶ 辞書型¶

The Swift language provides the following syntactic sugar for the Swift standard library Dictionary<Key, Value> type: スウィフト言語は、以下の糖衣構文をスウィフト標準ライブラリDictionary<Key, Value>型に提供します：

In other words, the following two declarations are equivalent: 言い換えると、以下の２つの宣言は、等しいです：

In both cases, the constant someDictionary is declared as a dictionary with strings as keys and integers as values. 両方の場合で、定数someDictionaryは、キーとして文字列そして値として整数を持つ辞書として宣言されます。

The values of a dictionary can be accessed through subscripting by specifying the corresponding key in square brackets: someDictionary["Alex"] refers to the value associated with the key "Alex". The subscript returns an optional value of the dictionary’s value type. If the specified key isn’t contained in the dictionary, the subscript returns nil. 辞書の値は、角括弧の中に対応するキーを指定することによる添え字指定を通してアクセスされることができます：someDictionary["Alex"]はキー"Alex"と結び付けられた値に言及します。添え字は辞書のもつ値型のオプショナルの値を返します。指定されたキーがその辞書に含まれないならば、添え字はnilを返します。

The key type of a dictionary must conform to the Swift standard library Hashable protocol. ある辞書のキーの型は、スウィフト標準ライブラリHashableプロトコルに準拠しなければなりません。

For a detailed discussion of the Swift standard library Dictionary type, see Dictionaries. スウィフト標準ライブラリDictionary型の詳細な議論として、辞書を見てください。

Optional Type¶ オプショナル型¶

The Swift language defines the postfix ? as syntactic sugar for the named type Optional<Wrapped>, which is defined in the Swift standard library. In other words, the following two declarations are equivalent: スウィフト言語は、接尾辞?を糖衣構文として名前付きの型Optional<Wrapped>に対して定義します、それは、スウィフト標準ライブラリで定義されます。言い換えると、以下の２つの宣言は、等しいです：

In both cases, the variable optionalInteger is declared to have the type of an optional integer. Note that no whitespace may appear between the type and the ?. 両方の場合には、変数optionalIntegerは、オプショナル整数の型を持つと宣言されます。空白が型と?の間に現れないことに注意してください。

The type Optional<Wrapped> is an enumeration with two cases, none and some(Wrapped), which are used to represent values that may or may not be present. Any type can be explicitly declared to be (or implicitly converted to) an optional type. If you don’t provide an initial value when you declare an optional variable or property, its value automatically defaults to nil. 型Optional<Wrapped>は、noneとsome(Wrapped)、２つのケース節をもつ列挙です、それは、存在しているかもしれないししていないかもしれない値を表わすために使われます。あらゆる型は、オプショナル型であるとして明示的に宣言される（または暗黙的に変換される）ことができます。オプショナルの変数またはプロパティを宣言する時にあなたが最初の値を提供しないならば、その値は自動的に省略時のnilになります。

If an instance of an optional type contains a value, you can access that value using the postfix operator !, as shown below: オプショナル型のインスタンスが値を含むならば、あなたが接尾辞演算子!を使用してその値にアクセスすることができます、以下に示すように：

Using the ! operator to unwrap an optional that has a value of nil results in a runtime error. !演算子を使ってnilの値を持つあるオプショナルをアンラップすることは、実行時エラーの結果になります。

You can also use optional chaining and optional binding to conditionally perform an operation on an optional expression. If the value is nil, no operation is performed and therefore no runtime error is produced. あなたはまたオプショナル連鎖とオプショナル束縛を使って、あるオプショナルの式に関して演算を条件付きで実行することができます。その値がnilならば、演算は実行されません、したがって、実行時エラーは生じません。

For more information and to see examples that show how to use optional types, see Optionals. より多くの情報のために、そしてオプショナル型を使う方法を示す例を見るために、オプショナルを見てください。

Implicitly Unwrapped Optional Type¶ 暗黙的にアンラップされるオプショナルの型¶

The Swift language defines the postfix ! as syntactic sugar for the named type Optional<Wrapped>, which is defined in the Swift standard library, with the additional behavior that it’s automatically unwrapped when it’s accessed. If you try to use an implicitly unwrapped optional that has a value of nil, you’ll get a runtime error. With the exception of the implicit unwrapping behavior, the following two declarations are equivalent: スウィフト言語は、接尾辞!を糖衣構文としてスウィフト標準ライブラリで定義される名前付きの型Optional<Wrapped>に対して定義します、それはそれがアクセスされるとき自動的にアンラップされるという追加の挙動を含みます。あなたがnilの値を持つ暗黙的にアンラップされるオプショナルを使うことを試みるならば、あなたは実行時エラーを得るでしょう。暗黙的にアンラップされる挙動を除けば、以下の２つの宣言は等しいです：

Note that no whitespace may appear between the type and the !. 空白が型と!の間に現れないことに注意してください。

Because implicit unwrapping changes the meaning of the declaration that contains that type, optional types that are nested inside a tuple type or a generic type—such as the element types of a dictionary or array—can’t be marked as implicitly unwrapped. For example: 暗黙的にアンラップされることがその型を含む宣言の意味することを変えることから、タプル型や総称体型の内部に入れ子にされたオプショナル型—例えば辞書や配列に属する要素型など—は、暗黙的にアンラップされるように印されることはできません。例えば：

Because implicitly unwrapped optionals have the same Optional<Wrapped> type as optional values, you can use implicitly unwrapped optionals in all the same places in your code that you can use optionals. For example, you can assign values of implicitly unwrapped optionals to variables, constants, and properties of optionals, and vice versa. 暗黙的にアンラップされるオプショナルがオプショナル値と同じOptional<Wrapped>型を持つことから、あなたは、あなたのコードにおいてあなたがオプショナルを使うことができるのと同じ場所すべてで暗黙的にアンラップされるオプショナルを使うことができます。たとえば、あなたは暗黙的にアンラップされるオプショナルの値を、オプショナルの変数、定数、そしてプロパティに代入することができます、その逆もまたできます。

As with optionals, if you don’t provide an initial value when you declare an implicitly unwrapped optional variable or property, its value automatically defaults to nil. オプショナルと同様に、あなたが暗黙的にアンラップされるオプショナルの変数やプロパティに初期値を提供しないならば、その値は自動的に省略時のnilになります。

Use optional chaining to conditionally perform an operation on an implicitly unwrapped optional expression. If the value is nil, no operation is performed and therefore no runtime error is produced. ある暗黙的にアンラップされるオプショナルの式に関して演算を条件付きで実行するために、オプショナル連鎖を使ってください。その値がnilならば、演算は実行されません、したがって、実行時エラーは生じません。

For more information about implicitly unwrapped optional types, see Implicitly Unwrapped Optionals. 暗黙的にアンラップされるオプショナル型の詳細については、暗黙的にアンラップされるオプショナルを見てください。

Protocol Composition Type¶ プロトコル合成型¶

A protocol composition type defines a type that conforms to each protocol in a list of specified protocols, or a type that’s a subclass of a given class and conforms to each protocol in a list of specified protocols. Protocol composition types may be used only when specifying a type in type annotations, in generic parameter clauses, and in generic where clauses. プロトコル合成型が定義するのは、指定されたプロトコルのリストの中の各プロトコルに準拠する型、または指定されたクラスのサブクラスであるそして指定されたプロトコルのリストの中の各プロトコルに準拠する型です。プロトコル合成型は、型注釈において、総称体パラメータ節において、そして総称体where節において型を指定する場合にのみ使われるでしょう。

Protocol composition types have the following form: プロトコル合成型は、以下の形式を持ちます：

A protocol composition type allows you to specify a value whose type conforms to the requirements of multiple protocols without explicitly defining a new, named protocol that inherits from each protocol you want the type to conform to. For example, you can use the protocol composition type ProtocolA & ProtocolB & ProtocolC instead of declaring a new protocol that inherits from ProtocolA, ProtocolB, and ProtocolC. Likewise, you can use SuperClass & ProtocolA instead of declaring a new protocol that’s a subclass of SuperClass and conforms to ProtocolA. プロトコル合成型は、あなたにそれの型が複数のプロトコルに属する要件に準拠するある値を、あなたがその型に準拠して欲しいプロトコル各々から継承する名前をつけられたある新しいプロトコルを明示的に定義する必要なしに指定させます。例えば、プロトコル合成型ProtocolA & ProtocolB & ProtocolCを使うことが、ProtocolA、ProtocolB、そしてProtocolCから継承する新しいプロトコルを宣言する代わりに行えます。同様に、あなたはSuperClass & ProtocolAを使うことが、SuperClassのサブクラスでProtocolAに準拠する新しいプロトコルを宣言する代わりに行えます。

Each item in a protocol composition list is one of the following; the list can contain at most one class: プロトコル合成リストの各項目は以下のうちの１つです；リストは最大１つのクラスを含むことができます：

• The name of a class あるクラスの名前
• The name of a protocol あるプロトコルの名前
• A type alias whose underlying type is a protocol composition type, a protocol, or a class. それの基礎をなす型がプロトコル合成型、プロトコル、またはクラスである型エイリアス。

When a protocol composition type contains type aliases, it’s possible for the same protocol to appear more than once in the definitions—duplicates are ignored. For example, the definition of PQR in the code below is equivalent to P & Q & R. あるプロトコル合成型が型エイリアスを含む場合、同じプロトコルが複数回定義の中に現れることが可能です — 重複は無視されます。例えば、以下のコードでのPQRの定義は、P & Q & Rと同等です。

Opaque Type¶ 不透明型¶

An opaque type defines a type that conforms to a protocol or protocol composition, without specifying the underlying concrete type. 不透明型は、あるプロトコルまたはプロトコル合成に準拠するある型を定義します、基礎をなす具象型を指定することなしに。

Opaque types appear as the return type of a function or subscript, or the type of a property. Opaque types can’t appear as part of a tuple type or a generic type, such as the element type of an array or the wrapped type of an optional. 不透明型は、関数または添え字の戻り型、またはあるプロパティの型として現れます。不透明型は、タプル型または総称体型の一部として現れることができません、たとえば配列の要素型、またはオプショナルのラップ型などの。

Opaque types have the following form: 不透明型は以下の形式を持ちます：

The constraint is a class type, protocol type, protocol composition type, or Any. A value can be used as an instance of the opaque type only if it’s an instance of a type that conforms to the listed protocol or protocol composition, or inherits from the listed class. Code that interacts with an opaque value can use the value only in ways that are part of the interface defined by the constraint. constraint（制約）は、クラス型、プロトコル型、プロトコル合成型、またはAnyです。値は、不透明型のインスタンスとして使われることが、それが、そのリストされたプロトコルまたはプロトコル合成に準拠する、またはリストされたクラスから継承するある型のインスタンスである場合にのみ、可能です。不透明型と相互作用するコードは、constraintによって定義されるインターフェイスの一部であるやり方それらにおいてのみ値を使うことができます。

Protocol declarations can’t include opaque types. Classes can’t use an opaque type as the return type of a nonfinal method. プロトコル宣言は、不透明型を含むことはできません。クラスは、不透明型を非最終メソッドの戻り型として使用できません。

A function that uses an opaque type as its return type must return values that share a single underlying type. The return type can include types that are part of the function’s generic type parameters. For example, a function someFunction<T>() could return a value of type T or Dictionary<String, T>. 不透明型をそれの戻り型として使う関数は、ある単一の基礎をなす型を共有する値を返さなければなりません。戻り型は、関数のもつ総称体型パラメータの一部である型を定義含むことができます。例えば、関数someFunction<T>()は、型TまたはDictionary<String, T>の値を返すことができました。

Metatype Type¶ メタタイプ型¶

A metatype type refers to the type of any type, including class types, structure types, enumeration types, and protocol types. あるメタタイプ型は、クラス型、構造体型、列挙型、そしてプロトコル型を含む、何らかの型のその型に言及します。

The metatype of a class, structure, or enumeration type is the name of that type followed by .Type. The metatype of a protocol type—not the concrete type that conforms to the protocol at runtime—is the name of that protocol followed by .Protocol. For example, the metatype of the class type SomeClass is SomeClass.Type and the metatype of the protocol SomeProtocol is SomeProtocol.Protocol. あるクラス、構造体、または列挙型のメタタイプは、その型の名前に.Typeが続くものです。あるプロトコル型 ― 実行時にそのプロトコルに準拠する具象型ではない ― のメタタイプは、そのプロトコルの名前に.Protocolが続くものです。例えば、クラス型SomeClassのメタタイプはSomeClass.Typeです、そして、プロトコルSomeProtocolのメタタイプはSomeProtocol.Protocolです。

You can use the postfix self expression to access a type as a value. For example, SomeClass.self returns SomeClass itself, not an instance of SomeClass. And SomeProtocol.self returns SomeProtocol itself, not an instance of a type that conforms to SomeProtocol at runtime. You can call the type(of:) function with an instance of a type to access that instance’s dynamic, runtime type as a value, as the following example shows: あなたは、接尾辞self式を使って、ある型に値としてアクセスすることができます。例えば、SomeClass.selfは、SomeClass自身を返します、SomeClassのインスタンスではなく。そして、SomeProtocol.selfは、SomeProtocol自身を返します、実行時にSomeProtocolに準拠するある型のインスタンスではなく。あなたは、ある型のインスタンスを使ってtype(of:)関数を呼び出して、そのインスタンスの持つ動的な、実行時の型にひとつの値としてアクセスできます、以下の例で示すように：

For more information, see type(of:) in the Swift standard library. 詳細は、type(of:)をスウィフト標準ライブラリで見てください。

Use an initializer expression to construct an instance of a type from that type’s metatype value. For class instances, the initializer that’s called must be marked with the required keyword or the entire class marked with the final keyword. イニシャライザ式を使って、ある型のインスタンスをその型のメタタイプ値から組み立ててください。クラスインスタンスに対しては、呼び出されるイニシャライザがrequiredキーワードで印されるか、クラス全体がfinalキーワードで印されなければなりません。

Any Type¶ Any型¶

The Any type can contain values from all other types. Any can be used as the concrete type for an instance of any of the following types: Any型は、全ての他の型からの値を含むことができます。Anyは、具象型として以下の型の何れかのインスタンスに対して使用できます：

• A class, structure, or enumeration クラス、構造体、または列挙
• A metatype, such as Int.self メタタイプ、たとえばInt.self
• A tuple with any types of components 何らかの型の構成要素をもつタプル
• A closure or function type クロージャまたは関数型。

When you use Any as a concrete type for an instance, you need to cast the instance to a known type before you can access its properties or methods. Instances with a concrete type of Any maintain their original dynamic type and can be cast to that type using one of the type-cast operators—as, as?, or as!. For example, use as? to conditionally downcast the first object in a heterogeneous array to a String as follows: あなたがAnyを具象型としてインスタンスに対して使う場合、あなたはそのインスタンスを既知の型へとキャストすることを、あなたがそれのプロパティまたはメソッドにアクセスする前に必要とします。Anyの具象型をもつインスタンスは、それらの本来の動的型を管理します、そして型キャスト演算子—as、as?、またはas!を使ってその型へとキャストできます。例えば、as?を使うことで、ある雑多な配列の中の最初のオブジェクトをStringオブジェクトへと、条件付きでダウンキャストしてください、以下のように：

For more information about casting, see Type Casting. キャストについてのさらなる情報として、型キャストを見てください。

The AnyObject protocol is similar to the Any type. All classes implicitly conform to AnyObject. Unlike Any, which is defined by the language, AnyObject is defined by the Swift standard library. For more information, see Class-Only Protocols and AnyObject. AnyObjectプロトコルは、Any型に似ています。全てのクラスは、暗黙的にAnyObjectに準拠します。言語によって定義されるAnyとは違い、AnyObjectはSwift標準ライブラリによって定義されます。さらなる情報として、クラス専用プロトコルとAnyObjectを見てください。

Self Type¶ Self型¶

The Self type isn’t a specific type, but rather lets you conveniently refer to the current type without repeating or knowing that type’s name. Self型は、特定の型ではありません、しかしいくぶんあなたに便利に現在の型を参照させます、その型の名前を繰り返すことまたは知ることなしに。

In a protocol declaration or a protocol member declaration, the Self type refers to the eventual type that conforms to the protocol. プロトコル宣言またはプロトコルメンバー宣言において、Self型は、そのプロトコルに準拠する結果として起こる型を参照します。

In a structure, class, or enumeration declaration, the Self type refers to the type introduced by the declaration. Inside the declaration for a member of a type, the Self type refers to that type. In the members of a class declaration, Self can appear only as follows: 構造体、クラス、または列挙宣言において、Self型は、その宣言によって導入される型を参照します。ある型のメンバーに対する宣言の内部で、Self型は、その型を参照します。クラス宣言のメンバーにおいて、Selfは以下のようにのみ現れることができます：

• As the return type of a method メソッドの戻り型として
• As the return type of a read-only subscript 読出し専用添え字の戻り型として
• As the type of a read-only computed property 読出し専用の計算プロパティの型として
• In the body of a method メソッドの本文において

For example, the code below shows an instance method f whose return type is Self. 例えば、以下のコードはインスタンスメソッドfを示します、それの戻り型はSelfです。

The last part of the example above shows that Self refers to the runtime type Subclass of the value of z, not the compile-time type Superclass of the variable itself. 上の例の最後の部分は、Selfがzの値のランタイム型Subclassを参照することを示します、変数それ自体のコンパイル時型Superclassではなく。

Inside a nested type declaration, the Self type refers to the type introduced by the innermost type declaration. 入れ子にされた型宣言の内部で、Self型は、最も内側の型宣言によって導入された型を参照します。

The Self type refers to the same type as the type(of:) function in the Swift standard library. Writing Self.someStaticMember to access a member of the current type is the same as writing type(of: self).someStaticMember. Self型は、スウィフト標準ライブラリの中のtype(of:)関数と同じ型を参照します。Self.someStaticMemberを書いて現在の型のあるメンバーにアクセスすることは、type(of: self).someStaticMemberを書くことと同じです。

Type Inheritance Clause¶ 型継承節¶

A type inheritance clause is used to specify which class a named type inherits from and which protocols a named type conforms to. A type inheritance clause begins with a colon (:), followed by a list of type identifiers. ある型継承節は、ある名前付きの型が継承するのはどのクラスからか、およびある名前付きの型が準拠するのはどのプロトコルに対してかを指定するために使われます。型継承節はコロン（:）で始まり、型識別子のリストが続きます。

Class types can inherit from a single superclass and conform to any number of protocols. When defining a class, the name of the superclass must appear first in the list of type identifiers, followed by any number of protocols the class must conform to. If the class doesn’t inherit from another class, the list can begin with a protocol instead. For an extended discussion and several examples of class inheritance, see Inheritance. クラス型は、１つのスーパークラスから継承することができ、任意の数のプロトコルに準拠することができます。クラスを定義するとき、スーパークラスの名前は型識別子のリストにおいて最初に現れなければなりません、そしてそのクラスが準拠しなければならないいくらかのプロトコルが続きます。クラスが別のクラスから継承しないならば、このリストは代わりにプロトコルで始まることが出来ます。クラス継承の広範囲にわたる議論といくつかの例のために、継承を見てください。

Other named types can only inherit from or conform to a list of protocols. Protocol types can inherit from any number of other protocols. When a protocol type inherits from other protocols, the set of requirements from those other protocols are aggregated together, and any type that inherits from the current protocol must conform to all of those requirements. 他の名前付きの型は、プロトコルのリストから継承し準拠することだけができます。プロトコル型は、いくらかの他のプロトコルから継承することができます。プロトコル型が他のプロトコルから継承するとき、それらの他のプロトコルからの要件ひとそろいは一緒にまとめられます、そして、現在のプロトコルから継承するどんな型でもそれらの要件の全てに準拠しなければなりません。

A type inheritance clause in an enumeration definition can be either a list of protocols, or in the case of an enumeration that assigns raw values to its cases, a single, named type that specifies the type of those raw values. For an example of an enumeration definition that uses a type inheritance clause to specify the type of its raw values, see Raw Values. 列挙定義における型継承節は、プロトコルのリスト、または生の値をそれのケース節に割り当てる列挙のケース節においては、それらの生の値を指定する単一の名前付き型、このどちらかであることができます。その生の値の型を指定するために型継承節を使う列挙定義の例のために、生の値を見てください。

Type Inference¶ 型推論¶

Swift uses type inference extensively, allowing you to omit the type or part of the type of many variables and expressions in your code. For example, instead of writing var x: Int = 0, you can write var x = 0, omitting the type completely—the compiler correctly infers that x names a value of type Int. Similarly, you can omit part of a type when the full type can be inferred from context. For example, if you write let dict: Dictionary = ["A": 1], the compiler infers that dict has the type Dictionary<String, Int>. スウィフトは広く型推論を使います、そして、あなたのコードにおいて多くの変数および式の型または型の一部をあなたが省略できるようにします。例えば、var x: Int = 0を書く代わりに、あなたは型を完全に省略してvar x = 0と書くことができます ― コンパイラは、xが型Intの値に名をつけると正しく推測します。同じように、前後関係から完全に型が推論されることができるとき、あなたはある型の一部を省略することができます。たとえば、あなたがlet dict: Dictionary = ["A": 1]を書くならば、コンパイラはdictが型Dictionary<String, Int>を持つと推測します。

In both of the examples above, the type information is passed up from the leaves of the expression tree to its root. That is, the type of x in var x: Int = 0 is inferred by first checking the type of 0 and then passing this type information up to the root (the variable x). 上の例の両方とも、型情報は、式ツリーの葉っぱから、その根までさかのぼって渡されます。すなわち、var x: Int = 0の中のxの型は、最初に0の型を調べて、それからこの型情報を根（変数x）までさかのぼって渡すことによって推論されます。

In Swift, type information can also flow in the opposite direction—from the root down to the leaves. In the following example, for instance, the explicit type annotation (: Float) on the constant eFloat causes the numeric literal 2.71828 to have an inferred type of Float instead of Double. スウィフトでは、型情報は逆方向にも流れます ― 根から下って葉っぱまで。例えば、以下の例において、定数eFloatでの明示的な型注釈（: Float）は、数値リテラル2.71828をFloatの推論される型を持つようにします、Doubleではなく。

Type inference in Swift operates at the level of a single expression or statement. This means that all of the information needed to infer an omitted type or part of a type in an expression must be accessible from type-checking the expression or one of its subexpressions. スウィフトの型推論は、単一の式や文の水準で働きます。これは、ある式における省略される型や型の一部分を推論するために必要とされる情報のすべては、型を調べているその式またはそれの下位式の１つからアクセス可能でなければならないことを意味します。