Declarations¶ 宣言¶

Top-Level Code¶ トップレベル・コード¶

The top-level code in a Swift source file consists of zero or more statements, declarations, and expressions. By default, variables, constants, and other named declarations that are declared at the top-level of a source file are accessible to code in every source file that’s part of the same module. You can override this default behavior by marking the declaration with an access-level modifier, as described in Access Control Levels. あるスウィフトソースコードにおけるトップレベル・コードは、０個以上の文、宣言、そして式から成ります。初期状態では、あるソースファイルのトップレベルで宣言される変数、定数、そして他の名前をつけられる宣言は、同じモジュールの一部であるすべてのソースファイルの中のコードにアクセス可能です。あなたは、アクセス制御ラベルで記述されるように、この初期状態のふるまいをその宣言をアクセス水準修飾子で印することによってオーバーライドすることができます。

There are two kinds of top-level code: top-level declarations and executable top-level code. Top-level declarations consist of only declarations, and are allowed in all Swift source files. Executable top-level code contains statements and expressions, not just declarations, and is allowed only as the top-level entry point for the program. ２つの種類のトップレベルコードがあります：トップレベル宣言と実行可能トップレベルコード。トップレベル宣言は、宣言それらからのみ構成されます、そしてスウィフトソースファイルにおいて許可されます。実行可能トップレベルコードは、文と式を含みます、宣言だけでなく、そしてプログラムのトップレベルエントリポイントとしてのみ許可されます。

The Swift code you compile to make an executable can contain at most one of the following approaches to mark the top-level entry point, regardless of how the code is organized into files and modules: the main attribute, the NSApplicationMain attribute, the UIApplicationMain attribute, a main.swift file, or a file that contains top-level executable code. あなたがコンパイルして実行可能にするスウィフトコードは、トップレベルエントリポイントを印するために次の進入口のうち最大で１つを含むことができます、どのコードがファイルおよびモジュールに組織化されるかに関係になく：main属性、NSApplicationMain属性、UIApplicationMain属性、main.swiftファイル、またはトップレベル実行コードを含むファイル。

Code Blocks¶ コード・ブロック¶

A code block is used by a variety of declarations and control structures to group statements together. It has the following form: コード・ブロックは、いくつかの文をまとめるために、いろいろな宣言や制御構造で使われます。それは、以下の形式を持ちます：

The statements inside a code block include declarations, expressions, and other kinds of statements and are executed in order of their appearance in source code. コード・ブロックの内側の文は、宣言、式、そして他の種類の文を含みます、そしてソース・コードにおいてそれらの現れる順に実行されます。

Import Declaration¶ インポート宣言¶

An import declaration lets you access symbols that are declared outside the current file. The basic form imports the entire module; it consists of the import keyword followed by a module name: インポート宣言は、あなたに現在のファイルの外側で宣言されるシンボルにアクセスさせます。基本の形式は、そのモジュール全体をインポートします；それは、importキーワードとそれに続くモジュール名から成ります：

Providing more detail limits which symbols are imported—you can specify a specific submodule or a specific declaration within a module or submodule. When this detailed form is used, only the imported symbol (and not the module that declares it) is made available in the current scope. より詳細な記述を提供することは、どのシンボルがインポートされるかを制限します ― あなたは、あるモジュールまたはサブモジュール内で、特定のサブモジュールまたは特定の宣言を指定することができます。この詳細な書式が使われるとき、インポートされたシンボルだけが（そしてそれを宣言するモジュールでなく）、現在のスコープにおいて利用可能にされます。

Constant Declaration¶ 定数宣言¶

A constant declaration introduces a constant named value into your program. Constant declarations are declared using the let keyword and have the following form: 定数宣言は、名前をつけられた一定不変の値をあなたのプログラムにもたらします。定数宣言は、letキーワードを使用して宣言され、以下の形式を持ちます：

A constant declaration defines an immutable binding between the constant name and the value of the initializer expression; after the value of a constant is set, it can’t be changed. That said, if a constant is initialized with a class object, the object itself can change, but the binding between the constant name and the object it refers to can’t. 定数宣言は、定数名とイニシャライザ式の値の間の不変の束縛を定義します；定数の値が設定されたあと、それは変更されることができません。そうは言っても、定数がクラスオブジェクトで初期化されるならば、そのオブジェクト自体は変わることができます、しかし、定数名とそれが言及するオブジェクトの間の束縛はそうすることができません。

When a constant is declared at global scope, it must be initialized with a value. When a constant declaration occurs in the context of a function or method, it can be initialized later, as long as it’s guaranteed to have a value set before the first time its value is read. If the compiler can prove that the constant’s value is never read, the constant isn’t required to have a value set at all. When a constant declaration occurs in the context of a class or structure declaration, it’s considered a constant property. Constant declarations aren’t computed properties and therefore don’t have getters or setters. 定数がグローバルなスコープで宣言されるとき、それはひとつの値で初期化されなければなりません。定数宣言が関数またはメソッドの文脈において現れるとき、それは後で初期化されることができます、それがある値をその値が読み出される最初の時の前に設定されてしまっているよう保証する限りは。定数のもつ値が決して読み出されないことをコンパイラが立証できるならば、定数は値を設定されることを全く要求されません。定数宣言がクラスまたは構造体宣言の文脈において起こるとき、それは定数プロパティとみなされます。定数宣言は、計算プロパティではなく、したがって、ゲッターまたはセッターを持ちません。

If the constant name of a constant declaration is a tuple pattern, the name of each item in the tuple is bound to the corresponding value in the initializer expression. 定数宣言の定数名がタプルパターンであるならば、タプルの中の各項目の名前は、イニシャライザ式の中の対応する値に縛りつけられます。

In this example, firstNumber is a named constant for the value 10, and secondNumber is a named constant for the value 42. Both constants can now be used independently: この例では、firstNumberは、値10のための名前をつけられた定数です、そして、secondNumberは値42のための名前をつけられた定数です。両方の定数は、今や独立して使われることができます：

The type annotation (: type) is optional in a constant declaration when the type of the constant name can be inferred, as described in Type Inference. 定数名の型が推論されることができるとき、型推論で記述されるように、型注釈（: type）は定数宣言において任意です。

To declare a constant type property, mark the declaration with the static declaration modifier. A constant type property of a class is always implicitly final; you can’t mark it with the class or final declaration modifier to allow or disallow overriding by subclasses. Type properties are discussed in Type Properties. 定数型プロパティを宣言するために、宣言にstatic宣言修飾子で印をつけてください。あるクラスの定数型プロパティは、常に暗黙的に最終的なものです；あなたはそれをclassまたはfinal宣言修飾子で印できません、またはサブクラスによるオーバーライドを許可したり不許可にしたりできません。型プロパティは、型プロパティで記述されます。

For more information about constants and for guidance about when to use them, see Constants and Variables and Stored Properties. 定数の詳細について、そしていつそれらを使うべきかの手引きとして、定数と変数および格納プロパティを見てください。

Variable Declaration¶ 変数の宣言¶

A variable declaration introduces a variable named value into your program and is declared using the var keyword. 変数宣言は、名前をつけられた変えられる値をあなたのプログラムにもたらします、そしてキーワードvarを使って宣言されます。

Variable declarations have several forms that declare different kinds of named, mutable values, including stored and computed variables and properties, stored variable and property observers, and static variable properties. The appropriate form to use depends on the scope at which the variable is declared and the kind of variable you intend to declare. 変数宣言はいくつかの形式を持ちます、それらは、格納および計算の変数およびプロパティ、格納である変数およびプロパティのオブザーバー、そして静的変数プロパティを含む、異なる種類の名前をつけられた可変の値を宣言します。使用するのに適切な形式は、その変数が宣言されるスコープとあなたが宣言するつもりである変数の種類に依存します。

You can override a property in a subclass by marking the subclass’s property declaration with the override declaration modifier, as described in Overriding. あなたは、オーバーライドで記述されるように、サブクラスのプロパティ宣言をoverride宣言修飾子で印することによってサブクラスの中のプロパティをオーバーライドすることができます。

Type Alias Declaration¶ 型エイリアス宣言¶

A type alias declaration introduces a named alias of an existing type into your program. Type alias declarations are declared using the typealias keyword and have the following form: 型エイリアス宣言は、あなたのプログラムに既存の型の名前をつけられたエイリアスを導入します。型エイリアス宣言は、キーワードtypealiasを使って宣言されます、そして以下の形式を持ちます：

