On This Page

Attributes 属性

There are two kinds of attributes in Swift—those that apply to declarations and those that apply to types. An attribute provides additional information about the declaration or type. For example, the discardableResult attribute on a function declaration indicates that, although the function returns a value, the compiler shouldn’t generate a warning if the return value is unused. スウィフトには２種類の属性があります — 宣言に適用されるもの、そして型に適用されるもの。属性は、宣言または型についての追加的な情報を提供します。例えば、ある関数宣言上でのdiscardableResult属性が指し示すのは、たとえその関数が値を返すとしても、コンパイラは戻り値が使われなくても警告を生成すべきでないということです。

You specify an attribute by writing the @ symbol followed by the attribute’s name and any arguments that the attribute accepts: あなたは、@記号に続いてその属性の名前そしてその属性が受け入れる任意の引数を書くことによって属性を指定します：

  1. @attribute name
  2. @attribute name(attribute arguments)

Some declaration attributes accept arguments that specify more information about the attribute and how it applies to a particular declaration. These attribute arguments are enclosed in parentheses, and their format is defined by the attribute they belong to. 若干の宣言属性は、属性に関するより多くの情報とそれが特定の宣言に適用される方法を指定する引数を受け入れます。これらの属性引数は丸括弧に囲まれます、そして、それらの形式はそれらが属している属性によって定義されます。

Declaration Attributes 宣言属性

You can apply a declaration attribute to declarations only. あなたは、宣言属性を宣言だけに適用することができます。

available

Apply this attribute to indicate a declaration’s life cycle relative to certain Swift language versions or certain platforms and operating system versions. この属性を適用することで、ある宣言の寿命を、特定のスウィフト言語バージョンまたは特定のプラットホームおよびオペレーティングシステムバージョンに相関的に指し示してください。

The available attribute always appears with a list of two or more comma-separated attribute arguments. These arguments begin with one of the following platform or language names: available属性は、常に２つ以上のコンマで区切られた属性引数とともに現れます。これらの引数は、以下のプラットホームまたは言語名の１つで始まります。

  • iOS
  • iOSApplicationExtension
  • macOS
  • macOSApplicationExtension
  • macCatalyst
  • macCatalystApplicationExtension
  • watchOS
  • watchOSApplicationExtension
  • tvOS
  • tvOSApplicationExtension
  • swift

You can also use an asterisk (*) to indicate the availability of the declaration on all of the platform names listed above. An available attribute that specifies availability using a Swift version number can’t use the asterisk. あなたはまた、アスタリスク（*）を使って上でリストされるプラットホーム名の全てでその宣言の有効性を指し示すことができます。スウィフトバージョン数を使って有効性を指定するavailable属性は、アスタリスクを使用できません。

The remaining arguments can appear in any order and specify additional information about the declaration’s life cycle, including important milestones. 残りの引数は、随意の順序で現れることができて、追加的な情報を宣言の寿命について、重要なマイルストーンを含めて指定します。

  • The unavailable argument indicates that the declaration isn’t available on the specified platform. This argument can’t be used when specifying Swift version availability. unavailable引数は、その宣言が指定されたプラットホーム上で利用可能でないことを指し示します。この引数は、スウィフトバージョン有効性を指定する時に使われることはできません。

  • The introduced argument indicates the first version of the specified platform or language in which the declaration was introduced. It has the following form: introduced引数は、そこにおいてその宣言が導入されたところの、指定されたプラットホームまたは言語の最初のバージョンを指し示します。それは、以下の形式を持ちます：

    1. introduced: version number

    The version number consists of one to three positive integers, separated by periods. バージョン番号は、ビリオドで区切られた、１つから３つの正の整数から成ります。

  • The deprecated argument indicates the first version of the specified platform or language in which the declaration was deprecated. It has the following form: deprecated引数は、そこにおいてその宣言が非推奨とされたところの、指定されたプラットホームまたは言語の最初のバージョンを指し示します。それは、以下の形式を持ちます：

    1. deprecated: version number

    The optional version number consists of one to three positive integers, separated by periods. Omitting the version number indicates that the declaration is currently deprecated, without giving any information about when the deprecation occurred. If you omit the version number, omit the colon (:) as well. 随意のバージョン番号は、ビリオドで区切られた、１つから３つの正の整数から成ります。バージョン番号の省略は、宣言が現れた時についてのどんな情報も与えることなく、その宣言が現在は非推奨であることを示します。あなたがこのバージョン番号を省略したならば、コロン（:）も同様に省いてください。

  • The obsoleted argument indicates the first version of the specified platform or language in which the declaration was obsoleted. When a declaration is obsoleted, it’s removed from the specified platform or language and can no longer be used. It has the following form: obsoleted引数は、そこにおいてその宣言が廃止とされたところの、指定されたプラットホームまたは言語の最初のバージョンを指し示します。ある宣言が廃止された場合は、それは指定されたプラットホームまたは言語から取り除かれます、そしてもはや使用されることはできません。それは、以下の形式を持ちます：

    1. obsoleted: version number

    The version number consists of one to three positive integers, separated by periods. バージョン番号は、ビリオドで区切られた、１つから３つの正の整数から成ります。

  • The message argument provides a textual message that the compiler displays when emitting a warning or error about the use of a deprecated or obsoleted declaration. It has the following form: message引数は、あるテキストメッセージを提供します、それはコンパイラが非推奨または廃止された宣言の使用についての警告またはエラーを発するときに表示するものです。それは、以下の形式を持ちます：

    1. message: message

    The message consists of a string literal. messageは、文字列リテラルから成ります。

  • The renamed argument provides a textual message that indicates the new name for a declaration that’s been renamed. The compiler displays the new name when emitting an error about the use of a renamed declaration. It has the following form: renamed引数は、あるテキストメッセージを提供します、それは改名された宣言に対する新しい名前を指し示すものです。コンパイラは、ある改名された宣言の使用についてのエラーを発するときにその新しい名前を表示します。それは、以下の形式を持ちます：

    1. renamed: new name

    The new name consists of a string literal. 新しい名前は文字列リテラルからなります。

    You can apply the available attribute with the renamed and unavailable arguments to a type alias declaration, as shown below, to indicate that the name of a declaration changed between releases of a framework or library. This combination results in a compile-time error that the declaration has been renamed. あなたは、available属性をrenamedおよびunavailable属性とともに型エイリアス宣言に対して使うことで、下で示されるように、ある宣言の名前がフレームワークまたはライブラリのリリースの間に変わったことを指し示せます。この連携は、宣言が改名されてしまっているというコンパイル時エラーという結果になります。

    1. // First release（最初のリリース）
    2. protocol MyProtocol {
    3. // protocol definition（プロトコル定義）
    4. }
    1. // Subsequent release renames MyProtocol（続くリリースでMyProtocolに改名する）
    2. protocol MyRenamedProtocol {
    3. // protocol definition（プロトコル定義）
    4. }
    6. @available(*, unavailable, renamed: "MyRenamedProtocol")
    7. typealias MyProtocol = MyRenamedProtocol

You can apply multiple available attributes on a single declaration to specify the declaration’s availability on different platforms and different versions of Swift. The declaration that the available attribute applies to is ignored if the attribute specifies a platform or language version that doesn’t match the current target. If you use multiple available attributes, the effective availability is the combination of the platform and Swift availabilities. あなたは、複数のavailable属性を単一の宣言上に適用することで、その宣言の有効性を異なるプラットホームおよび異なるバージョンのスウィフトに関して指定することができます。available属性を適用される宣言は、その属性が現在の対象と合致しないプラットホームまたは言語バージョンを指定するならば無視されます。あなたが複数のavailable属性を使うならば、有効な有効性はプラットホームとスウィフト有効性の組み合わせとなります。

If an available attribute only specifies an introduced argument in addition to a platform or language name argument, you can use the following shorthand syntax instead: available属性がただ１つのintroduced引数をプラットホームまたは言語名引数に加えて指定するならば、あなたは以下の略記構文が代わりに利用可能です：

  1. @available(platform name version number, *)
  2. @available(swift version number)

The shorthand syntax for available attributes concisely expresses availability for multiple platforms. Although the two forms are functionally equivalent, the shorthand form is preferred whenever possible. available属性のための略記構文は、複数のプラットホームに対する有効性を簡潔に表します。２つの書式は機能的に等しいですが、可能であればいつでも略記書式が好ましいです。

  1. @available(iOS 10.0, macOS 10.12, *)
  2. class MyClass {
  3. // class definition
  4. }

An available attribute that specifies availability using a Swift version number can’t additionally specify a declaration’s platform availability. Instead, use separate available attributes to specify a Swift version availability and one or more platform availabilities. スウィフトバージョン数を使って有効性を指定しているavailable属性は、ある宣言の持つプラットホーム有効性を追加的に指定することはできません。代わりに、available属性を使うことで、スウィフトバージョン有効性と１つ以上のプラットホーム有効性を指定してください。

  1. @available(swift 3.0.2)
  2. @available(macOS 10.12, *)
  3. struct MyStruct {
  4. // struct definition
  5. }

discardableResult

Apply this attribute to a function or method declaration to suppress the compiler warning when the function or method that returns a value is called without using its result. この属性を関数またはメソッド宣言に適用して、値を返す関数やメソッドがそれの結果を使うことなく呼び出された時にコンパイラが警告を発するのを抑制してください。

