Swift 6.0 beta 日本語化計画　: Swift 6.0 beta


属性


宣言と型に情報を追加します。


Swift には、宣言に適用される属性と型に適用される属性の 2 種類の属性があります。属性は、宣言または型に関する追加情報を提供します。たとえば、関数宣言の discardableResult 属性は、関数が値を返すにもかかわらず、戻り値が使用されていない場合にコンパイラが警告を生成するべきではないことを示します。


属性の名前と、属性が受け入れるすべての引数が続く @ 記号を書くことで属性を指定します。


@<#attribute name#>

@<#attribute name#> ( <#attribute arguments#> )



いくつかの宣言属性は、属性と、それが特定の宣言にいかに適用するかに関する詳細な情報を指定する引数を受け入れます。これらの 属性の引数 は括弧で囲まれており、その形式は、所属する属性によって定義されます。


付属した (attached) マクロとプロパティラッパーも属性構文を使用します。マクロの展開方法については、マクロ展開式 を参照してください。プロパティ ラッパーについては、propertyWrapper を参照してください。


宣言の属性


宣言にだけ宣言の属性を適用できます。


attached


attached 属性をマクロ宣言に適用します。この属性の引数はマクロの役割を示します。複数の役割を持つマクロの場合は、attached マクロを役割ごとに 1 回ずつ複数回適用します。


この属性への最初の引数はマクロの役割を示します。


Peer macros

この属性への最初の引数として peer を記述します。マクロを実装する型は、PeerMacro プロトコルに準拠します。これらのマクロは、マクロが付属している (attached) 宣言と同じスコープで新しい宣言を生成します。たとえば、構造体のメソッドに peer マクロを適用すると、その構造体に追加のメソッドとプロパティを定義できます。


Member macros

この属性への最初の引数として member を記述します。マクロを実装する型は、MemberMacro プロトコルに準拠します。これらのマクロは、マクロが付属してている型または拡張機能のメンバーである新しい宣言を生成します。たとえば、構造体宣言に member マクロを適用すると、その構造体に追加のメソッドとプロパティを定義できます。


Member attribute

この属性の最初の引数として memberAttribute を記述します。マクロを実装する型は、MemberAttributeMacro プロトコルに準拠します。これらのマクロは、マクロが付属している型または拡張機能のメンバーに属性を追加します。


Accessor Macros

この属性への最初の引数として accessor を記述します。マクロを実装する型は、AccessorMacro プロトコルに準拠します。これらのマクロは、付属している格納されたプロパティに accessor を追加し、計算されたプロパティに変換します。


Extension macros

この属性への最初の引数として extension を記述します。マクロを実装する型は、ExtensionMacro プロトコルに準拠します。これらのマクロは、プロトコル準拠、where 句、およびマクロが付属されている型のメンバーである新しい宣言を追加できます。マクロがプロトコル準拠を追加する場合は、 conformances: 引数を含めて、それらのプロトコルを指定します。準拠リストには、プロトコル名、準拠リスト項目を参照する型エイリアス、または準拠リスト項目のプロトコル構成が含まれます。ネストされた型の extension マクロは、そのファイルの最上位レベルの拡張機能に展開されます。拡張機能、型エイリアス、または関数内にネストされた型に extension マクロを記述したり、extension マクロを使用して peer マクロを持つ拡張機能を追加したりすることはできません。