After a type alias is declared, the aliased name can be used instead of the existing type everywhere in your program. The existing type can be a named type or a compound type. Type aliases don’t create new types; they simply allow a name to refer to an existing type. 型エイリアスが宣言されたあと、エイリアス（別名）にされた名前は、あなたのプログラムの至る所で既存の型の代わりに使われることができます。既存の型は、名前付きの型または複合の型でありえます。型エイリアスは、新しい型を作成しません；それらは、単にある名前が既存の型に言及できるようにします。

A type alias declaration can use generic parameters to give a name to an existing generic type. The type alias can provide concrete types for some or all of the generic parameters of the existing type. For example: 型エイリアス宣言は、総称体パラメータを使ってある名前を既存の総称体型に与えることができます。型エイリアスは、既存の型の総称体パラメータの一部またはすべてに具象型を提供できます。例えば：

When a type alias is declared with generic parameters, the constraints on those parameters must match exactly the constraints on the existing type’s generic parameters. For example: ある型エイリアスが総称体パラメータで宣言されるとき、それらのパラメータ上の制約は厳密に既存の型の持つ総称体パラメータ上の制約に一致しなければなりません。例えば：

Because the type alias and the existing type can be used interchangeably, the type alias can’t introduce additional generic constraints. 型エイリアスと既存の型は交換可能に使われることができるので、型エイリアスは追加的な総称体制約を導入することはできません。

A type alias can forward an existing type’s generic parameters by omitting all generic parameters from the declaration. For example, the Diccionario type alias declared here has the same generic parameters and constraints as Dictionary. 型エイリアスは、既存の型の持つ総称体パラメータを、全ての総称体パラメータを宣言から省略することによって、転送できます。例えば、ここで宣言されるDiccionario型エイリアスは、Dictionaryと同じ総称体パラメータと制約を持ちます。

Inside a protocol declaration, a type alias can give a shorter and more convenient name to a type that’s used frequently. For example: プロトコル宣言の内部で、型エイリアスはより短くより便利な名前を頻繁に使われる型に提供できます。例えば：

Without this type alias, the sum function would have to refer to the associated type as T.Iterator.Element instead of T.Element. この型エイリアスな時では、sum関数は関連値をT.Iterator.Elementのように参照しなければならないでしょう、T.Elementではなく。

See also Protocol Associated Type Declaration. また、プロトコル関連型宣言を見てください。

Function Declaration¶ 関数宣言¶

A function declaration introduces a function or method into your program. A function declared in the context of class, structure, enumeration, or protocol is referred to as a method. Function declarations are declared using the func keyword and have the following form: 関数宣言は、あなたのプログラムに関数またはメソッドをもたらします。クラス、構造体、列挙、またはプロトコルの文脈において宣言される関数は、メソッドとして言及されることができます。関数宣言は、キーワードfuncを使って宣言されます、そして以下の形式を持ちます：

If the function has a return type of Void, the return type can be omitted as follows: 関数がVoidの戻り型を持つならば、次のように戻り型は省略されることができます：

The type of each parameter must be included—it can’t be inferred. If you write inout in front of a parameter’s type, the parameter can be modified inside the scope of the function. In-out parameters are discussed in detail in In-Out Parameters, below. 各パラメータの型は、含められなければなりません ― それは、推論されることができません。あなたがinoutをパラメータの型のすぐ前に書くならば、そのパラメータは関数のスコープ内部において修正されることができます。in-outパラメータは詳細に、下で、in-outパラメータにおいて議論されます。

A function declaration whose statements include only a single expression is understood to return the value of that expression. This implicit return syntax is considered only when the expression’s type and the function’s return type aren’t Void and aren’t an enumeration like Never that doesn’t have any cases. それのstatementsがただ１つの式だけを含む関数宣言は、その式の値を返すものと理解されます。この暗黙的な戻り構文は、式のもつ型と関数のもつ戻り型がVoidでないそして何らケース節を持たないNeverのような列挙ではない場合にのみ考慮されます。

Functions can return multiple values using a tuple type as the return type of the function. 関数は、関数の戻り型としてタプル型を使って、複数の値を返すことができます。

A function definition can appear inside another function declaration. This kind of function is known as a nested function. 関数定義は、別の関数宣言の内部に現れることができます。この種類の関数は、入れ子にされた関数として知られています。

A nested function is nonescaping if it captures a value that’s guaranteed to never escape—such as an in-out parameter—or passed as a nonescaping function argument. Otherwise, the nested function is an escaping function. 入れ子にされた関数は、もしそれが、決して脱出しないことを保証される値を — たとえばin-outパラメータ — または非脱出関数引数として渡される値をキャプチャするならば非脱出です。それ以外では、入れ子にされた関数は脱出関数です。

For a discussion of nested functions, see Nested Functions. 入れ子にされた関数の議論のために、入れ子にされた関数を見てください。

Enumeration Declaration¶ 列挙宣言¶

An enumeration declaration introduces a named enumeration type into your program. 列挙宣言は、名前をつけられた列挙型をあなたのプログラムに導入します。

Enumeration declarations have two basic forms and are declared using the enum keyword. The body of an enumeration declared using either form contains zero or more values—called enumeration cases—and any number of declarations, including computed properties, instance methods, type methods, initializers, type aliases, and even other enumeration, structure, class, and actor declarations. Enumeration declarations can’t contain deinitializer or protocol declarations. 列挙宣言は、２つの基本の形式を持ち、キーワードenumを使って宣言されます。どちらの形式を使って宣言される列挙宣言の本文でも、０以上の値 ― 列挙ケース節と呼ばれるもの ― および任意の数の宣言から成っていて、計算プロパティ、インスタンスメソッド、型メソッド、イニシャライザ、型エイリアス、そして他の列挙、構造体、クラス、およびアクター宣言さえも含められます。列挙宣言は、デイニシャライザまたはプロトコル宣言を含むことができません。

Enumeration types can adopt any number of protocols, but can’t inherit from classes, structures, or other enumerations. 列挙型は、任意の数のプロトコルに準拠することができます、しかしクラス、構造体、または他の列挙から継承することはできません。

Unlike classes and structures, enumeration types don’t have an implicitly provided default initializer; all initializers must be declared explicitly. Initializers can delegate to other initializers in the enumeration, but the initialization process is complete only after an initializer assigns one of the enumeration cases to self. クラスや構造体と違って、列挙型には、暗黙のうちに提供される省略時のイニシャライザがありません；全てのイニシャライザは、明確に宣言されなければなりません。イニシャライザは、その列挙の中の他のイニシャライザに委任することができます、しかしその初期化処理はあるイニシャライザが列挙ケース節のうちの１つをselfに代入した後になって初めて終了します。

Like structures but unlike classes, enumerations are value types; instances of an enumeration are copied when assigned to variables or constants, or when passed as arguments to a function call. For information about value types, see Structures and Enumerations Are Value Types. 構造体のように、しかしクラスとは違い、列挙は値型です；列挙のインスタンスは、変数や定数に代入されるとき、または引数として関数呼び出しに渡されるときにコピーされます。値型に関して詳しくは、構造体と列挙は値型ですを見てください。

You can extend the behavior of an enumeration type with an extension declaration, as discussed in Extension Declaration. あなたは列挙型の挙動を拡張宣言を使って拡張できます、拡張宣言で議論されるように。

Structure Declaration¶ 構造体宣言¶

A structure declaration introduces a named structure type into your program. Structure declarations are declared using the struct keyword and have the following form: 構造体宣言は、名前をつけられた構造体型をあなたのプログラムに導入します。構造体宣言は、キーワードstructを使って宣言されて、以下の形式を持ちます：

The body of a structure contains zero or more declarations. These declarations can include both stored and computed properties, type properties, instance methods, type methods, initializers, subscripts, type aliases, and even other structure, class, actor, and enumeration declarations. Structure declarations can’t contain deinitializer or protocol declarations. For a discussion and several examples of structures that include various kinds of declarations, see Structures and Classes. 構造の本文は、０以上の宣言を含みます。これらの宣言は、格納または計算プロパティの双方、型プロパティ、インスタンスメソッド、型メソッド、イニシャライザ、添え字、型エイリアス、そして他の構造体、クラス、アクター、および列挙宣言さえも含むことができます。構造宣言は、デイニシャライザまたはプロトコル宣言を含むことができません。議論および、さまざまな種類の宣言を含む構造体の例のいくつかのために、構造体とクラスを見てください。