dynamicCallable

Apply this attribute to a class, structure, enumeration, or protocol to treat instances of the type as callable functions. The type must implement either a dynamicallyCall(withArguments:) method, a dynamicallyCall(withKeywordArguments:) method, or both. この属性をクラス、構造体、列挙、またはプロトコルに適用することで、その型のインスタンスをcallable関数として扱ってください。その型は、dynamicallyCall(withArguments:)、dynamicallyCall(withKeywordArguments:)メソッドのどちらか、または両方を実装しなければなりません。

You can call an instance of a dynamically callable type as if it’s a function that takes any number of arguments. あなたは動的callable型のインスタンスを、まるでそれがいくらかの数の引数を取る関数であるかのように呼び出せます。

  1. @dynamicCallable
  2. struct TelephoneExchange {
  3. func dynamicallyCall(withArguments phoneNumber: [Int]) {
  4. if phoneNumber == [4, 1, 1] {
  5. print("Get Swift help on forums.swift.org")
  6. } else {
  7. print("Unrecognized number")
  8. }
  9. }
  10. }
  12. let dial = TelephoneExchange()
  14. // Use a dynamic method call.（動的メソッド呼び出しを使います。）
  15. dial(4, 1, 1)
  16. // Prints "Get Swift help on forums.swift.org"
  18. dial(8, 6, 7, 5, 3, 0, 9)
  19. // Prints "Unrecognized number"
  21. // Call the underlying method directly.（基礎をなすメソッドを直接に呼び出します。）
  22. dial.dynamicallyCall(withArguments: [4, 1, 1])

The declaration of the dynamicallyCall(withArguments:) method must have a single parameter that conforms to the ExpressibleByArrayLiteral protocol—like [Int] in the example above. The return type can be any type. dynamicallyCall(withArguments:)メソッドの宣言は、ExpressibleByArrayLiteralプロトコルに準拠する単一のパラメータを持たなければいけません — 上の例の[Int]のように。戻りの型は任意の型であることができます。

You can include labels in a dynamic method call if you implement the dynamicallyCall(withKeywordArguments:) method. あなたは、いくつかのラベルを動的メソッド呼び出しに含めることができます、もしあなたがdynamicallyCall(withKeywordArguments:)メソッドを実装するならば。

  1. @dynamicCallable
  2. struct Repeater {
  3. func dynamicallyCall(withKeywordArguments pairs: KeyValuePairs<String, Int>) -> String {
  4. return pairs
  5. .map { label, count in
  6. repeatElement(label, count: count).joined(separator: " ")
  7. }
  8. .joined(separator: "\n")
  9. }
  10. }
  12. let repeatLabels = Repeater()
  13. print(repeatLabels(a: 1, b: 2, c: 3, b: 2, a: 1))
  14. // a
  15. // b b
  16. // c c c
  17. // b b
  18. // a

The declaration of the dynamicallyCall(withKeywordArguments:) method must have a single parameter that conforms to the ExpressibleByDictionaryLiteral protocol, and the return type can be any type. The parameter’s Key must be ExpressibleByStringLiteral. The previous example uses KeyValuePairs as the parameter type so that callers can include duplicate parameter labels—a and b appear multiple times in the call to repeat. dynamicallyCall(withKeywordArguments:)メソッドの宣言は、ある単一のパラメータを持たなければなりません、それはExpressibleByDictionaryLiteralプロトコルに準拠するものです、そして戻り型はどんな型でも構いません。パラメータのKeyは、ExpressibleByStringLiteralでなければなりません。前の例は、KeyValuePairsをパラメータ型として使います、それで呼び出し側は重複するパラメータラベルを含むことができます — aとbは複数回repeatの呼び出しにおいて現れます。

If you implement both dynamicallyCall methods, dynamicallyCall(withKeywordArguments:) is called when the method call includes keyword arguments. In all other cases, dynamicallyCall(withArguments:) is called. あなたが両方のdynamicallyCallメソッドを実装するならば、dynamicallyCall(withKeywordArguments:)が呼び出されるのは、メソッド呼び出しがキーワード引数を含む時です。全ての他の場合には、dynamicallyCall(withArguments:)が呼び出されます。

You can only call a dynamically callable instance with arguments and a return value that match the types you specify in one of your dynamicallyCall method implementations. The call in the following example doesn’t compile because there isn’t an implementation of dynamicallyCall(withArguments:) that takes KeyValuePairs<String, String>. あなたは動的callableインスタンスを、あなたのdynamicallyCallメソッド実装の１つにおいてあなたが指定する型に合致する引数いくつかと戻り値ひとつで呼び出せるだけです。以下の例における呼び出しはコンパイルしません、なぜならdynamicallyCall(withArguments:)の実装でKeyValuePairs<String, String>をとるものがないからです。

  1. repeatLabels(a: "four") // Error

dynamicMemberLookup

Apply this attribute to a class, structure, enumeration, or protocol to enable members to be looked up by name at runtime. The type must implement a subscript(dynamicMember:) subscript. この属性をクラス、構造体、列挙、またはプロトコルに適用して、メンバーが実行時に名前で検索されることを可能にしてください。この型は、subscript(dynamicMember:)添え字を実装しなければなりません。

In an explicit member expression, if there isn’t a corresponding declaration for the named member, the expression is understood as a call to the type’s subscript(dynamicMember:) subscript, passing information about the member as the argument. The subscript can accept a parameter that’s either a key path or a member name; if you implement both subscripts, the subscript that takes key path argument is used. 明示的メンバー式において、名前付きメンバーに対して対応する宣言がないならば、式は型の持つsubscript(dynamicMember:)添え字に対する呼び出しとして理解されます、メンバーについての情報を引数として渡します。添え字は、あるパラメータを受け入れます、それはキーパスまたはメンバー名のどちらかです；あなたが両方の添え字を実装するならば、キーパス引数をとる添え字が使われます。

An implementation of subscript(dynamicMember:) can accept key paths using an argument of type KeyPath, WritableKeyPath, or ReferenceWritableKeyPath. It can accept member names using an argument of a type that conforms to the ExpressibleByStringLiteral protocol—in most cases, String. The subscript’s return type can be any type. subscript(dynamicMember:)の実装はキーパスを、型KeyPath、WritableKeyPath、またはReferenceWritableKeyPathの引数を使って受け入れ可能です。それはメンバー名を、ExpressibleByStringLiteralプロトコルに準拠する型 — ほとんどの場合、String — の引数を使って受け入れ可能です。添え字のもつ戻り型は、どんな型でも可能です。

Dynamic member lookup by member name can be used to create a wrapper type around data that can’t be type checked at compile time, such as when bridging data from other languages into Swift. For example: メンバー名による動的メンバー検索は、コンパイル時に型検査されることができないデータを取り囲むラッパー型を作成するために使用できます、たとえば他の言語からスウィフトへとブリッジしている時など。例えば：

  1. @dynamicMemberLookup
  2. struct DynamicStruct {
  3. let dictionary = ["someDynamicMember": 325,
  4. "someOtherMember": 787]
  5. subscript(dynamicMember member: String) -> Int {
  6. return dictionary[member] ?? 1054
  7. }
  8. }
  9. let s = DynamicStruct()
  11. // Use dynamic member lookup.（動的メンバー検索を使います。）
  12. let dynamic = s.someDynamicMember
  13. print(dynamic)
  14. // Prints "325"（ "325" を出力する）
  16. // Call the underlying subscript directly.（基礎をなす添え字を直接に呼び出す。）
  17. let equivalent = s[dynamicMember: "someDynamicMember"]
  18. print(dynamic == equivalent)
  19. // Prints "true"（「true」を出力します）

Dynamic member lookup by key path can be used to implement a wrapper type in a way that supports compile-time type checking. For example: キーパスによる動的メンバー検索は、ラッパー型を、コンバイル時型検査をサポートするある方法で実装するために使用できます。例えば：

  1. struct Point { var x, y: Int }
  3. @dynamicMemberLookup
  4. struct PassthroughWrapper<Value> {
  5. var value: Value
  6. subscript<T>(dynamicMember member: KeyPath<Value, T>) -> T {
  7. get { return value[keyPath: member] }
  8. }
  9. }
  11. let point = Point(x: 381, y: 431)
  12. let wrapper = PassthroughWrapper(value: point)
  13. print(wrapper.x)

frozen

Apply this attribute to a structure or enumeration declaration to restrict the kinds of changes you can make to the type. This attribute is allowed only when compiling in library evolution mode. Future versions of the library can’t change the declaration by adding, removing, or reordering an enumeration’s cases or a structure’s stored instance properties. These changes are allowed on nonfrozen types, but they break ABI compatibility for frozen types. この属性を構造体または列挙宣言に適用して、あなたがその型にすることが出来る変更の種類を制約してください。この属性は、ライブラリ進化モードでコンパイルしている場合にのみ許可されます。ライブラリの将来のバージョンは、追加、削除、または列挙のもつケース節や構造体のもつ格納インスタンスプロパティの再配列によって宣言を変更できません。これらの変更は、非凍結型の上では許可されます、しかしそれらは凍結型に対するABI互換性を破壊します。

Note 注意