peer, member, および accessor マクロの役割には、マクロが生成するシンボルの名前をリストする names: 引数が必要です。マクロが <extension 内に宣言を追加する場合、extension マクロの役割にも names: 引数が必要です。マクロ宣言に names: 引数が含まれている場合、マクロの実装では、そのリストに一致する名前を持つシンボルのみを生成しなければなりません。ただし、マクロはリストされているすべての名前に対してシンボルを生成する必要はありません。その引数の値は、以下の 1 つ以上のリストです。


  • named(<#name#>) は、name が固定シンボル名で、事前にわかっている名前の場合です。

  • 既存のシンボルと同じ名前の場合は、overloaded です。

  • prefixed(<#prefix#>) は、prefix がシンボル名の前に付加され、固定した文字列で始まる名前の場合です。

  • suffixed(<#suffix#>) は、固定した文字列で終わる名前の場合、シンボル名に suffix が追加されます。

  • マクロ展開まで決定できない名前の場合は、arbitrary です。

    • 特別なケースとして、プロパティラッパーと同様に動作するマクロに prefixed ($) を記述できます。


    available

      特定の Swift 言語のバージョンまたは特定のプラットフォームとオペレーティング·システムのバージョンに、宣言の寿命を相対的に示すために、この属性を適用します。


      available 属性は、常に２つ以上のカンマで区切られた属性引数のリストで表わされます。これらの引数は、以下のプラットフォームまたは言語の名前のいずれか一つで始まります。


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

      アスタリスク(*) を使用して、上にリストしたすべてのプラットフォーム名上の宣言の使用可能である事を示すこともできます。Swift のバージョン番号を使用して利用可能性を指定する available 属性は、アスタリスクを使用できません。


      残りの引数は、任意の順序で表示でき、重要なマイルストーンを含む宣言の寿命に関する追加情報を指定できます。


      • unavailable 引数は、宣言が指定されたプラットフォーム上では利用できないことを示します。この引数は、Swift バージョンの利用可能性を指定するときには使用できません。

      • introduced 引数は、宣言が導入された指定のプラットフォームまたは言語の最初のバージョンを示します。これは以下の形式です：

        • introduced: <#version number#>


        version number (バージョン番号) は、１つから３つの正の整数で構成されており、ピリオドで区切られています。


      • deprecated 引数は、宣言が廃止された、指定のプラットフォームまたは言語の最初のバージョンを示します。これは以下の形式です：

        • deprecated: <#version number#>


        オプションの version number (バージョン番号) は、１つから３つの正の整数で構成されており、ピリオドで区切られています。バージョン番号を省略すると、廃止が起こった時点を示すことなく、宣言が現在廃止されていることが示されます。バージョン番号を省略した場合は、コロン(:) も省略してください。


      • obsoleted 引 数は、宣言が旧式となった、指定のプラットフォームまたは言語の最初のバージョンを示します。宣言が旧式になると、それは指定されたプラットフォームまたは言語から削除され、使用できなくなります。この形式は以下のとおりです。

        • obsoleted: <#version number#>


        version number (バージョン番号) は、１つから３つの正の整数で構成されており、ピリオドで区切られています。


      • message 引数は、廃止されたまたは旧式の宣言の使用に関する警告やエラーを発するときに、コンパイラによって表示されるテキストメッセージを提供します。これは以下の形式です：

        • message: <#message#>


        message(メッセージ) は文字列リテラルで構成されています。


      • renamed 引数は、名前が変更された宣言の新しい名前を示すテキストメッセージを提供します。名前を変更した宣言の使用に関するエラーを発するときには、新しい名前がコンパイラによって表示されます。これは以下の形式です：

        • renamed: <#new name#>


        new name(新しい名前) は、文字列リテラルで構成されています。


        以下に示すように、 renamed 引数と unavailable 引数を指定して available 属性を型エイリアス宣言に適用して、フレームワークまたはライブラリのリリース間で宣言の名前が変更されたことを示すことができます。この組み合わせにより、宣言の名前が変更されたというコンパイル時エラーが発生します。


        1. // First release
        2. protocol MyProtocol {
        3. // protocol definition
        4. }

        1. // Subsequent release renames MyProtocol
        2. protocol MyRenamedProtocol {
        3. // protocol definition
        4. }
        6. @available(*, unavailable, renamed:"MyRenamedProtocol")
        7. typealias MyProtocol = MyRenamedProtocol

      異なるプラットフォーム上および Swift の異なるバージョンで宣言の利用可能性を指定するために、一つの宣言上で複数の available 属性を適用できます。available 属性が適用される宣言は、属性が現在のターゲットと一致しないプラットフォームまたは言語のバージョンを指定する場合は無視されます。available 属性を複数使用する場合、有効な利用可能性はプラットフォームと Swift の利用可能性の組み合わせです。


      available 属性が、プラットフォーム名または言語名の引数に加えて introduced 引数だけを指定している場合は、以下の省略構文を代わりに使用できます。


      @available(<#platform name#> <#version number#>, *)

      @available(swift <#version number#>)


      available 属性の省略構文により、複数のプラットフォームの利用可能性を簡潔に表現できます。２つの形式は機能的に同等ですが、可能であれば省略形式が常に好まれます。


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

      Swift のバージョン番号を使用して利用可能性を指定する available 属性では、宣言のプラットフォームの利用可能性を追加で指定することはできません。代わりに、Swift バージョンの利用可能性と 1 つ以上のプラットフォームの利用可能性を指定するために、別の available 属性を使用してください。


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


      backDeployed


      この属性を関数、メソッド、サブスクリプト、または計算されたプロパティに適用すると、シンボルの実装のコピーが、シンボルを呼び出したりアクセスしたりするプログラムに含まれます。この属性は、オペレーティングシステムに含まれている API など、プラットフォームの一部として出荷されるシンボルに注釈を付ける場合に使用します。この属性は、シンボルにアクセスするプログラムに実装のコピーを含めることで、遡及的に使用できるシンボルをマークします。実装をコピーすることは、クライアントへの出力 とも呼ばれます。


      この属性は before: 引数を取り、このシンボルを提供するプラットフォームの最初のバージョンを指定します。これらのプラットフォームバージョンは、available 属性に指定したプラットフォームバージョンと同じ意味を持ちます。available 属性とは異なり、リストにはすべてのバージョンを参照するアスタリスク (*) を含めることはできません。たとえば、以下のコードを考えてみましょう。


      1. @available(iOS 16, *)
      2. @backDeployed(before: iOS 17)
      3. func someFunction( ) { /* ... */ }

      上記の例では、iOS SDK は iOS 17 以降で someFunction( ) を提供します。さらに、SDK はバックデプロイメントを使用して someFunction( ) を iOS 16 で利用できるようにします。


      この関数を呼び出すコードをコンパイルすると、Swift は関数の実装を見つける間接レイヤーを挿入します。この関数を含む SDK のバージョンを使用してコードを実行すると、SDK の実装が使用されます。それ以外の場合は、呼び出し元に含まれるコピーが使用されます。上記の例では、someFunction( ) を呼び出すと、iOS 17 以降で実行している場合は SDK の実装が使用され、iOS 16 で実行している場合は、呼び出し元に含まれる someFunction( ) のコピーが使用されます。


      注意 呼び出し元の最小配置ターゲットが、シンボルを含む SDK の最初のバージョンと同じかそれより大きい場合、コンパイラは実行環境チェックを最適化して SDK の実装を直接呼び出すことができます。この場合、バックデプロイされたシンボルに直接アクセスすると、コンパイラはクライアントからのシンボルの実装のコピーを省略することもできます。

      以下の基準を満たす関数、メソッド、サブスクリプト、計算されたプロパティは、バックデプロイできます。


    • 宣言は public または @usableFromInline です。

    • クラスのインスタンスメソッドとクラスの型メソッドの場合、メソッドは final としてマークされ、@objc としてマークされていません。

    • 実装は、inlinable で説明したインライン化可能な関数の要件を満たしています。

      • discardableResult


        この属性を関数またはメソッド宣言に適用すると、その結果を使用せずに、値を返す関数またはメソッドが呼び出されたときに、コンパイラの警告が表示されなくなります。


      dynamicCallable


        この属性をクラス、構造体、列挙型、またはプロトコルに適用して、その型のインスタンスを呼び出し可能な関数として処理します。この型は、dynamicallyCall(withArguments:) メソッド、 dynamicallyCall(withKeywordArguments:) メソッド、またはその両方を実装しなければなりません。


        動的に呼び出し可能な型のインスタンスは、任意の数の引数を取る関数のように呼び出すことができます。


      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])


        dynamicallyCall(withArguments:) メソッドの宣言は、 ExpressibleByArrayLiteral プロトコルに準拠する単一のパラメータを持たなければなりません。上記の例の [Int] のように。戻り値の型は任意の型にすることができます。


        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


          dynamicallyCall(withKeywordArguments:) メソッドの宣言は、 ExpressibleByDictionaryLiteral プロトコルに準拠した単一のパラメータを持たねばならず、戻り値の型は任意の型にすることができます。パラメータの Key は ExpressibleByStringLiteral でなければなりません。以前の例では、KeyValuePairs をパラメータ型として使用しているため、呼び出し元は重複するパラメータラベルを含めることができます。a と b は、呼び出しで複数回 repeat のため現れます。


          両方の dynamicallyCall メソッドを実装する場合、メソッド呼び出しにキーワード引数が含まれるときには dynamicallyCall(withKeywordArguments:) が呼び出されます。それ以外の場合は、 dynamicallyCall(withArguments:) が呼び出されます。


          動的呼び出し可能インスタンスは、dynamicallyCall メソッド実装の 1 つで指定した型と一致する引数と戻り値を使用してのみ呼び出すことができます。以下の例の呼び出しは、KeyValuePairs<String,String> をとる dynamicallyCall(withArguments:) の実装がないため、コンパイルされません。


        repeatLabels(a: "four") // Error



        dynamicMemberLookup


          この属性をクラス、構造体、列挙型、またはプロトコルに適用して、実行時にメンバーを名前で検索できるようにします。型は subscript(dynamicMember:) サブスクリプトを実装しなければなりません。


          明示的なメンバ式では、名前付きのメンバに対応する宣言がない場合、式は型の subscript(dynamicMember:) サブスクリプトへの呼び出しとして解釈され、メンバに関する情報を引数として渡します。サブスクリプトは、キーパスまたはメンバー名のいずれかのパラメータを受け入れることができます。両方のサブスクリプトを実装する場合、キーパス引数を取るサブスクリプトが使用されます。


          subscript(dynamicMember:) の実装は、KeyPath、WritableKeyPath、または ReferenceWritableKeyPath 型の引数を使用してキーパスを受け入れることができます。ExpressibleByStringLiteral プロトコルに準拠する型の引数 (ほとんどの場合は String) を使用して、メンバ名を受け入れることができます。サブスクリプトの戻り値の型は任意です。


          メンバ名による動的メンバ検索を使用すると、他の言語から Swift にデータをブリッジするときなど、コンパイル時に型チェックできないデータの周りに包み込まれた型を作成できます。例えば：


        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"
        16. // Call the underlying subscript directly.
        17. let equivalent = s[dynamicMember: "someDynamicMember"]
        18. print(dynamic == equivalent)
        19. // Prints "true"

        キーパスによる動的メンバルックアップを使用して、コンパイル時の型チェックをサポートする方法で包み込む型を実装できます。例えば：


        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)


        freestanding


        freestanding マクロの宣言に freestanding 属性を適用します。


        frozen

          この属性を構造体または列挙型宣言に適用して、型に加えることができる変更の種類を制限できます。この属性は、ライブラリエボリューション (library evolution) モードでコンパイルする場合にのみ許可されます。ライブラリの将来のバージョンでは、列挙型のケースまたは構造体の格納されたインスタンスプロパティを追加、削除、または並べ替えて宣言を変更することはできません。これらの変更は、nonfrozen 型では許可されますが、frozen 型では ABI 互換性を壊します。


          注意： コンパイラがライブラリエボリューションモードでない場合、すべての構造体と列挙型は暗黙的に frozen であり、この属性は無視されます。


          ライブラリエボリューションモードでは、nonfrozen 構造体および列挙型のメンバを操作するコードは、ライブラリの将来のバージョンがその型のメンバの一部を追加、削除、または並べ替えても、再コンパイルせずに動作を継続できるようにコンパイルされます。コンパイラは、実行時に情報を検索したり、間接層を追加したりするなどの手法を使用してこれを可能にします。構造体または列挙型を frozen としてマークすると、パフォーマンスを得るためにこの柔軟性が失われます。ライブラリの将来のバージョンでは、型に対して限られた変更しか行えませんが、コンパイラは、型のメンバを操作するコードで追加の最適化を行うことができます。


          frozen (凍結) された型、凍結された構造体の格納されたプロパティの型、および凍結された列挙型のケースの関連値は、public であるか、useableFromInline 属性でマークされていなければなりません。凍結された構造体のプロパティにはプロパティ監視者を設定できません。また、格納されたインスタンスプロパティの初期値を提供する式は、inlinable で説明した inlinable 関数と同じ制限に従わなければなりません。


          コマンドラインでライブラリエボリューションモードを有効にするには、-enable-library-evolution オプションを Swift コンパイラに渡します。Xcode で有効にするには、Xcode ヘルプ の説明に従って、"配布用ビルドライブラリ" のビルド設定 (BUILD_LIBRARY_FOR_DISTRIBUTION)を Yes に設定します。


          将来の列挙型 case の切り替え で説明されているように、frozen の列挙型の switch 文には default の case は必要ありません。frozen の列挙型を切り替えるときに default または @unknown default case を含めると、そのコードは決して実行されないため、警告が生成されます。


        GKInspectable


          この属性を適用して、カスタムの GameplayKit コンポーネントプロパティを SpriteKit エディタの UI に公開します。この属性を適用することは、objc 属性も伴います。


        inlinable


          この属性を関数、メソッド、計算されたプロパティ、サブスクリプト、コンビニエンス・イニシャライザ、またはデイニシャライザの宣言に適用して、その宣言の実装をモジュールの public インタフェースの一部として公開します。コンパイラは、呼び出し側サイトで、インライン化できるシンボルへの呼び出しをそのシンボルの実装のコピーに置き換えることができます。


          インライン化できるコードは、任意のモジュールで宣言されている open と public シンボルを操作でき、また、 usableFromInline 属性でマークされている同じモジュール内で宣言されている、internal シンボルを操作できます。インライン化できるコードは、private シンボルや fileprivate シンボルを操作することはできません。


          この属性は、関数内に入れ子にされている宣言、または fileprivate 宣言または private 宣言には適用できません。インライン化できる関数内で定義されている関数とクロージャは、この属性でマークすることはできませんが、暗黙的にはインライン可能です。


        main


          この属性を構造体、クラス、または列挙型宣言に適用して、プログラムフローの最上位のエントリポイントが含まれていることを示します。型は、引数を全くとらずに Void を返す main 型の関数を提供しなければなりません。例えば：


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

          main 属性の要件を説明する別の方法は、この属性を書き込む型が、以下の架空のプロトコルに準拠する型と同じ要件を満たさなければならないということです。


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

          実行可能ファイルを作成するためにコンパイルする Swift コードには、トップレベルのコード で説明したように、最大で 1 つのトップレベルのエントリポイントを含めることができます。


        nonobjc


          この属性をメソッド、プロパティ、サブスクリプト、またはイニシャライザの宣言に適用して、暗黙の objc 属性を抑制します。nonobjc 属性は、Objective-C で宣言を表すことは可能ですが、Objective-C コードで宣言を使用できないようにコンパイラに指示します。


          この属性を拡張機能に適用すると、objc 属性で明示的にマークされていない拡張機能のすべてのメンバに適用されるのと同じ効果があります。


          nonobjc 属性を使用して、objc 属性でマークされたクラス内のメソッドをブリッジするための循環性を解決し、objc 属性でマークされたクラス内のメソッドとイニシャライザのオーバーロードを許可します。


          nonobjc 属性でマークされたメソッドは、objc 属性でマークされたメソッドをオーバーライドできません。ただし、objc 属性でマークされたメソッドは、nonobjc 属性でマークされたメソッドをオーバーライドできます。同様に、nonobjc 属性でマークされたメソッドは、objc 属性でマークされたメソッドのプロトコル要件を満たすことはできません。


        NSApplicationMain


        廃止 この属性は廃止されました。代わりに main 属性を使用してください。Swift 6 では、この属性を使用するとエラーになります。

          クラスにこの属性を適用して、それはアプリケーションデリゲートであることを示します。この属性を使用するのは、NSApplicationMain(_:_:) 関数を呼び出すことと同じです。


          この属性を使用しない場合は、以下のように NSApplicationMain(_:_:) 関数を呼び出すコードを最上位レベルに含む main.swift ファイルを提供します。


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


          実行可能ファイルを作成するためにコンパイルする Swift コードには、トップレベルのコード で説明したように、最大で 1 つのトップレベルのエントリポイントを含めることができます。


        NSCopying


          クラスの格納された変数プロパティにこの属性を適用します。この属性では、プロパティのセッタはプロパティ自身の値の代わりに、copyWithZone(_:) メソッドで返されるプロパティの値の コピー を用いて合成されます。プロパティの型は NSCopying プロトコルに準拠していなければなりません。


          NSCopying 属性は、Objective-C の copy プロパティ属性と同様の動作をします。


        NSManaged


          この属性を、NSManagedObject から継承したクラスのインスタンスメソッドまたは格納された変数プロパティに適用し、コアデータが、関連する実体の説明に基づいて実行時に動的にその実装を提供することを示します。NSManaged 属性でマークされたプロパティの場合、コアデータはまた実行時にも格納場所を提供します。この属性を適用すると、objc 属性も伴います。


        objc


          Objective-C で表す事のできる、全ての宣言ー例えば、入れ子になっていないクラス、プロトコル、汎用でない列挙型 (整数の生の値型に制約される)、プロパティ及びクラスのメソッド (ゲッタとセッタを含む)、プロトコルおよびプロトコルの optional のメンバ、イニシャライザ、およびサブスクリプトにこの属性を適用します。objc 属性はコンパイラに、宣言は Objective-C のコードで使用可能であることを指示します。


          この属性を拡張機能に適用すると、nonobjc 属性で明示的にマークされていないその拡張機能のすべてのメンバに適用されるのと同じ効果があります。


          コンパイラは、Objective-C で定義された全てのクラスのサブクラスに objc 属性を暗黙的に追加します。ただし、サブクラスは汎用であってはならず、全ての汎用クラスから継承してはいけません。これらの基準を満たすサブクラスに objc 属性を明示的に追加して、後述するようにその Objective-C 名を指定することができます。objc 属性でマークされたプロトコルは、この属性でマークされていないプロトコルから継承できません。


          objc 属性は、以下の場合にも暗黙的に追加されます。


        • 宣言はサブクラスでのオーバーライドであり、スーパークラスの宣言には objc 属性があります。

        • この宣言は、objc 属性を持つプロトコルからの要件を満たしています。

        • 宣言には、IBAction、IBSegueAction、IBOutlet、IBDesignable、IBInspectable、NSManaged、 または GKInspectable 属性があります。

          列挙型に objc 属性を適用すると、それぞれの列挙型の case は、列挙型の名と case 名の連結として Objective-C のコードに公開されます。case 名の最初の文字は大文字になります。例えば、Swift の Planet 列挙型の venus という名前の case は PlanetVenus という名前の case として Objective-C のコードに公開されます。


          objc 属性は、オプションで単一の属性引数を受け取り、これは識別子で構成されます。識別子は、objc 属性が適用される実体の Objective-C に公開される名前を指定します。この引数を使用すると、クラス、列挙型、列挙型の case、プロトコル、メソッド、ゲッタ、セッタ、イニシャライザに名前を付けることができます。クラス、プロトコル、または列挙型の Objective-C 名を指定する場合は、Objective-C でのプログラミング (Programming with Objective-C) の 表記規則 (Conventions) に記載したように、名前に 3 文字の接頭辞を付けます。以下の例では、 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. }


        注意: objc 属性への引数は、その宣言の実行時名も変更できます。NSClassFromString(_:) (NSClassFromString(_:)) など、Objective-C 実行時環境を操作する関数を呼び出すとき、およびアプリの Info.plist ファイルでクラス名を指定するときには、実行時名を使用して下さい。引数を渡すことで名前を指定した場合、その名前は Objective-C コードの名前および実行時名として使用されます。引数を省略すると、Objective-C コードで使用される名前は Swift コードの名前と一致し、実行時名は名前をめちゃくちゃにする通常の Swift コンパイラ規則に従います。


        objcMembers


          この属性をクラス宣言に適用して、objc 属性をクラスのすべての Objective-C 互換メンバ、その拡張機能、そのサブクラス、およびそのサブクラスのすべての拡張機能に暗黙的に適用します。


          ほとんどのコードは、必要な宣言だけを公開するために、代わりに objc 属性を使用するべきです。多くの宣言を公開する必要がある場合は、それらを objc 属性を持つ拡張機能にグループ化することができます。objcMembers 属性は、Objective-C 実行時環境の内省機能を多用するライブラリにとって便利です。必要でないときに objc 属性を適用すると、バイナリサイズが大きくなり、パフォーマンスに悪影響を及ぼす可能性があります。


        preconcurrency


          厳密な同時実行チェックを抑制するには、この属性を宣言に適用します。この属性は、以下の種類の宣言に適用できます。


        • Imports

        • 構造体、クラス、アクター

        • 列挙型と列挙型の case

        • プロトコル

        • 変数と定数

        • サブスクリプト

        • イニシャライザ

        • 関数

          • インポート宣言では、この属性により、インポートされたモジュールの型を使用するコードの同時実行チェックの厳密さが緩和されます。具体的には、送信不可として明示的にマークされていないインポートされたモジュールの型は、送信可能な型を必要とするコンテキストで使用できます。


          他の宣言では、この属性により、宣言されているシンボルを使用するコードの同時実行チェックの厳密さが緩和されます。同時実行チェックが最小限のスコープ内でこのシンボルを使用すると、Sendable 要件やグローバルアクターなど、そのシンボルによって指定された同時実行関連の制約はチェックされません。


          この属性を以下のように使用すると、コードを厳密な同時実行チェックに移行しやすくなります。


          1. 厳密なチェックを有効にします。

          2. 厳密なチェックを有効にしていないモジュールのインポートに preconcurrency 属性を注釈として付けます。

          3. モジュールを厳密なチェックに移行した後、preconcurrency 属性を削除します。インポートの preconcurrency 属性が効果を持たなくなり、削除する必要がある場所について、コンパイラによって警告が表示されます。

          その他の宣言では、厳密なチェックに移行していないクライアントがまだある場合は、同時実行関連の制約を宣言に追加するときに、preconcurrency 属性を追加します。すべてのクライアントが移行したら、preconcurrency 属性を削除します。


          Objective-C からの宣言は、常に preconcurrency 属性でマークされているかのようにインポートされます。


        propertyWrapper


          この属性をクラス、構造体、または列挙型宣言に適用して、その型をプロパティラッパー (包み込むもの、 wrapper) として使用します。この属性を型に適用すると、型と同じ名前のカスタム属性が作成されます。その新しい属性をクラス、構造体、または列挙型のプロパティに適用して、ラッパー型のインスタンスを介してプロパティへのアクセスをラップ (wrap) します。この属性をローカルの格納された変数宣言に適用して、同じ方法で変数へのアクセスを包み込みます。計算された変数、グローバル変数、および定数ではプロパティラッパーを使用できません。


          ラッパーは、wrappedValue インスタンスプロパティを定義しなければなりません。プロパティの 包みこまれた値 は、このプロパティのゲッタとセッタが公開する値です。ほとんどの場合、wrappedValue は計算された値ですが、代わりに格納された値にすることもできます。ラッパーは、そのラップされた値に必要な、基礎となる保管場所を定義し管理します。コンパイラは、ラップされたプロパティの名前の前にアンダースコア(_ ) を接頭辞として付けることで、ラッパー型のインスタンスの保管場所を合成します。たとえば、someProperty のラッパーは _someProperty として格納されます。ラッパーの合成保管場所のアクセス制御レベルは private です。


          プロパティラッパーを持つプロパティには、willSet ブロックと didSet ブロックを含めることができますが、コンパイラの合成した get ブロックまたは set ブロックをオーバーライドすることはできません。


          Swift は、プロパティラッパーの初期化のために 2 つの形式のシンタックスシュガーを提供します。ラップされた値の定義で代入構文を使用して、代入の右辺の式をプロパティラッパーのイニシャライザの 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. }


          ラップされたプロパティの 投影値 は、プロパティラッパーが追加機能を公開するために使用できる 2 番目の値です。プロパティラッパー型の作成者は、その投影値の意味を決定し、投影値が公開するインターフェイスを定義する責任があります。プロパティラッパーから値を投影するには、 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


          この属性をクラス、構造体、列挙型に適用して、その型を結果ビルダーとして使用します。結果ビルダー は、入れ子にされたデータ構造体を段階的にビルドする型です。結果ビルダーを使用して、自然で宣言的な方法で入れ子にされたデータ構造を作成するためのドメイン固有言語 (DSL) を実装します。resultBuilder 属性の使用方法の例については、Result Builder を参照してください。


        Result-Building Methods


          Result Builder は、以下で説明する静的メソッドを実装します。Result Builder の機能はすべて静的メソッドを通じて公開されるため、その型のインスタンスを初期化する必要は全くありません。結果ビルダーは、buildBlock(_:) メソッド、または buildPartialBlock(first:) メソッドと buildPartialBlock(accumulated:next:) メソッドの両方を実装しなければなりません。DSL で追加機能を有効にするその他のメソッドはオプションです。結果ビルダー型の宣言には、実際にはプロトコル準拠を含める必要はありません。


          静的メソッドの説明では、プレースホルダーとして 3 つの型を使用します。Expression 型は Result Builder の入力の型のプレースホルダーであり、Component は部分的な結果 (result) の型のプレースホルダーであり、FinalResult は Result Builder が生成する結果の型のプレースホルダーです。これらの型を、Result Builder が使用する実際の型に置き換えます。結果構築 (result-building) メソッドで Expression または FinalResult の型を指定しない場合、デフォルトで Component と同じになります。


          結果構築メソッドは以下のとおりです。


          static func buildBlock(_ components: Component...) -> Component

            部分的な結果の配列を 1 つの部分的な結果に結合します。


          static func buildPartialBlock(first: Component) -> Component

            最初のコンポーネントから部分的な結果コンポーネントを構築します。一度に 1 つのコンポーネントのビルディングブロックをサポートするには、このメソッドと buildPartialBlock(accumulated:next:) の両方を実装します。buildBlock(_:) と比較すると、このアプローチでは、異なる数の引数を処理する汎用オーバーロードの必要性が減ります。


          結果ビルダーは、上記の 3 つのブロック構築メソッドをすべて実装できます。その場合、利用可能性によってどのメソッドが呼び出されるかが決まります。デフォルトでは、Swift は buildPartialBlock(first:) メソッドと buildPartialBlock(accumulated:next:) メソッドを呼び出します。代わりに Swift が buildBlock(_:) を呼び出すようにするには、buildPartialBlock(first:) と buildPartialBlock(accumulated:next:) に記述する利用可能性の前に、囲んでいる宣言を利用可能としてマークします。


          追加の結果構築メソッドは以下のとおりです。


          static func buildOptional(_ component: Component?) -> Component

            nil の可能性がある部分的な結果から部分的な結果を構築します。else 句を含まない if 文をサポートするには、このメソッドを実装します。


          static func buildEither(first: Component) -> Component

            その値が何らかの条件に応じて変化する部分的な結果を構築します。switch 文と、else 句を含む if 文をサポートするには、このメソッドと buildEither(second:) の両方を実装します。


          static func buildEither(second: Component) -> Component

            その値が何らかの条件に応じて変化する部分的な結果を構築します。switch 文と、else 句を含む if 文をサポートするには、このメソッドと buildEither(first:) の両方を実装します。


          static func buildArray(_ components: [Component]) -> Component

          部分結果の配列から部分結果を構築します。for ループをサポートするには、このメソッドを実装します。


          static func buildExpression(_ expression: Expression) -> Component

          式から部分的な結果を構築します。このメソッドを実装すると、前処理 (式を internal 型に変換するなど) を実行したり、使用サイトで型推論のための追加情報を提供したりできます。


          static func buildFinalResult(_ component: Component) -> FinalResult

          部分的な結果から最終的な結果を構築します。このメソッドは、部分的で最終的な結果に異なる型を使用する Result Builder の一部として実装することも、結果を返す前に結果に対して他の後処理を実行することもできます。


          static func buildLimitedAvailability(_ component: Component) -%gt Component

          利用可能性チェックを実行するコンパイラ制御文の外側で型情報を伝播または消去する部分的な結果を構築します。これを使用して、条件分岐間で異なる型情報を消去できます。


          たとえば、以下のコードは、整数の配列を構築する単純な Result Builder を定義します。このコードは、Component と 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 (結果の変換)


          以下の構文変換は再帰的に適用され、Result Builder 構文を使用するコードを Result Builder 型の静的メソッドを呼び出すコードに変換します。


          • Result Builder に buildExpression(_:) メソッドがある場合、各式はそのメソッドの呼び出しになります。この変換は常に最初に行われます。たとえば、以下の宣言は同等です。

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

          • 代入文は式のように変換されますが、( ) と評価されると理解されます。代入を具体的に処理するために、型 ( ) の引数を取る buildExpression(_:) のオーバーロードを定義できます。

          • 利用可能性条件をチェックする分岐文は、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. }

          ただし、このアプローチでは、利用可能性チェックを行うコードで問題が発生します。


          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>>>


          上記のコードでは、FutureText は DrawEither ジェネリック型の 1 つであるため、brokenDrawing 型の一部として表示されます。これにより、実行時に FutureText が使用できない場合、その型が明示的に使用されていない場合でも、プログラムがクラッシュする可能性があります。


          この問題を解決するには、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>>>


          • 分岐文は、buildEither(first:) メソッドと buildEither(second:) メソッドへの一連の入れ子にされた呼び出しになります。文の条件と case はバイナリツリーの葉のノードにマップされ、文は根のノードからその葉のノードへのパスをたどる buildEither メソッドへの入れ子にされた呼び出しになります。

            • たとえば、3 つの case を持つ switch 文を作成すると、コンパイラは 3 つの葉のノードを持つバイナリツリーを使用します。同様に、根のノードから 2 番目の case へのパスは "2 番目の子"、次は "最初の子" であるため、その case は buildEither(first: buildEither(next: ... )) のような入れ子にされた呼び出しになります。以下の宣言は同等です。


        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. }

        • else 節のない if 文など、値を生成しない分岐文は、buildOptional(_:) の呼び出しになります。if 文の条件が満たされる場合、そのコードブロックは変換され、引数として渡されます。それ以外の場合は、その引数として nil で buildOptional(_:) が呼び出されます。たとえば、以下の宣言は同等です。

          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)

        • 結果ビルダーが buildPartialBlock(first:) メソッドと buildPartialBlock(accumulated:next:) メソッドを実装する場合、コードブロックまたは do 文はこれらのメソッドへの呼び出しになります。ブロック内の最初の文は、buildPartialBlock(first:) メソッドへの引数になるように変換され、残りの文は buildPartialBlock(accumulated:next:) メソッドへの入れ子にされた呼び出しになります。たとえば、以下の宣言は同等です。

          1. struct DrawBoth<First: Drawable, Second: Drawable>: Drawable {
          2. var first: First
          3. var second: Second
          4. func draw( ) -> String { return first.draw( ) + second.draw( ) }
          5. }
          7. @resultBuilder
          8. struct DrawingPartialBlockBuilder {
          9. static func buildPartialBlock<D: Drawable>(first: D) -> D {
          10. return first
          11. }
          12. static func buildPartialBlock<Accumulated: Drawable, Next: Drawable>(
          13. accumulated: Accumulated, next: Next
          14. ) -> DrawBoth<Accumulated, Next> {
          15. return DrawBoth(first: accumulated, second: next)
          16. }
          17. }
          19. @DrawingPartialBlockBuilder var builderBlock: some Drawable {
          20. Text("First")
          21. Line(elements: [Text("Second"), Text("Third")])
          22. Text("Last")
          23. }
          25. let partialResult1 = DrawingPartialBlockBuilder.buildPartialBlock(first: Text("first"))
          26. let partialResult2 = DrawingPartialBlockBuilder.buildPartialBlock(
          27. accumulated: partialResult1,
          28. next: Line(elements: [Text("Second"), Text("Third")])
          29. )
          30. let manualResult = DrawingPartialBlockBuilder.buildPartialBlock(
          31. accumulated: partialResult2,
          32. next: Text("Last")
          33. )

        • それ以外の場合、コードブロックまたは do 文は buildBlock(_:) メソッドへの呼び出しになります。ブロック内の各文は 1 つずつ変換され、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. )

        • 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)

        • Result Builder に buildFinalResult(_:) メソッドがある場合、最終結果はそのメソッドへの呼び出しになります。この変換は常に最後に行われます。

          • 変換動作は一時変数の観点から説明されていますが、Result Builder を使用しても、コードの残りの部分から見える新しい宣言は実際には作成されません。


          Result Builder が変換するコードでは、break、continue、defer、guard、return 文、while 文、または do-catch 文を使用することはできません。


          変換プロセスではコード内の宣言は変更されないため、一時的な定数や変数を使用して式を少しずつ構築できます。また、throw 文、コンパイル時診断文、return 文を含むクロージャも変更されません。


          可能な限り、変換は合体します。たとえば、式 4 + 5 * 6 は、その関数を複数回呼び出すよりも、buildExpression(4 + 5 * 6) になります。同様に、入れ子にされた分岐文は、buildEither メソッドを呼び出す単一のバイナリツリーになります。


          Custom Result-Builder Attributes (カスタム結果ビルダー属性)


          Result Builder 型を作成すると、同じ名前のカスタム属性が作成されます。この属性は以下の場所に適用できます。


        • 関数宣言では、Result Builder が関数の本体を構築します。

        • ゲッタを含む変数またはサブスクリプト宣言では、Result Builder はゲッタの本体を構築します。

        • 関数宣言内のパラメータでは、Result Builder は、対応する引数として渡されるクロージャの本体を構築します。

          • Result Builder 属性を適用しても、ABI の互換性には影響しません。Result Builder 属性をパラメータに適用すると、その属性が関数のインターフェイスの一部となり、ソースの互換性に影響を与える可能性があります。


          requires_stored_property_inits


          この属性をクラス宣言に適用して、クラス内のすべての格納されたプロパティに定義の一部としてデフォルト値を提供するように要求します。この属性は、NSManagedObject から継承した全てのクラスに対して推測されます。


          testable


          この属性を import 宣言に適用して、モジュールのコードのテストを簡素化するそのアクセス制御への変更をそのモジュールにインポートします。internal アクセスレベル修飾子でマークされているインポートされたモジュール内の実体は、public アクセスレベル修飾子で宣言されているかのようにインポートされます。internal または public アクセスレベル修飾子でマークされたクラスとクラスメンバは、open アクセスレベル修飾子で宣言されているかのようにインポートされます。インポートされたモジュールは、テストを有効にしてコンパイルされなければなりません。


          UIApplicationMain


          廃止 この属性は廃止されました。代わりに main 属性を使用してください。Swift 6 では、この属性を使用するとエラーになります。

          それがアプリケーション・デリゲートであることを示すために、クラスにこの属性を適用します。この属性を使用するのは、UIApplicationMain 関数を呼び出して、デリゲートクラスの名前として、このクラスの名前を渡すことと同じです。


          この属性を使用しない場合は、UIApplicationMain(_:_:_:_:) (UIApplicationMain(_:_:_:_:)) 関数を呼び出す最上位レベルのコードで main.swift ファイルを指定して下さい。たとえば、アプリが UIApplication のカスタムサブクラスを principal クラスとして使用する場合、この属性を使用する代わりに UIApplicationMain(_:_:_:_:) 関数を呼び出します。


          トップレベルのコード で説明されているように、実行可能ファイルを作成するためにコンパイルする Swift コードには、トップレベルのエントリポイントを 1 つだけ含めることができます。


          unchecked


          この属性を、採用されたプロトコルの型宣言のリストの一部としてプロトコル型に適用すると、そのプロトコルの要件の適用が無効になります。


          サポートされているプロトコルは Sendable のみです。


        usableFromInline


        この属性を関数、メソッド、計算されたプロパティ、サブスクリプト、イニシャライザ、またはデイニシャライザの宣言に適用すると、宣言と同じモジュール内で定義されているインラインコードでそのシンボルを使用できます。宣言には internal アクセスレベル修飾子がなければなりません。usableFromInline とマークされた構造体またはクラスは、そのプロパティに public または usableFromInline の型のみを使用できます。usableFromInline とマークされた列挙型は、そのケースの生の値と関連する値に対して、public または usableFromInline である型のみを使用できます。


        public アクセスレベル修飾子と同様に、この属性は宣言をモジュールの public インターフェイスの一部として公開します。public とは異なり、コンパイラは、宣言のシンボルが export されていても、usageFromInline でマークされた宣言をモジュール外のコード内で名前で参照することを許可しません。ただし、モジュール外のコードは、実行時の動作を使用して宣言のシンボルを操作できる可能性があります。


        inlinable 属性でマークされた宣言は、inlinable (インライン化可能な) コードから暗黙的に使用可能です。inlinable または usableFromInline は internal 宣言に適用できますが、両方の属性を適用するとエラーになります。



        warn_unqualified_access


        この属性を最上位レベルの関数、インスタンスメソッド、クラス、または静的メソッドに適用すると、その関数またはメソッドが、モジュール名、型名、インスタンス変数、またはインスタンス定数などを前に付けずに使用された場合に警告を発します。この属性を使用すると、同じスコープ (scope) からアクセス可能な同じ名前の関数間のあいまいさを防ぐのに役立ちます。


        たとえば、Swift 標準ライブラリには、comparable (比較可能な) 要素で最上位レベルの min(_:_:) (min(_:_:)) 関数と シーケンスの min( ) メソッドの両方が含まれています。sequence メソッドは、warn_unqualified_access 属性を使用して宣言されているため、Sequence 拡張機能内から一方または他方を使用しようとしたときの混乱を減らすのに役立ちます。


        インターフェイスビルダーで使われる宣言属性


        インターフェイスビルダーの属性は、Xcode と同期するようにインターフェイスビルダーで使用される宣言属性です。Swift は、以下のインターフェースビルダーの属性を提供しています。IBAction, IBSegueAction, IBOutlet, IBDesignable, および IBInspectable です。これらの属性は、Objective-C で対応する物と概念的に同じです。


        IBOutlet と、IBInspectable 属性は、クラスのプロパティ宣言に適用されます。クラスのメソッド宣言には IBAction と IBSegueAction 属性を適用し、クラス宣言には IBDesignable 属性を適用して下さい。


        IBAction, IBSegueAction, IBOutlet, IBDesignable, または IBInspectable 属性を適用しても、objc 属性を含みます。


        型の属性


        型の属性は、型にだけ適用できます。


        autoclosure


        この属性は、引数なしでクロージャにその式を自動的に包み込むことにより、式の評価を遅延させるために適用されます。引数を取らず、式の型の値を返す関数型のパラメータ用に、関数またはメソッド宣言のパラメータの型にこの属性を適用して下さい。autoclosure 属性を使用する方法の例については、オートクロージャ 及び 関数型 を参照してください。


        convention


        この属性を関数の型に適用して、その呼び出し規約(convention)を示します。


        convention 属性は、常に以下の引数の１つと共に表示されます。


    • swift 引数は、Swift 関数の参照を示します。これは Swift の関数値の標準的な呼び出し規約です。

    • block 引数は、Objective-C 互換ブロックの参照を示します。関数値は、ブロックオブジェクトへの参照として表され、これは、オブジェクト内でのその呼び出し関数を埋め込む id 互換の Objective-C オブジェクトです。呼び出し関数は C の呼び出し規約を使用します。

    • c 引数は、C 関数の参照を示します。関数値は文脈を持たず、C 呼び出し規約を使用します。

      • いくつかの例外はありますが、他の呼び出し規約が関数に必要な場合は、任意の呼び出し規約の関数を使用できます。汎用でないグローバル関数、ローカル変数をキャプチャしないローカル関数、またはローカル変数をキャプチャしないクロージャは、C 呼び出し規約に変換できます。その他の Swift 関数は、C 呼び出し規約に変換できません。Objective-C ブロック呼び出し規約を持つ関数は、C 呼び出し規約に変換できません。


      escaping


      この属性を関数またはメソッド宣言内のパラメータの型に適用して、後で実行するためにパラメータの値を格納できることを示します。これは、値が呼び出しの寿命を超えて存続できることを意味します。escaping 型属性を持つ関数型パラメータでは、プロパティまたはメソッドの場合、self. を明示的に使用する必要があります。escaping 属性の使用例については、クロージャのエスケープ を参照してください。


      Sendable


      この属性を関数の型に適用して、関数またはクロージャが Sendable (送信可能) であることを示します。この属性を関数型に適用することは、非関数型を Sendable プロトコルに準拠させることと同じ意味を持ちます。


      この属性は、関数またはクロージャが送信可能な値を予期する文脈で使用され、関数またはクロージャが sendable (送信可能) であるための要件を満たしている場合に、関数およびクロージャで推論されます。


      送信可能な関数型は、対応する送信不可能な関数型のサブタイプです。



      Switch Case 属性


      switch case 属性は switch の case にのみ適用できます。


      unknown


      この属性を switch case に適用して、コードがコンパイルされた時点で既知の列挙型のいずれの case とも一致しないと予想されることを示します。unknown 属性の使用方法の例については、将来の列挙型 case の切り替え を参照してください。


      属性の文法

      attribute → @ attribute-name attribute-argument-clause?
      attribute-name → identifier
      attribute-argument-clause → ( balanced-tokens? )
      attributes → attribute attributes?

      balanced-tokens → balanced-token balanced-tokens?
      balanced-token → ( balanced-tokens? )
      balanced-token → [ balanced-tokens? ]
      balanced-token → { balanced-tokens? }
      balanced-token → Any identifier, keyword, literal, or operator
      balanced-token → Any punctuation except (, ) , [, ], {, or }


      前：宣言 次：パターン

      <BETA SOFTWARE>
      このドキュメントには、開発中の API または技術に関する予備的な情報が含まれています。この情報は変更されることがあり、このドキュメントに従って実装されたソフトウェアは、最終的なオペレーティングシステムソフトウェアでテストする必要があります。

      Apple の Beta ソフトウエアについての詳細
















      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ












      トップへ