Structure types can adopt any number of protocols, but can’t inherit from classes, enumerations, or other structures. 構造体型は、随意の数のプロトコルに準拠することができます、しかしクラス、列挙、または他の構造体から継承することはできません。

There are three ways to create an instance of a previously declared structure: 以前に宣言された構造体のインスタンスを作成するには３つの方法があります：

• Call one of the initializers declared within the structure, as described in Initializers. その構造体の内部で宣言されるイニシャライザの内の１つを呼び出してください、イニシャライザで記述されるように。
• If no initializers are declared, call the structure’s memberwise initializer, as described in Memberwise Initializers for Structure Types. イニシャライザが宣言されないならば、その構造体のメンバー関連イニシャライザを呼び出してください、構造型のためのメンバー関連イニシャライザで記述されるように。
• If no initializers are declared, and all properties of the structure declaration were given initial values, call the structure’s default initializer, as described in Default Initializers. イニシャライザが宣言されない、そしてその構造体宣言の全てのプロパティが初期値を与えられたならば、構造体の省略時のイニシャライザを呼び出してください、省略時のイニシャライザで記述されるように。

The process of initializing a structure’s declared properties is described in Initialization. ある構造体のもつ宣言されたプロパティを初期化する過程は、初期化で記述されます。

Properties of a structure instance can be accessed using dot (.) syntax, as described in Accessing Properties. クラスインスタンスのプロパティはドット（.）構文でアクセスされることができます、プロパティにアクセスするで記述されるように。

Structures are value types; instances of a structure are copied when assigned to variables or constants, or when passed as arguments to a function call. For information about value types, see Structures and Enumerations Are Value Types. 構造体は、値型です；構造体のインスタンスは、変数や定数に代入される時、または引数として関数呼び出しに渡される時にコピーされます。値型に関して詳しくは、構造体と列挙は値型ですを見てください。

You can extend the behavior of a structure type with an extension declaration, as discussed in Extension Declaration. あなたはある構造体型の挙動を拡張宣言を使って拡張できます、拡張宣言で議論されるように。

Class Declaration¶ クラス宣言¶

A class declaration introduces a named class type into your program. Class declarations are declared using the class keyword and have the following form: クラス宣言は、名前をつけられたクラス型をあなたのプログラムに導入します。クラス宣言は、キーワードclassを使用して宣言されて、以下の形式を持ちます：

The body of a class contains zero or more declarations. These declarations can include both stored and computed properties, instance methods, type methods, initializers, a single deinitializer, subscripts, type aliases, and even other class, structure, actor, and enumeration declarations. Class declarations can’t contain protocol declarations. For a discussion and several examples of classes that include various kinds of declarations, see Structures and Classes. クラスの本文は、０個以上の宣言を含みます。これらの宣言は、格納または計算プロパティの双方、インスタンスメソッド、型メソッド、イニシャライザ、１つだけのデイニシャライザ、添え字、型エイリアス、そして他のクラス、構造体、アクター、および列挙宣言さえも含むことができます。クラス宣言は、プロトコル宣言を含むことができません。議論および、さまざまな種類の宣言を含むクラスの例のいくつかのために、構造体とクラスを見てください。

A class type can inherit from only one parent class, its superclass, but can adopt any number of protocols. The superclass appears first after the class name and colon, followed by any adopted protocols. Generic classes can inherit from other generic and nongeneric classes, but a nongeneric class can inherit only from other nongeneric classes. When you write the name of a generic superclass class after the colon, you must include the full name of that generic class, including its generic parameter clause. クラス型は、ただ１つの親クラス、それのスーパークラスから継承することだけが許されます、しかし随意の数のプロトコルに準拠することはできます。スーパークラスがまずクラス名とコロンの後に現れ、続いて随意の採用プロトコルが続きます。総称体クラスは、他の総称体および非総称体クラスから継承することができます、しかし非総称体クラスはただ他の非総称体クラスからのみ継承することができます。あなたがコロンの後に総称体スーパークラスの名前を書く時、あなたはその総称体クラスの名前全体を、それの総称体パラメーター節を含めて書く必要があります。

As discussed in Initializer Declaration, classes can have designated and convenience initializers. The designated initializer of a class must initialize all of the class’s declared properties and it must do so before calling any of its superclass’s designated initializers. イニシャライザ宣言で議論されるように、クラスは、指定および便宜イニシャライザを持つことができます。あるクラスの指定イニシャライザは、そのクラスのもつ宣言されたプロパティのすべてを初期化しなければ成りません、そしてそれは何であれそれのスーパークラスの指定イニシャライザを呼ぶ前にそうしなければなりません。

A class can override properties, methods, subscripts, and initializers of its superclass. Overridden properties, methods, subscripts, and designated initializers must be marked with the override declaration modifier. クラスは、それのスーパークラスのプロパティ、メソッド、添え字、そしてイニシャライザをオーバーライドすることができます。プロパティ、メソッド、添え字、そして指定イニシャライザのオーバーライドは、override宣言修飾子で印されなければなりません。

To require that subclasses implement a superclass’s initializer, mark the superclass’s initializer with the required declaration modifier. The subclass’s implementation of that initializer must also be marked with the required declaration modifier. あるスーパークラスの持つイニシャライザをそのサブクラスそれらが実装することを要求するために、そのスーパークラスのイニシャライザをrequired宣言修飾子で印してください。そのイニシャライザのサブクラスの実装もまた、required宣言修飾子で印されなければなりません。

Although properties and methods declared in the superclass are inherited by the current class, designated initializers declared in the superclass are only inherited when the subclass meets the conditions described in Automatic Initializer Inheritance. Swift classes don’t inherit from a universal base class. スーパークラスの中で宣言されるプロパティやメソッドは現在のクラスによって継承されるけれども、スーパークラスの中で宣言される指定イニシャライザはただサブクラスが自動的なイニシャライザ継承で記述される条件と出会う場合に継承されるだけです。スウィフトのクラスそれらは、ひとつの共通の基盤クラスから継承はしません。

There are two ways to create an instance of a previously declared class: 以前に宣言されたクラスのインスタンスをつくるには２つの方法があります：

• Call one of the initializers declared within the class, as described in Initializers. そのクラス内で宣言されるイニシャライザのうちの１つを呼び出してください、イニシャライザで記述されるように。
• If no initializers are declared, and all properties of the class declaration were given initial values, call the class’s default initializer, as described in Default Initializers. イニシャライザが宣言されない、そしてそのクラス宣言の全てのプロパティが初期値を与えられたならば、クラスの省略時のイニシャライザを呼び出してください、省略時のイニシャライザで記述されるように。

Access properties of a class instance with dot (.) syntax, as described in Accessing Properties. クラスインスタンスのプロパティはドット（.）構文でアクセスしてください、プロパティにアクセスするで記述されるように。

Classes are reference types; instances of a class are referred to, rather than copied, when assigned to variables or constants, or when passed as arguments to a function call. For information about reference types, see Classes Are Reference Types. クラスは、参照型です；クラスのインスタンスは、変数または定数に代入されるとき、または引数として関数呼び出しに渡されるときに、コピーされるのではなく、参照されます。参照型に関して詳しくは、クラスは参照型ですを見てください。

You can extend the behavior of a class type with an extension declaration, as discussed in Extension Declaration. あなたはクラス型の挙動を拡張宣言を使って拡張できます、拡張宣言で議論されるように。

Actor Declaration¶ アクター宣言¶

An actor declaration introduces a named actor type into your program. Actor declarations are declared using the actor keyword and have the following form: アクター宣言は、名前をつけられたアクター型をあなたのプログラムに導入します。アクター宣言は、actorキーワードを使用して宣言され、以下の形式を持ちます：

The body of an actor contains zero or more declarations. These declarations can include both stored and computed properties, instance methods, type methods, initializers, a single deinitializer, subscripts, type aliases, and even other class, structure, and enumeration declarations. For a discussion and several examples of actors that include various kinds of declarations, see Actors. アクターの本文は、０個以上の宣言を含みます。これらの宣言は、格納または計算プロパティの双方、インスタンスメソッド、型メソッド、イニシャライザ、１つだけのデイニシャライザ、添え字、型エイリアス、そして他のクラス、構造体、および列挙宣言さえも含むことができます。いろいろな種類の宣言を含むアクターの解説といくつかの例のために、アクターを見てください。