When the compiler isn’t in library evolution mode, all structures and enumerations are implicitly frozen, and this attribute is ignored. コンパイラがライブラリ進化モードではない場合、全ての構造体と列挙は暗黙的に凍結されます、そしてこの属性は無視されます。

In library evolution mode, code that interacts with members of nonfrozen structures and enumerations is compiled in a way that allows it to continue working without recompiling even if a future version of the library adds, removes, or reorders some of that type’s members. The compiler makes this possible using techniques like looking up information at runtime and adding a layer of indirection. Marking a structure or enumeration as frozen gives up this flexibility to gain performance: Future versions of the library can make only limited changes to the type, but the compiler can make additional optimizations in code that interacts with the type’s members. ライブラリ進化モードでは、非凍結の構造体および列挙のメンバーと相互作用するコードは、ある方法でコンパイルされます、それは、再コンパイルすることなしにそれに仕事を継続させます、たとえ将来のバージョンのライブラリが追加する、削除する、またはその型のもつメンバーのいくつかを再配置するとしてもです。コンパイラは、これを、実行時に情報を検索することそして間接参照のレイヤーを加えることのような技術いくつかを使って可能にします。構造体または列挙を凍結されると印することは、この柔軟性を諦めることで性能を手に入れます：ライブラリの将来のバージョンは、制限された変更だけしか型に対して出来ません、しかしコンパイラは追加的な最適化を、型のもつメンバーと相互作用するコードにすることが出来ます。

Frozen types, the types of the stored properties of frozen structures, and the associated values of frozen enumeration cases must be public or marked with the usableFromInline attribute. The properties of a frozen structure can’t have property observers, and expressions that provide the initial value for stored instance properties must follow the same restrictions as inlinable functions, as discussed in inlinable. 凍結型、凍結構造体の格納プロパティの型、そして凍結列挙ケース節の関連値は、パブリックであるかusableFromInline属性で印されなければなりません。凍結構造体のプロパティは、ブロパティオブザーバを持つことが出来ません、そして格納インスタンスプロパティに初期値を提供する式は、インライン可能関数と同じ制約に従わなければなりません、inlinableで記述されるように。

To enable library evolution mode on the command line, pass the -enable-library-evolution option to the Swift compiler. To enable it in Xcode, set the “Build Libraries for Distribution” build setting (BUILD_LIBRARY_FOR_DISTRIBUTION) to Yes, as described in Xcode Help. ライブラリ進化モードをコマンドライン上で可能にするには、-enable-library-evolutionオプションをスウィフトコンパイラに渡してください。それをXcodeで可能にするには、“Build Libraries for Distribution” ビルド設定（BUILD_LIBRARY_FOR_DISTRIBUTION）を Yes に設定してください、Xcode Helpで記述されるとおりに。

A switch statement over a frozen enumeration doesn’t require a default case, as discussed in Switching Over Future Enumeration Cases. Including a default or @unknown default case when switching over a frozen enumeration produces a warning because that code is never executed. 凍結列挙に対するスイッチ文は、defaultケース節を必要しません、未来列挙ケース節に対してスイッチするで議論されるように。defaultまたは@unknown defaultケース節を、凍結列挙に対してスイッチしている時に含めることは、警告を生成します、なぜならそのコードは決して遂行されないからです。

GKInspectable

Apply this attribute to expose a custom GameplayKit component property to the SpriteKit editor UI. Applying this attribute also implies the objc attribute. この属性を適用することであつらえのGameplayKitコンポーネントプロパティをSpriteKitエディタUIに露出してください。この属性を適用することはまた、objc属性も暗に意味します。

inlinable

Apply this attribute to a function, method, computed property, subscript, convenience initializer, or deinitializer declaration to expose that declaration’s implementation as part of the module’s public interface. The compiler is allowed to replace calls to an inlinable symbol with a copy of the symbol’s implementation at the call site. この属性を関数、メソッド、計算プロパティ、添え字、便宜イニシャライザ、またはデイニシャライザ宣言に適用することで、宣言の実装をモジュールの公開インターフェイスの一部として露出してください。コンパイラは、インライン可能シンボルへの呼び出しを、呼び出し場所でのそのシンボルの持つ実装のコピーで置き換えます。

Inlinable code can interact with public symbols declared in any module, and it can interact with internal symbols declared in the same module that are marked with the usableFromInline attribute. Inlinable code can’t interact with private or fileprivate symbols. インライン可能コードは、何らかのモジュールにおいて宣言されるpublicシンボルと相互作用できます、そしてそれは同じモジュールにおいて宣言されるinternalシンボルで、usableFromInline属性で印されるものと相互作用できます。インライン可能コードは、privateまたはfileprivateシンボルと相互作用できません。

This attribute can’t be applied to declarations that are nested inside functions or to fileprivate or private declarations. Functions and closures that are defined inside an inlinable function are implicitly inlinable, even though they can’t be marked with this attribute. この属性は、関数の内部に入れ子にされる宣言に、またはfileprivateやprivate宣言に適用できません。インライン可能関数内部で定義される関数とクロージャは、暗黙的にインライン可能です。

main

Apply this attribute to a structure, class, or enumeration declaration to indicate that it contains the top-level entry point for program flow. The type must provide a main type function that doesn’t take any arguments and returns Void. For example: この属性を構造体、クラス、または列挙宣言に適用して、それがプログラム流れに対するトップレベルエントリポイントを含むことを指し示してください。型は、あるmain型関数を提供しなければなりません、それはどんな引数もとりません、そしてVoidを返します。例えば：

  1. @main
  2. struct MyTopLevel {
  3. static func main() {
  4. // Top-level code goes here
  5. }
  6. }

Another way to describe the requirements of the main attribute is that the type you write this attribute on must satisfy the same requirements as types that conform to the following hypothetical protocol: main属性の要件を記述する別の方法は、あなたがそれの上でこの属性を書くところの型は以下の仮定的なプロトコルに準拠する型と同じ要件を満たさなければならない、ということになります：

  1. protocol ProvidesMain {
  2. static func main() throws
  3. }

The Swift code you compile to make an executable can contain at most one top-level entry point, as discussed in Top-Level Code. あなたがコンパイルして実行可能にするSwiftコードは、最大で１つのトップレベルエントリポイントを持つことができます、トップレベル・コードで記述されるように。

nonobjc

Apply this attribute to a method, property, subscript, or initializer declaration to suppress an implicit objc attribute. The nonobjc attribute tells the compiler to make the declaration unavailable in Objective-C code, even though it’s possible to represent it in Objective-C. この属性をメソッド、プロパティ、添え字、およびイニシャライザ宣言に適用することで、暗黙的にobjc属性となるのを抑制してください。nonobjc属性は、コンパイラにその宣言がObjective-Cコードにおいて利用不可にされることを伝えます、たとえそれがObjective-Cにおいて表現可能であってもです。

Applying this attribute to an extension has the same effect as applying it to every member of that extension that isn’t explicitly marked with the objc attribute. この属性をある拡張に適用することは、明示的にobjc属性で印されていないその拡張のあらゆるメンバーにそれを適用することと同じ効果を持ちます。

You use the nonobjc attribute to resolve circularity for bridging methods in a class marked with the objc attribute, and to allow overloading of methods and initializers in a class marked with the objc attribute. あなたは、objc属性で印されるクラスの中のブリッジしているメソッドに対する循環性を解決するために、そしてobjc属性で印されるクラスにおいてメソッドとイニシャライザをオーバーロードすることを許可するためにnonobjc属性を使います。

A method marked with the nonobjc attribute can’t override a method marked with the objc attribute. However, a method marked with the objc attribute can override a method marked with the nonobjc attribute. Similarly, a method marked with the nonobjc attribute can’t satisfy a protocol requirement for a method marked with the objc attribute. nonobjc属性で印されるメソッドは、objc属性で印されるメソッドをオーバーライドできません。しかしながら、objc属性で印されるメソッドはnonobjc属性で印されるメソッドをオーバーライドすることができます。同様に、nonobjc属性で印されるメソッドは、objc属性で印されるメソッドに対するプロトコル要件を満たすことは出来ません。

NSApplicationMain

Apply this attribute to a class to indicate that it’s the application delegate. Using this attribute is equivalent to calling the NSApplicationMain(_:_:) function. この属性をあるクラスに適用することで、それがアプリケーション委任先であることを指し示してください。この属性を使用することは、NSApplicationMain(_:_:)関数を呼ぶことに相当します。

If you don’t use this attribute, supply a main.swift file with code at the top level that calls the NSApplicationMain(_:_:) function as follows: あなたがこの属性を使わないならば、NSApplicationMain(_:_:)関数を呼ぶトップレベルコードを持つmain.swiftファイルを以下のように提供してください：

  1. import AppKit
  2. NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv)

The Swift code you compile to make an executable can contain at most one top-level entry point, as discussed in Top-Level Code. あなたがコンパイルして実行可能にするSwiftコードは、最大で１つのトップレベルエントリポイントを持つことができます、トップレベル・コードで記述されるように。

NSCopying

Apply this attribute to a stored variable property of a class. This attribute causes the property’s setter to be synthesized with a copy of the property’s value—returned by the copyWithZone(_:) method—instead of the value of the property itself. The type of the property must conform to the NSCopying protocol. この属性をクラスの格納変数プロパティに適用してください。この属性は、プロパティのセッターがそのプロパティの値のコピー ― copyWithZone(_:)メソッドによって返されるもの ― を使って合成されるようにします、プロパティそれ自体の値ではなく。プロパティの型は、NSCopyingプロトコルに準拠しなければなりません。

The NSCopying attribute behaves in a way similar to the Objective-C copy property attribute. NSCopying属性は、Objective-Cのcopyプロパティ属性に似たやり方でふるまいます。

NSManaged

Apply this attribute to an instance method or stored variable property of a class that inherits from NSManagedObject to indicate that Core Data dynamically provides its implementation at runtime, based on the associated entity description. For a property marked with the NSManaged attribute, Core Data also provides the storage at runtime. Applying this attribute also implies the objc attribute. この属性をNSManagedObjectから継承するクラスのインスタンスメソッドまたは格納変数プロパティに適用することで、関連する実体記述に基づいて、Coreデータが動的にそれの実装に実行時に提供されることを指し示してください。NSManaged属性で印されるプロパティに対して、Coreデータはまたストレージを実行時に提供します。この属性を適用することはさらにまたobjc属性も意味します。

objc

Apply this attribute to any declaration that can be represented in Objective-C—for example, nonnested classes, protocols, nongeneric enumerations (constrained to integer raw-value types), properties and methods (including getters and setters) of classes, protocols and optional members of a protocol, initializers, and subscripts. The objc attribute tells the compiler that a declaration is available to use in Objective-C code. この属性をObjective-Cにおいて表わされることができる何らかの宣言に適用してください ― 例えば、入れ子にされないクラス、プロトコル、総称体でない列挙（整数の生の値型に制限される）、クラスのプロパティとメソッド（ゲッターやセッターを含む）、プロトコルおよびあるプロトコルのオプショナルメンバー、イニシャライザ、そして添え字など。objc属性は、コンパイラにある宣言がObjective-Cコードにおいて使われることが可能であるのを伝えます。

Applying this attribute to an extension has the same effect as applying it to every member of that extension that isn’t explicitly marked with the nonobjc attribute. この属性をある拡張に適用することは、その拡張のあらゆるメンバーで明示的にnonobjc属性で印されていないものにそれを適用することと同じ効果を持ちます。

The compiler implicitly adds the objc attribute to subclasses of any class defined in Objective-C. However, the subclass must not be generic, and must not inherit from any generic classes. You can explicitly add the objc attribute to a subclass that meets these criteria, to specify its Objective-C name as discussed below. Protocols that are marked with the objc attribute can’t inherit from protocols that aren’t marked with this attribute. コンパイラは、Objective-Cにおいて定義されたあらゆるクラスのサブクラスに暗黙的にobjc属性を加えます。しかしながら、サブクラスは総称体である必要はありません、そして何らかの総称体クラスから継承する必要はありません。あなたは、明示的にobjc属性をこの基準に合うサブクラスに適用して、下で議論されるように、それのObjective-C名を指定できます。objc属性で印されるプロトコルは、この属性で印されないプロトコルから継承できません。

The objc attribute is also implicitly added in the following cases: objc属性はまた、以下の場合において暗黙的に加えられます：

  • The declaration is an override in a subclass, and the superclass’s declaration has the objc attribute. その宣言は、サブクラスの中のオーバーライドである、そしてそのサブクラスの宣言がobjc属性を持つ。
  • The declaration satisfies a requirement from a protocol that has the objc attribute. その宣言は、objc属性を持つあるプロトコルからの要件を満たす。
  • The declaration has the IBAction, IBSegueAction, IBOutlet, IBDesignable, IBInspectable, NSManaged, or GKInspectable attribute. その宣言は、IBAction、IBSegueAction、IBOutlet、IBDesignable、IBInspectable、NSManaged、またはGKInspectableを持つ。

If you apply the objc attribute to an enumeration, each enumeration case is exposed to Objective-C code as the concatenation of the enumeration name and the case name. The first letter of the case name is capitalized. For example, a case named venus in a Swift Planet enumeration is exposed to Objective-C code as a case named PlanetVenus. あなたがobjc属性をある列挙に適応したならば、個々の列挙ケース節はObjective-Cコードに列挙名とそのケース節名を連結したものとして暴露されます。ケース節の最初の文字は大文字で書かれます。例えば、スウィフトのPlanet列挙の中のvenusと名付けられるケース節は、Objective-CコードにPlanetVenusと名付けられるケース節として暴露されます。

The objc attribute optionally accepts a single attribute argument, which consists of an identifier. The identifier specifies the name to be exposed to Objective-C for the entity that the objc attribute applies to. You can use this argument to name classes, enumerations, enumeration cases, protocols, methods, getters, setters, and initializers. If you specify the Objective-C name for a class, protocol, or enumeration, include a three-letter prefix on the name, as described in Conventions in Programming with Objective-C. The example below exposes the getter for the enabled property of the ExampleClass to Objective-C code as isEnabled rather than just as the name of the property itself. objc属性は、任意にただ１つだけ属性引数を受け入れます、それはひとつの識別子から成ります。この識別子は、Objective-Cへと暴露される名前をobjc属性を適用される存在に対して指定します。あなたはこの引数を、クラス、列挙、列挙ケース、プロトコル、メソッド、ゲッター、セッター、そしてイニシャライザに名前をつけるために使うことができます。あなたがObjective-C名をクラス、プロトコル、または列挙に指定するならば、ある３文字接頭辞をその名前に含めて下さい、ConventionsでProgramming with Objective-Cにおいて記述されるように。以下の例は、ExampleClassのenabledプロパティのためのゲッターをObjective-Cコードに、ただプロパティそれ自身の名前ではなくisEnabledとして露出します。

  1. class ExampleClass: NSObject {
  2. @objc var enabled: Bool {
  3. @objc(isEnabled) get {
  4. // Return the appropriate value（適切な値を返す）
  5. }
  6. }
  7. }

For more information, see Importing Swift into Objective-C. さらなる情報は、SwiftをObjective-Cにインポートするを見てください。

Note 注意

The argument to the objc attribute can also change the runtime name for that declaration. You use the runtime name when calling functions that interact with the Objective-C runtime, like NSClassFromString, and when specifying class names in an app’s Info.plist file. If you specify a name by passing an argument, that name is used as the name in Objective-C code and as the runtime name. If you omit the argument, the name used in Objective-C code matches the name in Swift code, and the runtime name follows the normal Swift compiler convention of name mangling. objc属性に対する引数はまた、その宣言に対するランタイム名を変更できます。あなたはランタイム名を、Objective-Cランタイムと相互作用する関数、NSClassFromStringなどを呼び出す時に、そしてクラス名をアプリのもつInfo.plistファイルの中で指定する時に使います。あなたが名前を引数を渡す事によって指定するならば、その名前はObjective-Cコードにおける名前としてそしてランタイム名として使われます。あなたが引数を省略するならば、Objective-Cコードにおいて使われる名前はSwiftコードにおける名前と合致します、そしてランタイム名は名前修飾の通常のSwiftコンパイラ慣例に従います。

objcMembers

Apply this attribute to a class declaration, to implicitly apply the objc attribute to all Objective-C compatible members of the class, its extensions, its subclasses, and all of the extensions of its subclasses. この属性をあるクラス宣言に適用してください、暗黙的にobjc属性をそのクラスの全てのObjective-C互換メンバー、それの拡張、それのサブクラス、そしてそれのサブクラスの全ての拡張に適用するには。

Most code should use the objc attribute instead, to expose only the declarations that are needed. If you need to expose many declarations, you can group them in an extension that has the objc attribute. The objcMembers attribute is a convenience for libraries that make heavy use of the introspection facilities of the Objective-C runtime. Applying the objc attribute when it isn’t needed can increase your binary size and adversely affect performance. ほとんどのコードは、objc属性を代わりに使って、必要とされる宣言だけを露出するべきです。あなたが多くの宣言を露出する必要があるならば、あなたはそれらをobjc属性を持つある拡張にまとめることができます。objcMembers属性は、Objective-Cランタイムの自己観察便宜の重度の使用を生じさせるライブラリにとって好都合です。それが必要とされない時にobjc属性を適用することは、あなたのバイナリサイズを増加させ性能に逆効果です。

propertyWrapper

Apply this attribute to a class, structure, or enumeration declaration to use that type as a property wrapper. When you apply this attribute to a type, you create a custom attribute with the same name as the type. Apply that new attribute to a property of a class, structure, or enumeration to wrap access to the property through an instance of the wrapper type; apply the attribute to a local stored variable declaration to wrap access to the variable the same way. Computed variables, global variables, and constants can’t use property wrappers. この属性をクラス、構造体、または列挙の宣言に適用して、その型をプロパティラッパーとして使ってください。あなたがこの属性をある型に適用する場合、あなたはあるあつらえの属性をその型と同じ名前で作成します。その新しい属性をクラス、構造体、または列挙のプロパティに適用することで、そのプロパティに対するアクセスを、ラッパー型のインスタンスによってラップしてください；その属性をあるローカル格納変数宣言に適用することで、その変数に対するアクセスを同じ方法でラップしてください。計算変数、グローバル変数、そして定数は、プロパティラッパーを使用できません。