Actor types can adopt any number of protocols, but can’t inherit from classes, enumerations, structures, or other actors. However, an actor that is marked with the @objc attribute implicitly conforms to the NSObjectProtocol protocol and is exposed to the Objective-C runtime as a subtype of NSObject. アクター型は、随意の数のプロトコルに準拠することができます、しかしクラス、列挙、構造体、または他のアクターから継承することはできません。しかしながら、@objc属性で印されるアクターは、暗黙的にNSObjectProtocolプロトコルに準拠します、そしてObjective-C runtimeへとNSObjectの下位型として暴露されます。

There are two ways to create an instance of a previously declared actor: 以前に宣言されたアクターのインスタンスをつくるには２つの方法があります：

• Call one of the initializers declared within the actor, as described in Initializers. そのアクターの内部で宣言されるイニシャライザの内の１つを呼び出してください、イニシャライザで記述されるように。
• If no initializers are declared, and all properties of the actor declaration were given initial values, call the actor’s default initializer, as described in Default Initializers. イニシャライザが宣言されない、そしてそのアクター宣言の全てのプロパティが初期値を与えられたならば、アクターの省略時のイニシャライザを呼び出してください、省略時のイニシャライザで記述されるように。

By default, members of an actor are isolated to that actor. Code, such as the body of a method or the getter for a property, is executed on that actor. Code within the actor can interact with them synchronously because that code is already running on the same actor, but code outside the actor must mark them with await to indicate that this code is asynchronously running code on another actor. Key paths can’t refer to isolated members of an actor. Actor-isolated stored properties can be passed as in-out parameters to synchronous functions, but not to asynchronous functions. 初期状態では、あるアクターのメンバーそれらはそのアクターへと隔離されます。コード、たとえばあるメソッドの本体またはあるプロパティのゲッターなどは、そのアクター上で遂行されます。アクター内部のコードは、それらと同期的に相互作用できます、なぜならそのコードは既に同じアクター上で動作しているからです、しかしアクターの外側のコードは、それらをawaitで印して、そのコードが別のアクター上で非同期に動作しているコードであることを指し示さなければなりません。キーバスは、あるアクターの隔離されたメンバーそれらを参照できません。アクター隔離された格納プロパティは、in-outパラメータとして同期関数へと渡されることができます、しかし非同期関数へとはできません。

Actors can also have nonisolated members, whose declarations are marked with the nonisolated keyword. A nonisolated member executes like code outside of the actor: It can’t interact with any of the actor’s isolated state, and callers don’t mark it with await when using it. アクターはまた、非隔離メンバーを持つことができます、それの宣言はnonisolatedキーワードで印されます。非隔離メンバーは、アクターの外側のコードのように遂行します：それはアクターのもつ隔離された状態のどれとも相互作用できません、そして呼び出し側は、それを使う時にそれをawaitで印しません。

Members of an actor can be marked with the @objc attribute only if they are nonisolated or asynchronous. アクターのメンバーそれらが、@objc属性で印されることが可能なのは、それらが隔離されないまたは非同期である場合だけです。

The process of initializing an actor’s declared properties is described in Initialization. あるアクターのもつ宣言されたプロパティを初期化する過程は、初期化で記述されます。

Properties of a actor instance can be accessed using dot (.) syntax, as described in Accessing Properties. アクターインスタンスのプロパティはドット（.）構文でアクセスされることができます、プロパティにアクセスするで記述されるように。

Actors are reference types; instances of an actor are referred to, rather than copied, when assigned to variables or constants, or when passed as arguments to a function call. For information about reference types, see Classes Are Reference Types. アクターは、参照型です；アクターのインスタンスは、変数または定数に代入されるとき、または引数として関数呼び出しに渡されるときに、コピーされるのではなく、参照されます。参照型に関して詳しくは、クラスは参照型ですを見てください。

You can extend the behavior of a structure type with an extension declaration, as discussed in Extension Declaration. あなたはある構造体型の挙動を拡張宣言を使って拡張できます、拡張宣言で議論されるように。

Protocol Declaration¶ プロトコル宣言¶

A protocol declaration introduces a named protocol type into your program. Protocol declarations are declared at global scope using the protocol keyword and have the following form: プロトコル宣言は、名前をつけられたプロトコル型をあなたのプログラムに導入します。プロトコル宣言は、グローバルなスコープでキーワードprotocolを使って宣言されて、以下の形式を持ちます：

The body of a protocol contains zero or more protocol member declarations, which describe the conformance requirements that any type adopting the protocol must fulfill. In particular, a protocol can declare that conforming types must implement certain properties, methods, initializers, and subscripts. Protocols can also declare special kinds of type aliases, called associated types, that can specify relationships among the various declarations of the protocol. Protocol declarations can’t contain class, structure, enumeration, or other protocol declarations. The protocol member declarations are discussed in detail below. プロトコルの本文は０以上のプロトコルメンバー宣言を含みます、それは、プロトコルを採用しているすべての型が満たさなければならない準拠要件を記述します。特に、プロトコルは、準拠している型が特定のプロパティ、メソッド、イニシャライザ、そして添え字を実装しなければならないと宣言することができます。プロトコルはまた、特別な種類の型エイリアス、そのプロトコルのいろいろな宣言の間での関係を指定することができる関連型と呼ばれるものを宣言することができます。プロトコル宣言は、クラス、構造体、列挙、または他のプロトコル宣言を含むことができません。プロトコルメンバー宣言は、詳細に下で議論されます。

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, and any type that inherits from the current protocol must conform to all those requirements. For an example of how to use protocol inheritance, see Protocol Inheritance. プロトコル型は、いくらかの他のプロトコルから継承することができます。あるプロトコル型が他のプロトコルから継承するとき、それらの他のプロトコルからの要件一式は、ひとまとめにされます、そして現在のプロトコルから継承するどんな型でも、それらの要件の全てに従わなければなりません。プロトコル継承を使う方法の例のために、プロトコル継承を見てください。

You can add protocol conformance to a previously declared type by adopting the protocol in an extension declaration of that type. In the extension, you must implement all of the adopted protocol’s requirements. If the type already implements all of the requirements, you can leave the body of the extension declaration empty. あなたは、プロトコル準拠を以前に宣言された型に加えることが、その型の拡張宣言においてそのプロトコルを採用することによってできます。拡張において、あなたは採用されたプロトコルの要件の全てを実装しなければなりません。その型が要件の全てをすでに実装するならば、あなたは拡張宣言の本文を空のままにしておいてかまいません。

By default, types that conform to a protocol must implement all properties, methods, and subscripts declared in the protocol. That said, you can mark these protocol member declarations with the optional declaration modifier to specify that their implementation by a conforming type is optional. The optional modifier can be applied only to members that are marked with the objc attribute, and only to members of protocols that are marked with the objc attribute. As a result, only class types can adopt and conform to a protocol that contains optional member requirements. For more information about how to use the optional declaration modifier and for guidance about how to access optional protocol members—for example, when you’re not sure whether a conforming type implements them—see Optional Protocol Requirements. 初期状態では、あるプロトコルに準拠する型は、そのプロトコルにおいて宣言される全てのプロパティ、メソッド、そして添え字を実装しなければなりません。とは言え、 あなたはこれらのプロトコルメンバー宣言をoptional宣言修飾子を使って印して、ある準拠型にとってそれらの実装が随意であると指定することができます。optional修飾子は、objc属性で印されるメンバーにだけ、そしてobjc属性で印されるプロトコルのメンバーにだけ適用されることができます。結果として、クラス型だけがオプショナルメンバー要件を含むプロトコルを採用および準拠することができます。optional宣言修飾子を働かせる方法に関する詳細は、そして、オプショナルのプロトコルメンバーにアクセスする方法 ― 例えば、ある準拠している型がそれらを実装するかどうかについてあなたが確信が持てない時など ― についての手引きとしてオプショナルのプロトコル要件を見てください。