The wrapper must define a wrappedValue instance property. The wrapped value of the property is the value that the getter and setter for this property expose. In most cases, wrappedValue is a computed value, but it can be a stored value instead. The wrapper defines and manages any underlying storage needed by its wrapped value. The compiler synthesizes storage for the instance of the wrapper type by prefixing the name of the wrapped property with an underscore (_)—for example, the wrapper for someProperty is stored as _someProperty. The synthesized storage for the wrapper has an access control level of private. ラッパーは、あるwrappedValueインスタンスプロパティを定義しなければなりません。そのプロパティのラップされた値は、このプロパティに対するゲッターとセッターが露出する値です。ほとんどの場合には、wrappedValueは計算される値です、しかしそれは代わりに格納される値であることもできます。ラッパーは、それのラップされた値によって必要とされるあらゆる基礎をなすストレージを定義および管理します。コンパイラは、ラッパー型のインスタンスのためにストレージを合成します、ラップされたプロパティの名前にアンダースコア（_）で接頭辞をつけることによって — 例えば、somePropertyに対するラッパーは、_somePropertyとして格納されます。ラッパーのために合成されたストレージは、privateのアクセス制御水準を持ちます。

A property that has a property wrapper can include willSet and didSet blocks, but it can’t override the compiler-synthesized get or set blocks. プロパティラッパーを持つプロパティは、willSetとdidSetブロックを含むことができます、しかしそれはコンパイラが合成したgetまたはsetブロックをオーバーライドできません。

Swift provides two forms of syntactic sugar for initialization of a property wrapper. You can use assignment syntax in the definition of a wrapped value to pass the expression on the right-hand side of the assignment as the argument to the wrappedValue parameter of the property wrapper’s initializer. You can also provide arguments to the attribute when you apply it to a property, and those arguments are passed to the property wrapper’s initializer. For example, in the code below, SomeStruct calls each of the initializers that SomeWrapper defines. スウィフトは、２つの形式の糖衣構文をプロパティラッパーの初期化に対して提供します。あなたは、代入構文をラップ値の定義において使用して、代入の右手側での式を、プロパティラッパーのもつイニシャライザのwrappedValueパラメータに対する引数として渡せます。あなたはまた引数いくつかを、属性に対して提供することが、それをあなたがプロパティに適用する時に行えます、そしてそれら引数は、プロパティラッパーのもつイニシャライザに渡されます。例えば、下のコードにおいて、SomeStructは、SomeWrapperが定義するイニシャライザそれぞれを呼び出します。

  1. @propertyWrapper
  2. struct SomeWrapper {
  3. var wrappedValue: Int
  4. var someValue: Double
  5. init() {
  6. self.wrappedValue = 100
  7. self.someValue = 12.3
  8. }
  9. init(wrappedValue: Int) {
  10. self.wrappedValue = wrappedValue
  11. self.someValue = 45.6
  12. }
  13. init(wrappedValue value: Int, custom: Double) {
  14. self.wrappedValue = value
  15. self.someValue = custom
  16. }
  17. }
  19. struct SomeStruct {
  20. // Uses init()
  21. @SomeWrapper var a: Int
  23. // Uses init(wrappedValue:)
  24. @SomeWrapper var b = 10
  26. // Both use init(wrappedValue:custom:)
  27. @SomeWrapper(custom: 98.7) var c = 30
  28. @SomeWrapper(wrappedValue: 30, custom: 98.7) var d
  29. }

The projected value for a wrapped property is a second value that a property wrapper can use to expose additional functionality. The author of a property wrapper type is responsible for determining the meaning of its projected value and defining the interface that the projected value exposes. To project a value from a property wrapper, define a projectedValue instance property on the wrapper type. The compiler synthesizes an identifier for the projected value by prefixing the name of the wrapped property with a dollar sign ($)—for example, the projected value for someProperty is $someProperty. The projected value has the same access control level as the original wrapped property. あるラップされたプロパティに対する投影値は、２番目の値です、それはプロパティラッパーが使用することで追加的機能性を露出できるものです。プロパティラッパー型の作者は、その投影値の意味の決定にそして投影値を露出するインターフェイスの定義に責任があります。ある値をプロパティラッパーから投影をするには、projectedValueインスタンスプロパティをそのラッパー型上で定義してください。コンパイラは、ある識別子を投影値に対して合成します、ラップされたプロパティの名前にドル記号（$）で接頭辞をつけることによって — 例えば、somePropertyに対する投影値は$somePropertyです。投影値は、元のラップされたプロパティと同じアクセス制御水準を持ちます。

  1. @propertyWrapper
  2. struct WrapperWithProjection {
  3. var wrappedValue: Int
  4. var projectedValue: SomeProjection {
  5. return SomeProjection(wrapper: self)
  6. }
  7. }
  8. struct SomeProjection {
  9. var wrapper: WrapperWithProjection
  10. }
  12. struct SomeStruct {
  13. @WrapperWithProjection var x = 123
  14. }
  15. let s = SomeStruct()
  16. s.x // Int value
  17. s.$x // SomeProjection value
  18. s.$x.wrapper // WrapperWithProjection value

resultBuilder

Apply this attribute to a class, structure, enumeration to use that type as a result builder. A result builder is a type that builds a nested data structure step by step. You use result builders to implement a domain-specific language (DSL) for creating nested data structures in a natural, declarative way. For an example of how to use the resultBuilder attribute, see Result Builders. この属性をクラス、構造体、列挙に適用することで、その型をリザルトビルダーとして使ってください。リザルトビルダーは、ある型です、それは入れ子にされたデータ構造を着実に組み立てます。あなたはリザルトビルダーを使用することで、入れ子にされたデータ構造の自然な、宣言的な方法での作成のためにあるドメイン固有言語 (DSL) を実装します。どのようにresultBuilder属性を使うかの例として、リザルトビルダーを見てください。

Result-Building Methods リザルトビルド（結果組立）メソッド

A result builder implements static methods described below. Because all of the result builder’s functionality is exposed through static methods, you don’t ever initialize an instance of that type. The buildBlock(_:) method is required; the other methods—which enable additional functionality in the DSL—are optional. The declaration of a result builder type doesn’t actually have to include any protocol conformance. リザルトビルダーは、下で記述される静的メソッドを実装します。リザルトビルダーのもつ機能性の全ては静的メソッドを通して露出されることから、あなたは決してその型のインスタンスを初期化しないでください。buildBlock(_:)メソッドは必須とされます；他のメソッド — それは追加の機能性をDSLにおいて可能にします — は随意です。リザルトビルダー型の宣言は、実際はどんなプロトコル準拠も含む必要はありません。

The description of the static methods uses three types as placeholders. The type Expression is a placeholder for the type of the result builder’s input, Component is a placeholder for the type of a partial result, and FinalResult is a placeholder for the type of the result that the result builder produces. You replace these types with the actual types that your result builder uses. If your result-building methods don’t specify a type for Expression or FinalResult, they default to being the same as Component. これら静的メソッドの説明は、３つの型をプレースホルダとして使います。型Expressionはリザルトビルダーのもつ入力の型に対するプレースホルダです、Componentは部分結果の型に対するプレースホルダです、そしてFinalResultはリザルトビルダーが産み出す結果の型に対するプレースホルダです。あなたは、これらの型をあなたのリザルトビルダーが使う実際の型で置き換えます。あなたのリザリトビルドメソッドがExpressionまたはFinalResultに対して型を指定しないならば、それらは初期状態でComponentと同じになります。

The result-building methods are as follows: リザルビルドメソッドは、以下があります：

static func buildBlock(_ components: Component...) -> Component
Combines an array of partial results into a single partial result. A result builder must implement this method. 部分的結果それらからなるある配列を単一の部分的結果へと結合します。リザルトビルダーは、このメソッドを実装しなければなりません。
static func buildOptional(_ component: Component?) -> Component
Builds a partial result from a partial result that can be nil. Implement this method to support if statements that don’t include an else clause. ある部分的結果を、nilであることが可能なある部分的結果から組み立てます。このメソッドを実装することで、if文をサポートしてください、それはelse節を含まないものです。
static func buildEither(first: Component) -> Component
Builds a partial result whose value varies depending on some condition. Implement both this method and buildEither(second:) to support switch statements and if statements that include an else clause. ある部分的結果を組み立てます、それの値はなんらかの条件に依存して変化するものです。このメソッドとbuildEither(second:)を両方とも実装することで、switch文と、if文でelse節を含むものをサポートしてください。
static func buildEither(second: Component) -> Component
Builds a partial result whose value varies depending on some condition. Implement both this method and buildEither(first:) to support switch statements and if statements that include an else clause. ある部分的結果を組み立てます、それの値はなんらかの条件に依存して変化するものです。このメソッドとbuildEither(first:)を両方とも実装することで、switch文と、if文でelse節を含むものをサポートしてください。
static func buildArray(_ components: [Component]) -> Component
Builds a partial result from an array of partial results. Implement this method to support for loops. ある部分的結果を、部分的結果それらからなるある配列から組み立てます。このメソッドを実装することで、forループをサポートしてください。
static func buildExpression(_ expression: Expression) -> Component
Builds a partial result from an expression. You can implement this method to perform preprocessing—for example, converting expressions to an internal type—or to provide additional information for type inference at use sites. ある部分的結果をある式から組み立てます。あなたはこのメソッドを実装することで、処理 — 例えば、いくつかの式をある内部型へ変換すること — を実行します、または追加の情報を型推論に対してさまざまな現場で提供します。
static func buildFinalResult(_ component: Component) -> FinalResult
Builds a final result from a partial result. You can implement this method as part of a result builder that uses a different type for partial and final results, or to perform other postprocessing on a result before returning it. ある最終的な結果をある部分的な結果から組み立てます。あなたはこのメソッドを、部分的および最終的結果に対して異なる型を使うあるリザルトビルダーの一部として、または他の処理をある結果上でそれが返る前に実行するために実装できます。
static func buildLimitedAvailability(_ component: Component) -> Component
Builds a partial result that propagates or erases type information outside a compiler-control statement that performs an availability check. You can use this to erase type information that varies between the conditional branches. ある部分的結果を組み立てます、それはある有効性検査を実行するコンパイラ制御文の外側に型情報を伝播または消去するものです。あなたはこれを使うことで、条件分岐の間でさまざまに変化する型情報を消去できます。

For example, the code below defines a simple result builder that builds an array of integers. This code defines Compontent and Expression as type aliases, to make it easier to match the examples below to the list of methods above. 例えば、下のコードはある単純なリザルトビルダーを定義します、それは整数それらからなるある配列を組み立てます。このコードは、CompontentとExpressionを型エイリアスとして定義します、そうして下の例それらを上のメソッドそれらのリストにより合うようにしています。

  1. @resultBuilder
  2. struct ArrayBuilder {
  3. typealias Component = [Int]
  4. typealias Expression = Int
  5. static func buildExpression(_ element: Expression) -> Component {
  6. return [element]
  7. }
  8. static func buildOptional(_ component: Component?) -> Component {
  9. guard let component = component else { return [] }
  10. return component
  11. }
  12. static func buildEither(first component: Component) -> Component {
  13. return component
  14. }
  15. static func buildEither(second component: Component) -> Component {
  16. return component
  17. }
  18. static func buildArray(_ components: [Component]) -> Component {
  19. return Array(components.joined())
  20. }
  21. static func buildBlock(_ components: Component...) -> Component {
  22. return Array(components.joined())
  23. }
  24. }

Result Transformations 結果（リザルト）変換

The following syntactic transformations are applied recursively to turn code that uses result-builder syntax into code that calls the static methods of the result builder type: 以下の構文的変換は、再帰的に適用されることで、リザルトビルダー構文を使うコードを、リザルトビルダー型の静的メソッドを呼び出すコードに転換します：

  • If the result builder has a buildExpression(_:) method, each expression becomes a call to that method. This transformation is always first. For example, the following declarations are equivalent: リザルトビルダーがあるbuildExpression(_:)メソッドを持つならば、各々の式はそのメソッドへの呼び出しになります。この変換は、常に１番目です。例えば、以下の宣言は同等です：

    1. @ArrayBuilder var builderNumber: [Int] { 10 }
    2. var manualNumber = ArrayBuilder.buildExpression(10)

  • An assignment statement is transformed like an expression, but is understood to evaluate to (). You can define an overload of buildExpression(_:) that takes an argument of type () to handle assignments specifically. 代入文は、式のように変換されます、しかし()を評価すると理解されます。あなたはbuildExpression(_:)のあるオーバーロードを定義できます、それは型()の１つの引数を取ることで特に代入を取り扱うものです。

  • A branch statement that checks an availability condition becomes a call to the buildLimitedAvailability(_:) method. This transformation happens before the transformation into a call to buildEither(first:), buildEither(second:), or buildOptional(_:). You use the buildLimitedAvailability(_:) method to erase type information that changes depending on which branch is taken. For example, the buildEither(first:) and buildEither(second:) methods below use a generic type that captures type information about both branches. ある有効性条件を検査する分岐文は、buildLimitedAvailability(_:)メソッドへの呼び出しになります。この変換は、buildEither(first:)、buildEither(second:)、またはbuildOptional(_:)への呼び出しへの変換の前に起こります。あなたは、buildLimitedAvailability(_:)メソッドを使用することで、どの分岐が取られるかに依存して変化する型情報を消去します。例えば、下のbuildEither(first:)とbuildEither(second:)メソッドは、ある総称体型を使います、それは両方の分岐について型情報をキャプチャします。

    1. protocol Drawable {
    2. func draw() -> String
    3. }
    4. struct Text: Drawable {
    5. var content: String
    6. init(_ content: String) { self.content = content }
    7. func draw() -> String { return content }
    8. }
    9. struct Line<D: Drawable>: Drawable {
    10. var elements: [D]
    11. func draw() -> String {
    12. return elements.map { $0.draw() }.joined(separator: "")
    13. }
    14. }
    15. struct DrawEither<First: Drawable, Second: Drawable>: Drawable {
    16. var content: Drawable
    17. func draw() -> String { return content.draw() }
    18. }
    20. @resultBuilder
    21. struct DrawingBuilder {
    22. static func buildBlock<D: Drawable>(_ components: D...) -> Line<D> {
    23. return Line(elements: components)
    24. }
    25. static func buildEither<First, Second>(first: First)
    26. -> DrawEither<First, Second> {
    27. return DrawEither(content: first)
    28. }
    29. static func buildEither<First, Second>(second: Second)
    30. -> DrawEither<First, Second> {
    31. return DrawEither(content: second)
    32. }
    33. }

    However, this approach causes a problem in code that has availability checks: しかしながら、この取り組みは有効性検査を持つコードにおいて問題を引き起こします：

    1. @available(macOS 99, *)
    2. struct FutureText: Drawable {
    3. var content: String
    4. init(_ content: String) { self.content = content }
    5. func draw() -> String { return content }
    6. }
    7. @DrawingBuilder var brokenDrawing: Drawable {
    8. if #available(macOS 99, *) {
    9. FutureText("Inside.future") // Problem
    10. } else {
    11. Text("Inside.present")
    12. }
    13. }
    14. // The type of brokenDrawing is Line<DrawEither<Line<FutureText>, Line<Text>>>

    In the code above, FutureText appears as part of the type of brokenDrawing because it’s one of the types in the DrawEither generic type. This could cause your program to crash if FutureText isn’t available at runtime, even in the case where that type is explicitly not being used. 上のコードにおいて、FutureTextはbrokenDrawingの型の一部として現れます、なぜならそれはDrawEither総称体型の中の型のうちの１つだからです。これは、あなたのプログラムをクラッシュさせる可能性があります、もしFutureTextが実行時に有効でないならば、はっきりその型が使われない場合でさえ。

    To solve this problem, implement a buildLimitedAvailability(_:) method to erase type information. For example, the code below builds an AnyDrawable value from its availability check. この問題を解決するには、buildLimitedAvailability(_:)メソッドを実装して型情報を消去してください。例えば、下のコードはAnyDrawable値をそれの有効性検査から作り上げます。

    1. struct AnyDrawable: Drawable {
    2. var content: Drawable
    3. func draw() -> String { return content.draw() }
    4. }
    5. extension DrawingBuilder {
    6. static func buildLimitedAvailability(_ content: Drawable) -> AnyDrawable {
    7. return AnyDrawable(content: content)
    8. }
    9. }
    11. @DrawingBuilder var typeErasedDrawing: Drawable {
    12. if #available(macOS 99, *) {
    13. FutureText("Inside.future")
    14. } else {
    15. Text("Inside.present")
    16. }
    17. }
    18. // The type of typeErasedDrawing is Line<DrawEither<AnyDrawable, Line<Text>>>

  • A branch statement becomes a series of nested calls to the buildEither(first:) and buildEither(second:) methods. The statements’ conditions and cases are mapped onto the leaf nodes of a binary tree, and the statement becomes a nested call to the buildEither methods following the path to that leaf node from the root node. ある分岐文は、一連の入れ子にされたbuildEither(first:)とbuildEither(second:)メソッドそれらへの呼び出しになります。その文のもつ条件と事例は、ある二分木のリーフノードそれらへとマップされます、そして文はbuildEitherメソッドそれらへのある入れ子にされた呼び出しになり、ルートノードからそのリーフノードへの経路をなぞっています。

    For example, if you write a switch statement that has three cases, the compiler uses a binary tree with three leaf nodes. Likewise, because the path from the root node to the second case is “second child” and then “first child”, that case becomes a nested call like buildEither(first: buildEither(second: ... )). The following declarations are equivalent: 例えば、あなたが３つの事例を持つある切替文を書くならば、コンパイラは３つのリーフノードを備えるあるバイナリツリーを使います。同様に、ルートノードから２番目の事例への経路は “２番目の子” そしてそれゆえ “最初の子” であることから、その事例はある入れ子にされた呼び出しになります、buildEither(first: buildEither(second: ... ))のように。以下の宣言は同等です：

    1. let someNumber = 19
    2. @ArrayBuilder var builderConditional: [Int] {
    3. if someNumber < 12 {
    4. 31
    5. } else if someNumber == 19 {
    6. 32
    7. } else {
    8. 33
    9. }
    10. }
    12. var manualConditional: [Int]
    13. if someNumber < 12 {
    14. let partialResult = ArrayBuilder.buildExpression(31)
    15. let outerPartialResult = ArrayBuilder.buildEither(first: partialResult)
    16. manualConditional = ArrayBuilder.buildEither(first: outerPartialResult)
    17. } else if someNumber == 19 {
    18. let partialResult = ArrayBuilder.buildExpression(32)
    19. let outerPartialResult = ArrayBuilder.buildEither(second: partialResult)
    20. manualConditional = ArrayBuilder.buildEither(first: outerPartialResult)
    21. } else {
    22. let partialResult = ArrayBuilder.buildExpression(33)
    23. manualConditional = ArrayBuilder.buildEither(second: partialResult)
    24. }

  • A branch statement that might not produce a value, like an if statement without an else clause, becomes a call to buildOptional(_:). If the if statement’s condition is satisfied, its code block is transformed and passed as the argument; otherwise, buildOptional(_:) is called with nil as its argument. For example, the following declarations are equivalent: 値を生成しないかもしれない分岐文、たとえばif文でelse節なしなどは、buildOptional(_:)への呼び出しになります。if文のもつ条件が満たされるならば、それのコードブロックは変換されてそして引数として渡されます；そうでなければ、buildOptional(_:)が呼び出されます、nilをそれの引数として。例えば、以下の宣言は同等です：

    1. @ArrayBuilder var builderOptional: [Int] {
    2. if (someNumber % 2) == 1 { 20 }
    3. }
    5. var partialResult: [Int]? = nil
    6. if (someNumber % 2) == 1 {
    7. partialResult = ArrayBuilder.buildExpression(20)
    8. }
    9. var manualOptional = ArrayBuilder.buildOptional(partialResult)

  • A code block or do statement becomes a call to the buildBlock(_:) method. Each of the statements inside of the block is transformed, one at a time, and they become the arguments to the buildBlock(_:) method. For example, the following declarations are equivalent: コードブロックまたはdo文は、buildBlock(_:)メソッドへの呼び出しになります。ブロックの内部の文のそれぞれは変換されます、一度に１つずつ、そしてそれらはbuildBlock(_:)メソッドへの引数になります。例えば、以下の宣言は同等です：

    1. @ArrayBuilder var builderBlock: [Int] {
    2. 100
    3. 200
    4. 300
    5. }
    7. var manualBlock = ArrayBuilder.buildBlock(
    8. ArrayBuilder.buildExpression(100),
    9. ArrayBuilder.buildExpression(200),
    10. ArrayBuilder.buildExpression(300)
    11. )

  • A for loop becomes a temporary variable, a for loop, and call to the buildArray(_:) method. The new for loop iterates over the sequence and appends each partial result to that array. The temporary array is passed as the argument in the buildArray(_:) call. For example, the following declarations are equivalent: forループは、ある一時的な変数、あるforループ、そしてbuildArray(_:)メソッドへの呼び出しになります。新しいforループは、そのシーケンスのすべてにわたって反復します、そして部分的結果それぞれをその配列に追加します。一時的配列は、引数としてbuildArray(_:)呼び出しにおいて渡されます。例えば、以下の宣言は同等です：

    1. @ArrayBuilder var builderArray: [Int] {
    2. for i in 5...7 {
    3. 100 + i
    4. }
    5. }
    7. var temporary: [[Int]] = []
    8. for i in 5...7 {
    9. let partialResult = ArrayBuilder.buildExpression(100 + i)
    10. temporary.append(partialResult)
    11. }
    12. let manualArray = ArrayBuilder.buildArray(temporary)

  • If the result builder has a buildFinalResult(_:) method, the final result becomes a call to that method. This transformation is always last. リザルトビルダーがあるbuildFinalResult(_:)メソッドを持つならば、最終的結果はそのメソッドへの呼び出しになります。この変換は、常に最後です。