The cases of an enumeration can satisfy protocol requirements for type members. Specifically, an enumeration case without any associated values satisfies a protocol requirement for a get-only type variable of type Self, and an enumeration case with associated values satisfies a protocol requirement for a function that returns Self whose parameters and their argument labels match the case’s associated values. For example: 列挙のケース節は、型メンバーに対するプロトコル要件を満たすことができます。とりわけ、どんな関連値を持たない列挙ケース節は、型Selfのある取得専用の型変数に対するプロトコル要件を満たします、そして関連値を持つ列挙ケース節は、Selfを返すある関数に対するプロトコル要件を満たします、それは、それのもつパラメータそれらとそれらの引数ラベルがケース節のもつ関連値それらと合致するものです。例えば：

To restrict the adoption of a protocol to class types only, include the AnyObject protocol in the inherited protocols list after the colon. For example, the following protocol can be adopted only by class types: あるプロトコルの採用をクラス型のみに制約するには、AnyObjectプロトコルを継承されたプロトコルのリストの中にコロンの後で加えてください。例えば、以下のプロトコルはクラス型によってのみ採用されることができます：

Any protocol that inherits from a protocol that’s marked with the AnyObject requirement can likewise be adopted only by class types. AnyObject要件で印されるプロトコルから継承するどんなプロトコルも、同じようにクラス型でのみ採用されることができます。

Protocols are named types, and thus they can appear in all the same places in your code as other named types, as discussed in Protocols as Types. However, you can’t construct an instance of a protocol, because protocols don’t actually provide the implementations for the requirements they specify. プロトコルは名前をつけられた型です、したがってそれらはあなたのコードにおいて他の名前をつけられた型と同じ場所の全てにおいて現れることができます、型としてのプロトコルで議論されるように。しかし、あなたはプロトコルからインスタンスを造ることができません、なぜならプロトコルは実際にはそれらが指定する要件に対する実装を用意しないからです。

You can use protocols to declare which methods a delegate of a class or structure should implement, as described in Delegation. あなたはプロトコルを使って、あるクラスまたは構造体から委任を受ける側が実装しなければならないのはどのメソッドかを宣言することができます、委任で記述されるように。

Initializer Declaration¶ イニシャライザ宣言¶

An initializer declaration introduces an initializer for a class, structure, or enumeration into your program. Initializer declarations are declared using the init keyword and have two basic forms. イニシャライザ宣言は、あなたのプログラムにクラス、構造体、または列挙のためのイニシャライザを導入します。イニシャライザ宣言は、キーワードinitを使って宣言されて、２つの基本の書式を持ちます。

Structure, enumeration, and class types can have any number of initializers, but the rules and associated behavior for class initializers are different. Unlike structures and enumerations, classes have two kinds of initializers: designated initializers and convenience initializers, as described in Initialization. 構造体、列挙、そしてクラス型は、随意の数のイニシャライザを持つことができます、しかし、クラスイニシャライザのための規則および関連する挙動は異なります。構造体や列挙と違って、クラスは２種類のイニシャライザを持ちます：指定イニシャライザと便宜イニシャライザ、初期化で記述されるように。

The following form declares initializers for structures, enumerations, and designated initializers of classes: 以下の形式は、構造体、列挙のイニシャライザ、そしてクラスの指定イニシャライザを宣言します：

A designated initializer of a class initializes all of the class’s properties directly. It can’t call any other initializers of the same class, and if the class has a superclass, it must call one of the superclass’s designated initializers. If the class inherits any properties from its superclass, one of the superclass’s designated initializers must be called before any of these properties can be set or modified in the current class. あるクラスの指定イニシャライザは、直接そのクラスのプロパティの全てを初期化します。それは同じクラスの他のどのイニシャライザも呼ぶことができません、そしてそのクラスがスーパークラスを持つならば、それはスーパークラスの指定イニシャライザのうちの１つを呼ばなければなりません。クラスが何らかのプロパティをそのスーパークラスから受け継ぐならば、これらのプロパティのどれかが現在のクラスにおいて設定または修正されることができる前に、スーパークラスの指定イニシャライザのうちの１つが呼ばれなければなりません。

Designated initializers can be declared in the context of a class declaration only and therefore can’t be added to a class using an extension declaration. 指定イニシャライザは、クラス宣言の文脈においてのみ宣言されることができて、したがって拡張宣言を使ってあるクラスに加えられることはできません。

Initializers in structures and enumerations can call other declared initializers to delegate part or all of the initialization process. 構造体および列挙のイニシャライザは、初期化プロセスの一部または全てを委任するために他の宣言済みイニシャライザを呼ぶことができます。

To declare convenience initializers for a class, mark the initializer declaration with the convenience declaration modifier. あるクラスの便宜イニシャライザを宣言するために、そのイニシャライザ宣言をconvenience宣言修飾子を使って印してください。

Convenience initializers can delegate the initialization process to another convenience initializer or to one of the class’s designated initializers. That said, the initialization processes must end with a call to a designated initializer that ultimately initializes the class’s properties. Convenience initializers can’t call a superclass’s initializers. 便宜イニシャライザは、初期化プロセスを別の便宜イニシャライザに、またはそのクラスの指定イニシャライザのうちの１つに委任することができます。とは言え、 初期化プロセスは、最終的にそのクラスのプロパティを初期化する指定イニシャライザに対する呼び出しで終わらなければなりません。便宜イニシャライザは、スーパークラスのイニシャライザを呼ぶことができません。

You can mark designated and convenience initializers with the required declaration modifier to require that every subclass implement the initializer. A subclass’s implementation of that initializer must also be marked with the required declaration modifier. あなたは指定および便宜イニシャライザをrequired宣言修飾子で印して、全てのサブクラスがそのイニシャライザを実装することが必須であるようにすることができます。そのイニシャライザのサブクラスでの実装は、また、required宣言修飾子で印されなければなりません。

By default, initializers declared in a superclass aren’t inherited by subclasses. That said, if a subclass initializes all of its stored properties with default values and doesn’t define any initializers of its own, it inherits all of the superclass’s initializers. If the subclass overrides all of the superclass’s designated initializers, it inherits the superclass’s convenience initializers. 初期状態では、スーパークラスで宣言されるイニシャライザは、サブクラスによって継承されません。とは言え、サブクラスがそれの格納プロパティのすべてを省略時の値で初期化して、それ自身のイニシャライザを全く定義しないならば、それはそのスーパークラスのイニシャライザのすべてを継承します。サブクラスがスーパークラスの指定イニシャライザのすべてをオーバーライドするならば、それはスーパークラスの便宜イニシャライザそれらを継承します。

As with methods, properties, and subscripts, you need to mark overridden designated initializers with the override declaration modifier. メソッド、プロパティ、そして添え字と同様に、あなたはオーバーライドした指定イニシャライザをoverride宣言修飾子で印する必要があります。

Just like functions and methods, initializers can throw or rethrow errors. And just like functions and methods, you use the throws or rethrows keyword after an initializer’s parameters to indicate the appropriate behavior. 関数やメソッドのように、イニシャライザはエラーをスローまたは再スローできます。そして関数やメソッドのように、あなたはthrowsまたはrethrowsキーワードをイニシャライザのパラメータの後に使って、ふさわしい挙動を指し示すことができます。

To see examples of initializers in various type declarations, see Initialization. いろいろな型宣言におけるイニシャライザの例を見るために、初期化を見てください。

Deinitializer Declaration¶ デイニシャライザ宣言¶

A deinitializer declaration declares a deinitializer for a class type. Deinitializers take no parameters and have the following form: デイニシャライザ宣言は、クラス型のためにデイニシャライザを宣言します。デイニシャライザは、パラメータを取らない以下の形式を持ちます：

A deinitializer is called automatically when there are no longer any references to a class object, just before the class object is deallocated. A deinitializer can be declared only in the body of a class declaration—but not in an extension of a class—and each class can have at most one. デイニシャライザは、あるクラスオブジェクトに対するいかなる参照ももはやない時、そのクラスオブジェクトが割り当て解除される直前に、自動的に呼ばれます。デイニシャライザは、クラス宣言の本文においてのみ ― しかしクラスの拡張においてではなく ― 宣言されることができます、そして各クラスが多くとも１つしか持つことができません。

A subclass inherits its superclass’s deinitializer, which is implicitly called just before the subclass object is deallocated. The subclass object isn’t deallocated until all deinitializers in its inheritance chain have finished executing. サブクラスはそのスーパークラスのデイニシャライザを継承します、それは、サブクラスオブジェクトが割り当て解除される直前に、暗黙のうちに呼ばれます。サブクラスオブジェクトは、その継承連鎖の中の全てのデイニシャライザが実行を終えるまで、割り当て解除されません。