Although the transformation behavior is described in terms of temporary variables, using a result builder doesn’t actually create any new declarations that are visible from the rest of your code. 変換挙動は一時的な変数それらに基づいて記述されるとはいえ、リザルトビルダーを使うことは、あなたのコードの残りから可視であるどんな新しい宣言も実際は作成しません。

You can’t use break, continue, defer, guard, or return statements, while statements, or do-catch statements in the code that a result builder transforms. あなたは、break、continue、defer、guard、またはreturn文、while文、またはdo-catch文をリザルトビルダーが変換するコードにおいて使用できません。

The transformation process doesn’t change declarations in the code, which lets you use temporary constants and variables to build up expressions piece by piece. It also doesn’t change throw statements, compile-time diagnostic statements, or closures that contain a return statement. 変換処理は、コードの中の宣言を変更しません、それはあなたに一時的な定数と変数を使用して式それらを一つ一つ組み立てさせます。それはまた、throw文、コンパイル時診断文、またはreturn文を含むクロージャを変更しません。

Whenever possible, transformations are coalesced. For example, the expression 4 + 5 * 6 becomes buildExpression(4 + 5 * 6) rather multiple calls to that function. Likewise, nested branch statements become a single binary tree of calls to the buildEither methods. 可能な時はいつでも、変換それらは合体させられます。例えば、式4 + 5 * 6はbuildExpression(4 + 5 * 6)になります、その関数に対する複数の呼び出しではなく。同様に、入れ子にされた分岐文それらは、buildEitherメソッドへの呼び出しいくつかからなるある単一の二分木になります。

Custom Result-Builder Attributes あつらえのリザルトビルダー属性

Creating a result builder type creates a custom attribute with the same name. You can apply that attribute in the following places: あるリザルトビルダー型を作成することは、あるあつらえの属性を同じ名前で作成します。あなたは、その属性を以下の場所で適用できます：

  • On a function declaration, the result builder builds the body of the function. ある関数宣言上で、リザルトビルダーはその関数の本文を組み立てます。
  • On a variable or subscript declaration that includes a getter, the result builder builds the body of the getter. ゲッターを含んでいる、変数または添え字の宣言上で、リザルトビルダーはゲッターの本文を組み立てます。
  • On a parameter in a function declaration, the result builder builds the body of a closure that’s passed as the corresponding argument. 関数宣言のパラメータ上で、リザルトビルダーは、対応する引数として渡されるクロージャの本文を組み立てます。

Applying a result builder attribute doesn’t impact ABI compatibility. Applying a result builder attribute to a parameter makes that attribute part of the function’s interface, which can effect source compatibility. リザルトビルダー属性を適用することは、ABI互換性に影響を与えません。リザルトビルダー属性をあるパラメータに適用することは、その属性を関数のもつインターフェイスの一部にします、それはソース互換性に影響を及ぼす可能性があります。

requires_stored_property_inits

Apply this attribute to a class declaration to require all stored properties within the class to provide default values as part of their definitions. This attribute is inferred for any class that inherits from NSManagedObject. この属性をあるクラス宣言に適用することで、そのクラス内の全ての格納プロパティに、省略時の値をそれら宣言の一部として提供することを要求してください。この属性は、NSManagedObjectから継承されるあらゆるクラスに対して伴われます。

testable

Apply this attribute to an import declaration to import that module with changes to its access control that simplify testing the module’s code. Entities in the imported module that are marked with the internal access-level modifier are imported as if they were declared with the public access-level modifier. Classes and class members that are marked with the internal or public access-level modifier are imported as if they were declared with the open access-level modifier. The imported module must be compiled with testing enabled. この属性をあるimport宣言に適用することで、そのモジュールのインポートをそれのアクセス制御への、モジュールの持つコードを試験するのを簡単にする変更とともに行ってください。internalアクセス水準修飾子で印されるインポートされたモジュールの中の存在それらは、まるでそれらがpublicアクセス水準修飾子で宣言されたかのようにインポートされます。internalまたはpublicアクセス水準修飾子で印されるクラスまたはクラスメンバーは、まるでそれらがopenアクセス水準修飾子で宣言されたかのようにインポートされます。インポートされたモジュールは、テストすることを可能にされてコンパイルされなければなりません。

UIApplicationMain

Apply this attribute to a class to indicate that it’s the application delegate. Using this attribute is equivalent to calling the UIApplicationMain function and passing this class’s name as the name of the delegate class. この属性をあるクラスに適用することで、それがアプリケーション委任先であることを指し示してください。この属性を使用することは、UIApplicationMain関数を呼んで、このクラスの名前を委任先クラスの名前として渡すことに相当します。

If you don’t use this attribute, supply a main.swift file with code at the top level that calls the UIApplicationMain(_:_:_:_:) function. For example, if your app uses a custom subclass of UIApplication as its principal class, call the UIApplicationMain(_:_:_:_:) function instead of using this attribute. あなたがこの属性を使わないならば、UIApplicationMain(_:_:_:_:)関数を呼ぶトップレベルでのコードを持つmain.swiftファイルを提供してください。例えば、あなたのアプリがそれの主役クラス（プリンシパルクラス）としてUIApplicationのあつらえのサブクラスを使うならば、UIApplicationMain(_:_:_:_:)関数をこの属性を使用する代わりに呼んでください。

The Swift code you compile to make an executable can contain at most one top-level entry point, as discussed in Top-Level Code. あなたがコンパイルして実行可能にするSwiftコードは、最大で１つのトップレベルエントリポイントを持つことができます、トップレベル・コードで記述されるように。

usableFromInline