Deinitializers aren’t called directly. デイニシャライザは、直接に呼ばれません。

For an example of how to use a deinitializer in a class declaration, see Deinitialization. クラス宣言においてデイニシャライザを使う方法の例のために、デイニシャライズを見てください。

Extension Declaration¶ 拡張宣言¶

An extension declaration allows you to extend the behavior of existing types. Extension declarations are declared using the extension keyword and have the following form: 拡張宣言があなたに可能にするのは、既存の型の挙動を拡張することです。拡張宣言は、キーワードextensionキーワードを使って宣言され、以下の形式を持ちます：

The body of an extension declaration contains zero or more declarations. These declarations can include computed properties, computed type properties, instance methods, type methods, initializers, subscript declarations, and even class, structure, and enumeration declarations. Extension declarations can’t contain deinitializer or protocol declarations, stored properties, property observers, or other extension declarations. Declarations in a protocol extension can’t be marked final. For a discussion and several examples of extensions that include various kinds of declarations, see Extensions. 拡張宣言の本文は、０個以上の宣言を含みます。これらの宣言は、計算プロパティ、計算型プロパティ、インスタンスメソッド、型メソッド、イニシャライザ、添え字宣言、そしてクラス、構造体、そして列挙宣言さえも含むことができます。拡張宣言は、デイニシャライザまたはプロトコル宣言、格納プロパティ、プロパティオブザーバー、または他の拡張宣言を含むことができません。プロトコル拡張の中の宣言は、finalで印されることができません。いろいろな種類の宣言を含む拡張の解説といくつかの例のために、拡張を見てください。

If the type name is a class, structure, or enumeration type, the extension extends that type. If the type name is a protocol type, the extension extends all types that conform to that protocol. type nameがクラス、構造体、または列挙型ならば、その拡張はその型を拡張します。type nameがプロトコル型ならば、その拡張はそのプロトコルに準拠するすべての型を拡張します。

Extension declarations that extend a generic type or a protocol with associated types can include requirements. If an instance of the extended type or of a type that conforms to the extended protocol satisfies the requirements, the instance gains the behavior specified in the declaration. 総称体型またはプロトコルを関連型で拡張する拡張宣言は、requirements いくつかの要件を含むことができます。拡張された型のまたは拡張されたプロトコルに準拠する型のインスタンスがrequirements 要件を満たすならば、そのインスタンスは宣言において指定される挙動を獲得します。

Extension declarations can contain initializer declarations. That said, if the type you’re extending is defined in another module, an initializer declaration must delegate to an initializer already defined in that module to ensure members of that type are properly initialized. 拡張宣言は、イニシャライザ宣言を含むことができます。とは言え、 あなたが拡張している型が別のモジュールにおいて定義されるならば、イニシャライザ宣言はそのモジュールですでに定義されるイニシャライザに委任して、その型のメンバーが正しく初期化されることを確実にしなければなりません。

Properties, methods, and initializers of an existing type can’t be overridden in an extension of that type. 既存の型のプロパティ、メソッド、そしてイニシャライザは、その型の拡張においてオーバーライドされることができません。

Extension declarations can add protocol conformance to an existing class, structure, or enumeration type by specifying adopted protocols: 拡張宣言は、プロトコル準拠を既存のクラス、構造体、または列挙型に加えることが採用プロトコルを指定することによって可能です：

Extension declarations can’t add class inheritance to an existing class, and therefore you can specify only a list of protocols after the type name and colon. 拡張宣言は、クラス継承を既存のクラスに加えることができません、従ってあなたは幾らかのプロトコルからなるリストのみをtype name 型名とコロンの後に指定することができます。

Subscript Declaration¶ 添え字宣言¶

A subscript declaration allows you to add subscripting support for objects of a particular type and are typically used to provide a convenient syntax for accessing the elements in a collection, list, or sequence. Subscript declarations are declared using the subscript keyword and have the following form: 添え字宣言は、特定の型のオブジェクトに対する添え字サポートを付け加えることをあなたに可能にして、コレクション、リスト、またはシーケンスの中の要素にアクセスするための便利な構文を提供するために概して使われます。添え字宣言は、キーワードsubscriptを使って宣言されて、以下の形式を持ちます：

Subscript declarations can appear only in the context of a class, structure, enumeration, extension, or protocol declaration. 添え字宣言は、クラス、構造体、列挙、拡張、またはプロトコル宣言の文脈においてだけ、現れることができます。

The parameters specify one or more indexes used to access elements of the corresponding type in a subscript expression (for example, the i in the expression object[i]). Although the indexes used to access the elements can be of any type, each parameter must include a type annotation to specify the type of each index. The return type specifies the type of the element being accessed. パラメータは、対応する型の要素にアクセスするために添え字式において使用する一種類以上のインデックスを指定します（例えば、式object[i]におけるiなど）。要素にアクセスするために使用されるインデックスは、どんな型でも可能であるけれども、各パラメータは型注釈を含んで、各インデックスの型を指定しなければなりません。戻り型は、アクセスされている要素の型を指定します。

As with computed properties, subscript declarations support reading and writing the value of the accessed elements. The getter is used to read the value, and the setter is used to write the value. The setter clause is optional, and when only a getter is needed, you can omit both clauses and simply return the requested value directly. That said, if you provide a setter clause, you must also provide a getter clause. 計算プロパティと同様に、添え字宣言はアクセスされた要素の値を読み書きすることをサポートします。ゲッターが値を読むために使われます、そしてセッターが値を書くために使われます。セッター節は任意です、そしてゲッターだけが必要なとき、あなたは両方の節を省略して、単に直接要請された値を返すことができます。とは言え、 あなたがセッター節を提供するならば、あなたはまたゲッター節も提供しなければなりません。

The setter name and enclosing parentheses are optional. If you provide a setter name, it’s used as the name of the parameter to the setter. If you don’t provide a setter name, the default parameter name to the setter is value. The type of the parameter to the setter is the same as the return type. セッター名と囲んでいる括弧は、任意です。あなたがセッター名を提供するならば、それがセッターにパラメータの名前として使われます。あなたがセッター名を提供しないならば、セッターへの省略時のパラメータ名はvalueです。セッターに対するパラメータの型は、return type（戻り型）と同じです。

You can overload a subscript declaration in the type in which it’s declared, as long as the parameters or the return type differ from the one you’re overloading. You can also override a subscript declaration inherited from a superclass. When you do so, you must mark the overridden subscript declaration with the override declaration modifier. あなたは、ある添え字宣言を、そこにおいてそれが宣言される型においてオーバーロードすることができます、パラメーターまたは戻り型があなたがオーバーロードしているものと異なる限りはです。あなたはまた、スーパークラスから継承した添え字宣言をオーバーライドすることができます。あなたがそうするとき、あなたはオーバーライドされる添え字宣言をoverride宣言修飾子で印しなければなりません。

Subscript parameters follow the same rules as function parameters, with two exceptions. By default, the parameters used in subscripting don’t have argument labels, unlike functions, methods, and initializers. However, you can provide explicit argument labels using the same syntax that functions, methods, and initializers use. In addition, subscripts can’t have in-out parameters. A subscript parameter can have a default value, using the syntax described in Special Kinds of Parameters. 添え字パラメータは、関数パラメータと同じ規則に従います、２つの例外で。初期状態で、添字において使用されるパラメータは引数ラベルを持ちません、関数、メソッド、およびイニシャライザとは違って。しかしながら、あなたは明示的に引数ラベルを提供することが、関数、メソッド、およびイニシャライザが使うのと同じ構文を使うことで可能です。加えて、添え字はin-outパラメータを持つことができません。添え字バラメータは省略時の値を持つことができます、特別な種類のパラメータで記述される構文を使います。

You can also declare subscripts in the context of a protocol declaration, as described in Protocol Subscript Declaration. プロトコル添え字宣言で記述されるように、あなたはまた、プロトコル宣言の文脈において添え字を宣言することができます。

For more information about subscripting and to see examples of subscript declarations, see Subscripts. 添え字に関するより多くの情報のために、そして、添え字宣言の例を見るために、添え字を見てください。

Operator Declaration¶ 演算子宣言¶