Apply this attribute to a function, method, computed property, subscript, initializer, or deinitializer declaration to allow that symbol to be used in inlinable code that’s defined in the same module as the declaration. The declaration must have the internal access-level modifier. A structure or class marked usableFromInline can use only types that are public or usableFromInline for its properties. An enumeration marked usableFromInline can use only types that are public or usableFromInline for the raw values and associated values of its cases. この属性を関数、メソッド、計算プロパティ、添え字、便宜イニシャライザ、またはデイニシャライザ宣言に適用することで、そのシンボルが、同じモジュールの中で宣言として定義されるインライン可能コードにおいて使用できるようにしてください。宣言は、internalアクセス水準修飾子を持たなければなりません。usableFromInlineで印される構造体またはクラスは、それのプロパティに対してパブリックまたはusableFromInlineである型のみに使用できます。usableFromInlineで印される列挙は、生の値およびそれの列挙節の関連値に対してパブリックまたはusableFromInlineである型のみに使用できます。

Like the public access-level modifier, this attribute exposes the declaration as part of the module’s public interface. Unlike public, the compiler doesn’t allow declarations marked with usableFromInline to be referenced by name in code outside the module, even though the declaration’s symbol is exported. However, code outside the module might still be able to interact with the declaration’s symbol by using runtime behavior. publicアクセス水準修飾子のように、この属性は宣言をモジュールの公開インターフェイスの一部として露出します。publicとは違い、コンパイラはusableFromInlineで印される宣言に名前によってモジュール外部のコードにおいて参照されるのを許しません、宣言のシンボルがエクスポートされるとしてもです。しかしながら、モジュール外部のコードは、依然として宣言のシンボルと実行時挙動を使うことによって相互作用可能かもしれません。

Declarations marked with the inlinable attribute are implicitly usable from inlinable code. Although either inlinable or usableFromInline can be applied to internal declarations, applying both attributes is an error. inlinable属性で印される宣言は、暗黙的にインライン可能コードから利用可能です。けれどもinlinableまたはusableFromInlineのどちらかは、internal宣言に適用できます、両方の属性を適用することはエラーです。

warn_unqualified_access

Apply this attribute to a top-level function, instance method, or class or static method to trigger warnings when that function or method is used without a preceding qualifier, such as a module name, type name, or instance variable or constant. Use this attribute to help discourage ambiguity between functions with the same name that are accessible from the same scope. この属性をトップレベルの関数、インスタンスメソッド、もしくはクラスまたは静的メソッドに適用することで、その関数またはメソッドが、例えばモジュール名、型名、またはインスタンス変数や定数など、先行する修飾語無しで使われる場合に警告を引き起こしてください。この属性を使って、関数とその同じスコープからアクセス可能な同じ名前との間の曖昧さを防止するのに役立ててください。

For example, the Swift standard library includes both a top-level min(_:_:) function and a min() method for sequences with comparable elements. The sequence method is declared with the warn_unqualified_access attribute to help reduce confusion when attempting to use one or the other from within a Sequence extension. 例えば、Swift標準ライブラリはトップレベルのmin(_:_:)関数と比較可能要素を持つシーケンスに対するmin()メソッドの両方を持ちます。シーケンスメソッドは、warn_unqualified_access属性で宣言されることで、一方または他方を使うことをあるSequence拡張内から試みる時に混乱を減らすのを助けます。

Declaration Attributes Used by Interface Builder インターフェイスビルダーで使用される宣言属性

Interface Builder attributes are declaration attributes used by Interface Builder to synchronize with Xcode. Swift provides the following Interface Builder attributes: IBAction, IBSegueAction, IBOutlet, IBDesignable, and IBInspectable. These attributes are conceptually the same as their Objective-C counterparts. いくつかのインターフェイスビルダー属性は、Xcodeと同期するためにインターフェイスビルダーによって使用される宣言属性です。スウィフトは、以下のインターフェイスビルダー属性を提供します：IBAction、IBSegueAction、IBOutlet、IBDesignable、そしてIBInspectable。これらの属性は、概念的にそれらのObjective-Cでの対応物と同じものです。

You apply the IBOutlet and IBInspectable attributes to property declarations of a class. You apply the IBAction and IBSegueAction attribute to method declarations of a class and the IBDesignable attribute to class declarations. あなたは、IBOutletとIBInspectable属性をクラスのプロパティ宣言に適用します。あなたは、IBActionとIBSegueAction属性をクラスのメソッド宣言に、そしてIBDesignable属性をクラス宣言に適用します。

Applying the IBAction, IBSegueAction, IBOutlet, IBDesignable, or IBInspectable attribute also implies the objc attribute. IBAction、IBSegueAction、IBOutlet、IBDesignable、またはIBInspectable属性を適用することはまた、暗黙的にobjc属性を伴います。

Type Attributes 型属性

You can apply type attributes to types only. あなたは、型属性を型だけに適用することができます。

autoclosure

Apply this attribute to delay the evaluation of an expression by automatically wrapping that expression in a closure with no arguments. You apply it to a parameter’s type in a function or method declaration, for a parameter whose type is a function type that takes no arguments and that returns a value of the type of the expression. For an example of how to use the autoclosure attribute, see Autoclosures and Function Type. この属性を適用することで、ある式の評価の延期を、自動的にその式を引数なしクロージャの中にラップすることによって行ってください。あなたはそれを、関数またはメソッドの宣言の中であるパラメータの持つ型へと適用します、あるパラメータでそれの型が関数型のものに対して、それは引数を取らずそしてそれは式の型のひとつの値を返すものです。autoclosure属性を使用する方法の例として、自動クロージャと関数型を見てください。

convention

Apply this attribute to the type of a function to indicate its calling conventions. この属性を関数の型に適用して、それの呼出規約を示してください。

The convention attribute always appears with one of the following arguments: convention属性は常に以下の引数の１つと共に現れます：

  • The swift argument indicates a Swift function reference. This is the standard calling convention for function values in Swift. swift引数はあるスウィフト関数参照を指し示します。これは、スウィフトにおける関数値のための標準的な呼出規約です。
  • The block argument indicates an Objective-C compatible block reference. The function value is represented as a reference to the block object, which is an id-compatible Objective-C object that embeds its invocation function within the object. The invocation function uses the C calling convention. block引数は、Objective-C互換ブロック参照を指し示します。この関数値はそのブロックオブジェクトへの参照として表現されます、それはid互換Objective-Cオブジェクトで、それの呼出関数がそのオブジェクト内部に埋め込まれます。この呼出関数はC呼出規約を使います。
  • The c argument indicates a C function reference. The function value carries no context and uses the C calling convention. c引数は、C関数参照を指し示します。関数値は、コンテキストを持ち運びません、そしてC呼出規約を使います。

With a few exceptions, a function of any calling convention can be used when a function any other calling convention is needed. A nongeneric global function, a local function that doesn’t capture any local variables, or a closure that doesn’t capture any local variables can be converted to the C calling convention. Other Swift functions can’t be converted to the C calling convention. A function with the Objective-C block calling convention can’t be converted to the C calling convention. 2、3の例外がありますが、何らかの呼出規約の関数は、何らかの他の呼出規約の関数が必要とされる場合に使用可能です。非総称体グローバル関数、何らローカル変数をキャプチャしないローカル関数、または何らローカル変数をキャプチャしないクロージャは、C呼出規約に変換されることが可能です。他のスウィフト関数は、C呼出規約に変換されることはできません。Objective-Cブロック呼出規約での関数は、C呼出規約に変換されることはできません。

escaping

Apply this attribute to a parameter’s type in a function or method declaration to indicate that the parameter’s value can be stored for later execution. This means that the value is allowed to outlive the lifetime of the call. Function type parameters with the escaping type attribute require explicit use of self. for properties or methods. For an example of how to use the escaping attribute, see Escaping Closures. この属性をパラメータのもつ型に対して関数やメソッドの宣言において適用して、そのパラメータのもつ値がその後の実行のために保管されることができるのを指し示してください。これは、その値が呼び出しのライフタイムより長生きするのを許されることを意味します。escaping型属性を持つ関数型パラメーターは、明示的なself.の使用をプロパティやメソッドに対して必要とします。escaping属性を使う方法の例として、脱出クロージャを見てください。

Switch Case Attributes スイッチケース節属性

You can apply switch case attributes to switch cases only. あなたは、スイッチケース節属性をスイッチケース節のみに適用できます。

unknown

Apply this attribute to a switch case to indicate that it isn’t expected to be matched by any case of the enumeration that’s known at the time the code is compiled. For an example of how to use the unknown attribute, see Switching Over Future Enumeration Cases. この属性をスイッチケース節に適用して、コードがコンパイルされる時点で既知である列挙のどんなケース節によってもそれが合致されることは期待されないことを指し示してください。unknown属性を使う方法の例のために、未来列挙ケース節に対してスイッチするを見てください。

Grammar of an attribute 属性の文法

attribute → @ attribute-name attribute-argument-clause opt

attribute-name → identifier

attribute-argument-clause → ( balanced-tokens opt )

attributes → attribute attributes opt

balanced-tokens → balanced-token balanced-tokens opt

balanced-token → ( balanced-tokens opt )

balanced-token → [ balanced-tokens opt ]

balanced-token → { balanced-tokens opt }

balanced-token → Any identifier, keyword, literal, or operator 任意の識別子、キーワード、リテラル、または演算子

balanced-token → Any punctuation except (, ), [, ], {, or } 任意の句読点、しかし(, ), [, ], {, または }を除く

Declarations 宣言

Patterns パターン