An operator declaration introduces a new infix, prefix, or postfix operator into your program and is declared using the operator keyword. 演算子宣言は、新しい接中辞、接頭辞、または接尾辞演算子をあなたのプログラムに導入します、そしてキーワードoperatorを使って宣言されます。

You can declare operators of three different fixities: infix, prefix, and postfix. The fixity of an operator specifies the relative position of an operator to its operands. あなたは、３つの異なる定着性の演算子を宣言することができます：接中辞、接頭辞、そして接尾辞。演算子の定着性は、その演算子の演算数に対する相対位置を指定します。

There are three basic forms of an operator declaration, one for each fixity. The fixity of the operator is specified by marking the operator declaration with the infix, prefix, or postfix declaration modifier before the operator keyword. In each form, the name of the operator can contain only the operator characters defined in Operators. 演算子宣言の基本の書式は、各定着性に対して１つずつ、３つあります。演算子の定着性は、演算子定義をoperatorキーワードの前にinfix、prefix、またはpostfix宣言修飾子を使って印することによって指定されます。各形式において、演算子の名前は演算子で定義される演算子文字だけを含むことができます。

The following form declares a new infix operator: 以下の形式は、新しい接中辞演算子を宣言します：

An infix operator is a binary operator that’s written between its two operands, such as the familiar addition operator (+) in the expression 1 + 2. 接中辞演算子は、それの２つ演算数の間で書かれる二項演算子です、例えば式1 + 2でのよく知られた加算演算子（+）など。

Infix operators can optionally specify a precedence group. If you omit the precedence group for an operator, Swift uses the default precedence group, DefaultPrecedence, which specifies a precedence just higher than TernaryPrecedence. For more information, see Precedence Group Declaration. 接中辞演算子は、任意に優先順位グループを指定することができます。あなたが優先順位グループを省略するならば、スウィフトは省略時の優先順位グループ、DefaultPrecedenceを使います、それはTernaryPrecedenceのすぐ上の優先順位を指定します。さらなる情報は、優先順位グループ定義を見てください。

The following form declares a new prefix operator: 以下の形式は、新しい接頭辞演算子を宣言します：

A prefix operator is a unary operator that’s written immediately before its operand, such as the prefix logical NOT operator (!) in the expression !a. 接頭辞演算子は単項演算子です、それはその演算数の直前に書かれます、例えば式!aでの論理否定演算子（!）など。

Prefix operators declarations don’t specify a precedence level. Prefix operators are nonassociative. 接頭辞演算子宣言は、優先順位レベルを指定しません。接頭辞演算子は非結合です。

The following form declares a new postfix operator: 以下の形式は、新しい接尾辞演算子を宣言します：

A postfix operator is a unary operator that’s written immediately after its operand, such as the postfix forced-unwrap operator (!) in the expression a!. 接尾辞演算子は単項演算子です、それはその演算数の直後に書かれます、例えば式a!での論理否定演算子（!）など。

As with prefix operators, postfix operator declarations don’t specify a precedence level. Postfix operators are nonassociative. 接頭辞演算子と同様に、接尾辞演算子宣言は、優先順位レベルを指定しません。接尾辞演算子は非結合です。

After declaring a new operator, you implement it by declaring a static method that has the same name as the operator. The static method is a member of one of the types whose values the operator takes as an argument—for example, an operator that multiplies a Double by an Int is implemented as a static method on either the Double or Int structure. If you’re implementing a prefix or postfix operator, you must also mark that method declaration with the corresponding prefix or postfix declaration modifier. To see an example of how to create and implement a new operator, see Custom Operators. ある新しい演算子を宣言した後に、あなたはその演算子と同じ名前を持つ静的メソッドを宣言することによってそれを実装します。この静的メソッドは、その演算子が引数としてとる値の型のうちの１つに属するあるメンバーです、例えばDoubleにIntを掛ける演算子は静的メソッドとしてDoubleまたはInt 構造体のどちらかで実装されます。あなたが接頭辞または接尾辞演算子を実装しているならば、あなたはまたそのメソッド宣言を対応するprefixまたはpostfix宣言修飾子で印をしなければなりません。新しい演算子の作成と実装の方法の例を見るには、あつらえの演算子を参照してください。

Precedence Group Declaration¶ 優先順位グループ定義¶

A precedence group declaration introduces a new grouping for infix operator precedence into your program. The precedence of an operator specifies how tightly the operator binds to its operands, in the absence of grouping parentheses. 優先順位グループは、接中辞演算子優先順位に対する新しいグループをあなたのプログラムへ導入します。ある演算子の優先順位は、どのくらいきつくその演算子をそれの演算数に束縛するかを、グループ化の丸括弧がないところで指定します。

A precedence group declaration has the following form: 優先順位グループ定義は、以下の形式を持ちます：

The lower group names and higher group names lists specify the new precedence group’s relation to existing precedence groups. The lowerThan precedence group attribute may only be used to refer to precedence groups declared outside of the current module. When two operators compete with each other for their operands, such as in the expression 2 + 3 * 5, the operator with the higher relative precedence binds more tightly to its operands. 下方グループ名および上方グループ名リストは、新しい優先順位グループのもつ関係を既存の優先順位グループに対して指定します。lowerThan優先順位グループ属性は、現在のモジュールの外側で宣言される優先順位グループを参照するのに使われるだけでしょう。２つの演算子がそれらの演算数に対して互いと比較される時、例えば式2 + 3 * 5などで、より高い関係優先順位を持つ演算子はよりきつくそれの演算数に束縛されます。

Swift defines numerous precedence groups to go along with the operators provided by the standard library. For example, the addition (+) and subtraction (-) operators belong to the AdditionPrecedence group, and the multiplication (*) and division (/) operators belong to the MultiplicationPrecedence group. For a complete list of precedence groups provided by the Swift standard library, see Operator Declarations. スウィフトは、標準ライブラリによって提供される演算子と一緒にやっていくために、多数の優先順位グループを定義します。例えば、加算（+）および減算（-）演算子は、AdditionPrecedenceグルーブに所属し、そして乗算（*）および減算（/）演算子はMultiplicationPrecedenceグルーブに属します。スウィフト標準ライブラリによって提供される優先順位グループの完全なリストとして、さまざまな演算子宣言を見てください。

The associativity of an operator specifies how a sequence of operators with the same precedence level are grouped together in the absence of grouping parentheses. You specify the associativity of an operator by writing one of the context-sensitive keywords left, right, or none—if your omit the associativity, the default is none. Operators that are left-associative group left-to-right. For example, the subtraction operator (-) is left-associative, so the expression 4 - 5 - 6 is grouped as (4 - 5) - 6 and evaluates to -7. Operators that are right-associative group right-to-left, and operators that are specified with an associativity of none don’t associate at all. Nonassociative operators of the same precedence level can’t appear adjacent to each to other. For example, the < operator has an associativity of none, which means 1 < 2 < 3 isn’t a valid expression. 演算子の結合性は、グループ括弧がない場合に同じ優先順位レベルを持つひと連なりの演算子がどのようにまとめられるかを指定します。あなたはある演算子の結合性を文脈依存キーワードleft、right、またはnoneのうちの１つを書くことによって指定します—あなたが結合性を省略するならば、初期状態はnoneです。左結合である演算子は、左から右へとグループにまとめられます。例えば、減算演算子（-）は左結合です、それで式4 - 5 - 6は(4 - 5) - 6のようにグループにされて、-7に評価されます。右結合の演算子は右から左にグループにされます、そしてnoneの関係性を指定される演算子は全く結合しません。同じ優先順位レベルを持つ非結合演算子は、互いに隣同士に現れることができません。例えば、<演算子は、noneの関係性を持ちます、それは1 < 2 < 3が有効な式でないことを意味します。

The assignment of a precedence group specifies the precedence of an operator when used in an operation that includes optional chaining. When set to true, an operator in the corresponding precedence group uses the same grouping rules during optional chaining as the assignment operators from the standard library. Otherwise, when set to false or omitted, operators in the precedence group follows the same optional chaining rules as operators that don’t perform assignment. 優先順位グループのassignmentは、オプショナル連鎖を含む演算において使われる時ある演算子の優先順位を指定します。trueに設定する場合、対応する優先順位グループの演算子は標準ライブラリ由来のassignment（割り当て）演算子と同じグループ化規則をオプショナル連鎖の間に使います。そうせずに、falseに設定するか省略する場合は、その優先順位グループの演算子は代入を実行しない演算子と同じオプショナル連鎖規則に従います。

Declaration Modifiers¶ 宣言修飾子¶

Declaration modifiers are keywords or context-sensitive keywords that modify the behavior or meaning of a declaration. You specify a declaration modifier by writing the appropriate keyword or context-sensitive keyword between a declaration’s attributes (if any) and the keyword that introduces the declaration. 宣言修飾子は、キーワードまたは文脈依存キーワードです、それは宣言のふるまいや意味することを修正します。あなたは、宣言修飾子を適切なキーワードまたは文脈依存キーワードを宣言の属性（もしあれば）と宣言を導入するキーワードとの間に書くことによって指定します。

class

Apply this modifier to a member of a class to indicate that the member is a member of the class itself, rather than a member of instances of the class. Members of a superclass that have this modifier and don’t have the final modifier can be overridden by subclasses. この修飾子をクラスのメンバーに適用して、そのメンバーがそのクラスそれ自身のメンバーであることを指し示してください、そのクラスのインスタンスのメンバーではなくて。この修飾子を持つそしてfinal修飾子を持たないスーパークラスのメンバーは、サブクラスによってオーバーライドされることができます。

dynamic

Apply this modifier to any member of a class that can be represented by Objective-C. When you mark a member declaration with the dynamic modifier, access to that member is always dynamically dispatched using the Objective-C runtime. Access to that member is never inlined or devirtualized by the compiler. この修飾子をObjective-Cによって表わされることのできるクラスのあらゆるメンバーに適用してください。あなたがメンバー宣言をdynamic修飾子で印する時は、そのメンバーへのアクセスは、常に動的にObjective-Cランタイムを使用してディスパッチされます。そのメンパーに対するアクセスは、決してコンパイラによってインラインまたはデバーチャライズされません。

Because declarations marked with the dynamic modifier are dispatched using the Objective-C runtime, they must be marked with the objc attribute. dynamic修飾子で印される宣言はObjective-Cランタイムを使ってディスパッチされるので、それらはobjc属性で印されなければなりません。

final

Apply this modifier to a class or to a property, method, or subscript member of a class. It’s applied to a class to indicate that the class can’t be subclassed. It’s applied to a property, method, or subscript of a class to indicate that a class member can’t be overridden in any subclass. For an example of how to use the final attribute, see Preventing Overrides. この修飾子をクラスに、またはプロパティ、メソッド、またはクラスの添え字メンバーに適用してください。それはクラスに適用されて、そのクラスがサブクラスを作られることができないのを指し示します。それはプロパティ、メソッド、またはクラスの添え字に適用されて、そのクラスメンバーがあらゆるサブクラスにおいてオーバーライドされることができないのを指し示します。final属性を使う方法の例として、オーバーライドを防ぐを見てください。

lazy

Apply this modifier to a stored variable property of a class or structure to indicate that the property’s initial value is calculated and stored at most once, when the property is first accessed. For an example of how to use the lazy modifier, see Lazy Stored Properties. この修飾子をクラスまたは構造体の格納変数プロパティに適用して、そのプロパティの初期値が最大でも一度だけ、そのプロパティが最初にアクセスされるときに、計算または格納されることを指し示してください。lazy修飾子を使う方法の例として、遅延格納プロパティを見てください。

optional

Apply this modifier to a protocol’s property, method, or subscript members to indicate that a conforming type isn’t required to implement those members. この修飾子をプロトコルのプロパティ、メソッド、または添え字メンバーに適用して、ある準拠型がそれらのメンバーを実装する必要がないことを指し示してください。

You can apply the optional modifier only to protocols that are marked with the objc attribute. As a result, only class types can adopt and conform to a protocol that contains optional member requirements. For more information about how to use the optional modifier and for guidance about how to access optional protocol members—for example, when you’re not sure whether a conforming type implements them—see Optional Protocol Requirements. あなたはoptional修飾子をobjc属性で印されるプロトコルだけに適用することができます。結果として、クラス型だけがオプショナルメンバー要件を含むプロトコルを採用および準拠することができます。optional修飾子を使う方法についての更なる情報のために、そしてオプショナルプロトコルメンバーにアクセスする方法についての手引きとして ― 例えば、あなたがある準拠型がそれらを実装するかどうか確信が持てない時など ― オプショナルのプロトコル要件を見てください。

required

Apply this modifier to a designated or convenience initializer of a class to indicate that every subclass must implement that initializer. The subclass’s implementation of that initializer must also be marked with the required modifier. この修飾子をクラスの必須または便宜イニシャライザに適用して、全てのサブクラスがそのイニシャライザを実装しなければならないことを指し示してください。このイニシャライザのサブクラスでの実装はまた、required修飾子で印されなければなりません。

static

Apply this modifier to a member of a structure, class, enumeration, or protocol to indicate that the member is a member of the type, rather than a member of instances of that type. In the scope of a class declaration, writing the static modifier on a member declaration has the same effect as writing the class and final modifiers on that member declaration. However, constant type properties of a class are an exception: static has its normal, nonclass meaning there because you can’t write class or final on those declarations. この修飾子を構造体、クラス、列挙、またはプロトコルのメンバーに適用して、そのメンバーがその型のメンバーであることを指し示してください、その型のインスタンスのメンバーではなくて。クラス宣言のスコープにおいて、static修飾子をメンバー宣言上で書くことは、classとfinal修飾子をそのメンバー宣言上で書くことと同じ効果を持ちます。しかしながら、クラスの定数型プロパティは例外です：staticはそれの通常の、非クラスの意味をそこで持ちません、なぜならあなたはclassまたはfinalをそれらの宣言上で書けないからです。

unowned

Apply this modifier to a stored variable, constant, or stored property to indicate that the variable or property has an unowned reference to the object stored as its value. If you try to access the variable or property after the object has been deallocated, a runtime error is raised. Like a weak reference, the type of the property or value must be a class type; unlike a weak reference, the type is non-optional. For an example and more information about the unowned modifier, see Unowned References. この修飾子を格納変数、定数、または格納プロパティに適用して、その変数またはプロパティがそれの値として格納されるオブジェクトに対して非所有参照を持つことを指し示してください。あなたが変数またはプロパティにそのオブジェクトがデアロケートされてしまった後にアクセスすることを試みるならば、実行時エラーが引き起こされます。弱い参照のように、プロパティや値の型はクラス型でなければなりません；弱い参照と違って、その型は非オプショナルです。unowned修飾子についての例とさらなる情報として、非所有参照を見てください。

unowned(safe)

An explicit spelling of unowned. unownedの明確なつづり方。

unowned(unsafe)

Apply this modifier to a stored variable, constant, or stored property to indicate that the variable or property has an unowned reference to the object stored as its value. If you try to access the variable or property after the object has been deallocated, you’ll access the memory at the location where the object used to be, which is a memory-unsafe operation. Like a weak reference, the type of the property or value must be a class type; unlike a weak reference, the type is non-optional. For an example and more information about the unowned modifier, see Unowned References. この修飾子を格納変数、定数、または格納プロパティに適用して、その変数またはプロパティがそれの値として格納されるオブジェクトに対して非所有参照を持つことを指し示してください。あなたが変数またはプロパティに、そのオブジェクトがデアロケートされてしまった後にアクセスすることを試みるならば、あなたはそのオブジェクトが存在するのに使われたところの位置でメモリにアクセスするでしょう、それはメモリ安全ではない操作です。弱い参照のように、プロパティや値の型はクラス型でなければなりません；弱い参照と違って、その型は非オプショナルです。unowned修飾子についての例とさらなる情報として、非所有参照を見てください。

weak

Apply this modifier to a stored variable or stored variable property to indicate that the variable or property has a weak reference to the object stored as its value. The type of the variable or property must be an optional class type. If you access the variable or property after the object has been deallocated, its value is nil. For an example and more information about the weak modifier, see Weak References. この修飾子を格納変数または格納変数プロパティに適用して、その変数またはプロパティがそれの値として格納されるオブジェクトに対して弱い参照を持つことを指し示してください。この変数またはプロパティの型はまた、オプショナルクラス型でなければなりません。あなたが変数またはプロパティにそのオブジェクトがデアロケートされてしまった後にアクセスするならば、それの値はnilです。weak修飾子についての例と更なる情報のために、弱い参照を見てください。