Swiftの新機能

Swiftの新機能

Swiftに関するアップデートを確認しましょう。日々の作業における使いやすさの向上、並行処理の改善、高パフォーマンスのコードにおける安全性強化など、Swiftの最新の進化を紹介します。Embedded Swiftにおける、ワークフローや言語間の相互運用性の改善点やアップデートについても学びます。

関連する章
- 0:07 - Introduction
- 0:44 - Everyday Language Improvements
- 1:55 - anyAppleOS Availability
- 3:02 - @diagnose Attribute
- 3:52 - Module Selectors (::)
- 5:59 - Library Updates
- 6:16 - Standard Library
- 7:31 - Swift Testing Updates
- 9:29 - Subprocess 1.0
- 10:14 - Foundation
- 11:59 - Beyond Apple Platforms
- 12:35 - Swift–C Interoperability (@C attribute)
- 15:09 - Swift-Java
- 16:03 - Editor support
- 16:44 - WebAssembly (Wasm) & JavascriptKit
- 18:08 - Embedded Swift
- 19:59 - Performance Tuning
- 21:29 - Optimizer Control: @inline(always) & @specialized
- 24:29 - Ownership System & Noncopyable Types
- 26:18 - Iterable Protocol & Borrow/Mutate Accessors
- 28:57 - New Standard Library Types: UniqueBox, UniqueArray, Ref
- 31:11 - The Future of Swift
リソース
関連ビデオ

WWDC26
- gRPCとSwiftによるリアルタイムのアプリやサービスの構築
- Swift Testingへの移行
こんにちは Swiftチームの Beccaです。
チームメンバーのEvanと私からいくつかの改善点を紹介します Swift 6.3と6.4の開発で行った改善点です。まず言語への変更をいくつか紹介します日々のコーディングを効率化するものです。次にEvanが重要なライブラリのアップデートについて説明します XcodeやAppleプラットフォーム以外でのサポートの進展も紹介します。その後パフォーマンスをチューニングする専門的な機能を紹介します安全性を損なわずにパフォーマンス重視のコードに対応します。そして最後にEvanが Swiftの開発へのフォローや貢献方法をお伝えします。まず日々利用するシンプルな改善点から見ていきましょう。
ほとんど気づかないような小さな問題が解消されたものもありますまず小さな変更点から確認しましょう。たとえば以前はoptional型に someやanyを使う場合括弧で囲む必要がありました。 Swiftの演算子優先順位の規則によるものでしたがやや形式的すぎました。 Swift 6.4ではその括弧を省略できるようになりましたコンパイラは意図通りに解釈してくれます。エラーを暗黙的に無視すると警告が表示されるようになりました Swift Concurrencyのタスクからスローされたエラーの場合ですタスク内でエラーを処理するよう促しますまたはタスクを保存して後でエラーを確認します。 deferブロックからasync関数を呼び出せるようになりました。 @unchecked Sendableが必要なクラスがある場合 weak varプロパティを持つためであればそのプロパティをweak letに変更してイミュータブルにできます Sendableチェックを有効にできるようになります。型がSendableであるべきでない場合は新しいチルダSendable構文で明示的に宣言できます。サブクラスがSendableになることは妨げません。 internalとprivateプロパティが混在するstructは 2番目のメンバーワイズイニシャライザを持ちますプロジェクト内の他のファイルから使用できます。
確実に気づく変更点もあります。 Appleのエコシステムは過去20年で大きく成長しており SwiftコードのAvailability属性もそれに伴い増加しています。昨年Appleはこの問題に取り組み始めました OSリリースのバージョン番号を統一することで対応しました。 Swiftはさらにそれを発展させていますすべてのプラットフォーム名を "Any Apple OS"に集約できます。対象のすべてのプラットフォームで availabilityが一致するならすべてのOSを一度に指定できます例外がある場合はanyAppleOSでデフォルトを設定して例外に対してより具体的な属性を追加できます。 #if os条件でも同様に機能しますコードの一部を完全にコンパイル対象外にできます。年月とともに変化するものに APIもあります。進化に伴い古いAPIは非推奨になることがあります新しいバージョンへの移行を促すためです。しかしすぐに移行できない場合もあります新しいAPIが大きく異なり適応に時間が必要な場合です。一時的にこれらの警告を無効にできたら便利ではないでしょうかプロジェクトの他の部分に影響を与えずに。
それが可能になりました。 @diagnose属性を使うと特定の警告の動作を変更できます特定の宣言内で。 deprecated declarationの警告グループを無視するよう設定したりその箇所だけ警告を非表示にできます。デフォルトでオフの警告を選択的に有効にすることもできます。たとえばstrict memory safetyを有効にしてセキュリティクリティカルな関数で unsafe APIの使用を確認できます。または特定の警告をエラーとして扱えます。ここでは将来エラーになる警告をアップグレードして今すぐエラーとしています。これにより多くの柔軟性が得られます。 Swift 6.3には2つのモジュールが同じ名前のAPIを持つ場合により適切に処理する新機能があります。たとえばRocketモジュールに型があるとします実際の100メートル級の SaturnVロケットを表す型です一方GiftShopToysモジュールには子供サイズのSaturnVロケットのモデルを表す型があります。
同じファイルで両方のモジュールをインポートすると Swiftはどちらを使いたいか判断できずエラーになります。これを解決するにはドット構文を使う方法があります Rocket.SaturnVはまず Rocketモジュールを検索しその中でSaturnV型を探します他にSaturnVが存在しても影響を受けません。通常はこれで解決しますがうまくいかない場合もあります。たとえばRocketモジュールに Rocketという型もある場合はどうでしょう何が起きるか説明します Swiftは型名をモジュール名より優先しますそのためRocket型を指定していると判断しその中でSaturnVというメンバーを探します。見つからない場合はエラーになります。 Swift 6.3ではこの問題を解決するためにドットをダブルコロンに変更します。この新しい構文はモジュールセレクタと呼びます左側の名前は常にモジュール名として扱われます。 SwiftはRocket型を無視して Rocketモジュールに直接アクセスし目的の型を簡単に見つけられます。この構文はメソッドやプロパティ名にも使えます型が同じ名前のメソッドを持つ場合に便利です 2つの異なるモジュールの extensionから取得する場合です。間違ったメソッドを呼び出すと問題になりますから。モジュールセレクタは非常に便利です制御できない2つのモジュール間で競合がある場合に役立ちます。たとえばSwiftUIと使用中のパッケージが両方View型を持つ場合モジュールセレクタで問題を解消できます。また防御的に使うことも良い方法ですマクロ展開や自動生成コードでは特に有効ですプロジェクトに何がインポートされているか不明なためです。ただし名前の競合が生じるよう APIを意図的に設計することは推奨しませんモジュールセレクタで区別するために。コードが明確であってもエラーメッセージやドキュメントが分かりにくい場合があります。ですから、やめましょう。言語の新機能を確認したところで重要なライブラリのアップデートを Evanが紹介します。
これらの言語改善はすべて同じ目標を持っています余分なノイズなしに意図を正確に表現できるようにすることです。同じ目標が日々使うライブラリのアップデートにも引き継がれます。標準ライブラリ、Swift Testing、 Subprocess、Foundationです。
まず標準ライブラリのアップデートから見ていきましょう特にタスクキャンセルの新しいツールについてですディクショナリの変換とファイルパス操作も紹介します。タスクのキャンセル状態を確認することが重要ですが高コストな処理を開始する前に実際に処理を実行したい場合もありますタスクがキャンセルされた後でもファイルを破損しないようデータのディスク書き込みを完了する場合などです。タスクキャンセルシールドを使用できるようになりました。シールド内ではタスクキャンセルチェックが常にfalseを返します。この領域は短く保つことが重要です開始済みの処理を完了するかロールバックすることに集中します。ディクショナリのマッピングもアップデートされました。 mapValuesは古い値のみをマッピングクロージャに渡しますが新しい値の計算にキーが必要な場合手動で新しいディクショナリを構築する必要がありました。 mapKeyedValuesを呼び出せるようになりましたキーと古い値の両方をマッピングクロージャに渡して新しい値を計算します。プログラムはファイルパスを操作することが多くあります。プラットフォームごとのファイルパスの表現に微妙な差異があります正確に処理することが難しい場合があります。今年標準ライブラリに新しいfilepathの型を追加しました Swift Systemの型を基にしており正確な処理が容易になります。
Swift 6.4のテストではテストの動作をより細かく制御できます致命的でない問題の表示やテストケースの動的スキップが可能です。 Issue.recordで記録する問題の重大度レベルを設定できます。警告に設定すると調査する価値のある問題をテストケースに表示できます CIワークフローをブロックするほどではない問題です。 Test.cancel APIを呼び出すことでテストを動的にキャンセルできます。パラメータ化テストでは特に効果的です実行すべきでない個々の引数をキャンセルできますテストを最後まで実行したり失敗させたりせずに済みます。不安定なテストに対処することがあります。 swift testコマンドにテストを繰り返す新機能が追加されました成功または失敗するまで繰り返し回数の上限も制御できます。テストが成功するまで繰り返す設定にすると失敗したテストのみ再実行されます成功しているテストを再実行しないので時間を節約できます。多くのプロジェクトでは XCTest APIベースの大規模なテストスイートがあります Swift 6.4ではXCTestのアサーション失敗が問題として報告されます Swift Testingから呼び出された場合です。これによりSwift Testingへの移行が容易になります移行中にテストカバレッジが失われる心配がありません。相互運用性は逆方向でも機能します Swift Testingの#expectマクロ等は XCTestCaseからも機能します。 Swift Testingでヘルパー APIを構築でき一貫した動作が得られます XCTestとSwift Testingのどちらから呼び出しても同様です。既存のプロジェクトで作業している場合すでにSwift TestingからXCTestのアサーションを呼び出しているかもしれませんまたその逆も同様です。この移行を容易にするためにこれらの問題はデフォルトで警告として報告されます。 Xcodeのビルド設定でテスト失敗に昇格させることもできます。 Swift Testingの相互運用性や移行戦略の詳細については "Migrate to Swift Testing"をご覧ください。
昨年 Subprocessパッケージを発表しましたサブプロセスを起動するためのモダンなAPIを含んでいます。今年 Subprocess 1.0をリリースします実際の使用からいただいたフィードバックを取り込みました。 API改善には簡略化された実行タイプが含まれます改善されたエラー処理と出力ストリーミング用の便利なAPIです。クロスプラットフォームサポートも大幅に向上しましたプラットフォーム固有のプロセスディスクリプタや終了ステータスを含みます各プラットフォームのセマンティクスをより正確に反映します。 Subprocess 1.0の改善されたAPIの例です。 runメソッドを呼び出してサブプロセスを起動する場合標準出力と標準エラーのストリームは AsyncBufferSequenceとして実行オブジェクトに含められます。
このモデルでは各ストリームが 1度だけ作成されることが保証されます。 AsyncBufferSequenceの新しいstrings()メソッドでサブプロセスの出力を行ごとに読み取れます。このAPIは書記素クラスターの境界を遵守しますマルチバイト文字が分割される心配がありません。最後にFoundationの改善について見ていきましょう。 ProgressManagerは Foundationの新しい進捗報告タイプです。 async/awaitスタイルの並行処理とうまく連携するよう設計されており進捗の構成と報告を明確に分離します構造化されていて追加メタデータを添付するための型安全なメカニズムを提供します。 2年前にSwift-Foundationを発表しました Foundationを安全で一貫した Swiftで書かれたクロスプラットフォームコードベースに移行する取り組みです。今年もその取り組みを続け何十年ものObjective-CをモダンなSwiftに置き換えています。今年はDataの多くの部分を最新化しました全体的な改善につながりました spanアクセス、等価確認、イテレーション、変更処理が高速化されました。 AppleプラットフォームでのDataと NSData間のブリッジも高速化されました。 NSURLとCFURLが統一され単一のSwift実装になりました。 Swiftを活用することでこれらの型は高速化しメモリ使用量も削減されます。 Foundationのような大規模で成熟したライブラリの移行は Swiftの言語相互運用性があるからこそ可能です。 Swiftで全く新しいAPIを追加したり移行することもできます APIサーフェスを変えずに既存APIの実装をSwiftに移行できます。言語の境界を越えることに加えて実際の多くのプロジェクトはサービス、デバイス、Webコンポーネントに広がりますクロスプラットフォームのクライアントなど多岐にわたります。
AppleではOSのあらゆる部分で Swiftを使用しています天気のようなアプリやリアルタイム通話スパム検出などのサービスでカーネル自体からファームウェアの最下層まで使用しています。 Swiftはあらゆる場面で使える言語として設計されておりソフトウェアスタックのあらゆる層に対応します。既存のソフトウェアシステムでより使いやすくするために Swift 6.4は言語の相互運用性を拡張しクロスプラットフォームIDEサポートを改善しより安全かつ容易に SwiftコードをWebや組み込みデバイス環境に持ち込めます。
これまでCをSwiftに簡単にインポートできました。 Swift 6.4ではSwiftで書いた関数を Cに公開できるようになりました。 @objc属性を見たり使ったりしたことがあるかもしれません Objective-CからSwiftへのアプリ移行時にです。 @C属性も同じように機能しますが C向けです。 @C属性はCと互換性のある型を操作する関数に適用します。 CからSwiftにインポートできる型は SwiftからCにエクスポートする関数でも使用できます例えば整数ポインタ、インポートしたCの構造体、 raw整数値型の列挙型などです。コンパイラは誤った型の受け渡しを防ぎます Cと非互換な型の場合です。 @C属性の実際の動作を見てみましょう。ロケット打ち上げをスケジュールするアプリを開発しています。打ち上げウィンドウを追跡するコードに注目します。現在Cで書かれていますがメモリ安全性とデベロッパエルゴノミクスの向上のためSwiftに移行しています。 Swift 6.4の新機能を使ってアプリのC部分を書き換えましょう。現在ヘッダーに 2つの関数が宣言されています 1つは打ち上げウィンドウの長さを取得するものもう1つは複数の打ち上げウィンドウで費やした合計時間を計算するものです発射台の稼働率を計算できます。 Cの実装を置き換えることから始めましょう打ち上げウィンドウの長さを計算する関数の実装です。 @cと@implementation属性を組み合わせて使うことで C宣言を作成せずに C関数を実装できます元のヘッダーファイルにすでに存在しているためです。次に計算する関数の実装を提供します複数の打ち上げウィンドウでの合計滞在時間を計算します。 Swiftで実装する際は関数がそのままインポートされます。型をネイティブのSwift型に変換できます SwiftのエルゴノミクスでC関数を再実装できます。セーフinterop機能は関数呼び出し時に安全なラッパーを提供します配列とカウントを別々に渡す代わりに spanを渡せます。書きやすく安全です！作業中に打ち上げウィンドウの平均長を取得する新しい関数を追加したいと思います。ここでは@implementation属性は使用しません元のCヘッダーに関数が宣言されていないためです。 Swiftコンパイラは適切な関数宣言を生成されたCに出力します interopヘッダーに代わりに出力するため Cコードから新しい関数を呼び出せます。 SwiftはSwift SpanをCに自動的にブリッジします。また Swift C++相互運用性でも SwiftとC++ 20のspanをブリッジできます。この宣言はspanでSwiftにインポートされ直接渡せます。
相互運用性が重要です他の言語で書かれた既存コードベースへのSwift導入に。 Swift-JavaはSwiftとJava間の相互運用を実現するパッケージです。 JavaからasyncやthrowingのSwift関数を呼び出せるようになりました。ジェネリクスシステムのより多くの機能をサポートします制約付きextensionなど JavaクラスをSwiftプロトコルに準拠させることも含みます。これらすべての改善により JavaやKotlinからSwiftコードを Androidでも自然に呼び出せます。 swift.orgからAndroid向け公式 Swift SDKをダウンロードできます。 VSCode向けSwift拡張の最新バージョンが Swiftlyとの新しい連携機能を追加しましたエディタからswift.orgのツールチェーンを簡単にインストールできます。これにより常にすべてのプラットフォームに適したツールチェーンを持てますすぐに利用できます。昨年 Swift拡張を Visual Studioマーケットプレイスに追加しました。
今年はOpenVSX マーケットプレイスにも追加しました統合されたSwiftエクスペリエンスを新しいエディタで利用できるようになります VSCodium、Cursor、Kiro、 Antigravityなどです。プラグインの最新バージョンで Swiftの開始がより簡単になりました Swiftのインストールを案内するチェックリストがあります新しいプロジェクトの作成、コードの実行テストの設定、ドキュメントの生成が含まれます。 Swiftlyがインストールされていればツールチェーンの管理を助けます。ナイトリーツールチェーンをインストールしています Web Assembly向けの新しい言語機能を試すためです組み込みプラットフォームも含みます。インストールしたオープンソースのツールチェーンはWasmにコンパイルできます。
SwiftのWasmサポートでネイティブアプリと同じ言語で書けるということですバックエンドWebサーバーもフロントエンドも。 JavaScriptの相互運用性の改善を見ていきましょうオープンソースプロジェクトの JavaScriptKitからの成果です。 SwiftとJavaScript間のブリッジは多くの動的ルックアップが必要でした型が一致することを期待していました。 JavaScriptKitの最新の取り組みで言語間のブリッジがより安全かつ高速になりました。コードはネイティブSwiftのように見えますが JavaScriptを通じて WebGLを呼び出しています。
人気のメモアプリGoodnotesはネイティブiOSアプリに加えて Webベースのインターフェースを実装しました。コアアプリを別の言語に移行するコストバグの修正と2つのコードベースの維持コストが大きすぎました。既存の実績あるSwiftコードを活用しました Wasmを使ってWeb向けにコンパイルしました。 JavaScriptKitの改善によりベンチマーク結果ではセーフブリッジが動的ブリッジより 35〜40倍高速であることが判明しました。 SwiftのWasmサポートでネイティブiOSアプリで動く Swiftコードを持ち出せます Webアプリの一部として実行できます。ネイティブアプリとは異なりサイト訪問のたびに各デバイスにコードを送る必要があります。 CDNが助けになりますが大きなバイナリは自分とユーザーのデータをすぐに消費します。これによりサイズが以前にも増して重要になっています。
Embedded Swiftではより制約のある環境でも Swiftのエルゴノミクスを活用できます。言語を絞り込んで適合させましたがこうした環境でのSwiftの使われ方を学んでいく中で利用可能な言語サブセットを拡大しています。 Embedded Swiftで existential型をサポートするようになりました。プロトコルに準拠した複数の型を扱えます配列に格納したり関数に渡したりできます。エラー型が分かっているとき typed throwsは優れていますが特定のエラー型に制限されます。 existential型を処理する同じ基盤メカニズムを使って Embedded Swiftで untyped throwsをサポートするようになりました。デバッガは変数を表示するために型レイアウトの追加メタデータが必要です。バイナリサイズを小さく保つために Embedded Swiftはそのデータをバイナリ自体に含めません。さらに多くの組み込みシステムではコアダンプのみが残りますプログラムがクラッシュした時のメモリ状態ですライブプロセスのデバッグさえできません。 Swift 6.4は必要なメタデータを DWARFデバッグ情報に保存しますバイナリサイズを小さく保ちながら Embedded Swiftのコアダンプのデバッグ体験を大幅に向上させます。これらは今年行った改善のほんの一部ですフルSwiftとEmbedded Swiftのギャップを縮めています。組み込みプラットフォームで動く Swiftのサブセットは拡大していますがまだ言語のサブセットです。 EmbeddedRestrictionsの警告グループの診断が言語機能を識別します組み込みコンテキストで使用できないものを。組み込みとフルSwiftの両方をサポートするライブラリで作業する場合公開する必要がある関数がある場合があります組み込みコンテキストで利用できない機能を使うものです。先ほどBeccaが紹介した @diagnose属性を使うとこれらの診断を制御できます。組み込みコードは非常に制約されたハードウェア環境で動きます。そのため毎クロックサイクルを最大限に活用することが重要です。 BeccaがSwiftコードからパフォーマンスを引き出す方法をお伝えします。
Swiftは優れたパフォーマンスを持つよう設計されています最もシンプルで表現力豊かなロジックの実装でも。しかし多くの計算を行う場合や組み込みシステムのような制約された環境ではコードを少し複雑にすることが価値ある場合があります重要な場面でわずかな改善を引き出すために。通常これらの高度なパフォーマンス機能は不要ですが必要な時には役立ちます。
今年取り組んだ2つの領域に注目しますオプティマイザの判断を明示的に制御することと不要なコピーを安全に防ぐための所有権システムの拡張です。 Swiftコンパイラのオプティマイザはコードを高速化するために数十の技術を適用しますしかし最も強力なものの中には誤って適用すると逆効果になるものもあります。特定の状況に合わせてコードを複製するものですしかしカスタマイズが効果的でないとプログラムは小さく高速になるどころか大きく低速になります。たとえばコンパイラが行う最も重要な最適化の1つがインライン化です関数呼び出しを実装に置き換えますそして特定の呼び出し元に合わせてその実装を最適化します。インライン化が効果的であれば同じ結果を少ない処理で得られますがそうでない場合はバイナリが大きくなるだけで高速化はしません。それを防ぐためにオプティマイザは関数と呼び出し元を分析してインライン化が効果的かどうかを判断しますしかし時に誤った判断をすることがありますそのため強制的に指定する方法が必要です。
Swiftには以前から @inline(never)属性がありますインライン化を完全に禁止するものでインライン化が決して効果的でないと分かっている場合に有用です。 Swift 6.4では対応する @inline(always)属性が追加されましたコンパイラにインライン化を強制しますオプティマイザが効果的かどうか確信できない場合でも。ただし時にそれができない場合もありますオーバーライドされる可能性のあるオブジェクトメソッドを呼び出す場合などですクラスメソッドにはfinalと @inline(always)の併用を検討してください。もう一つの重要な最適化が特殊化(specialization)です特定の具体的な型のためにジェネリック関数を複製しますジェネリックのオーバーヘッドを削減しさらなる最適化を実現します。関数の特殊化が効果を発揮するのはオプティマイザがその型での使用を認識している場合のみですしかし時にライブラリでは特にコンパイラは関数がどのように使われるかを見ることができません。 Swift 6.3では@specialized属性が導入されましたこれを直接制御するために。属性の中でジェネリックパラメータの一部または全部を制限するwhere句を書き Swiftはその制約を持つ特殊化された関数のバージョンを生成しますその制約で。遅いジェネリックコードがあって 1〜2つの特定の型で頻繁に使われる場合 Swiftにその型を優先するよう伝えられます。しかしパフォーマンスチューニングで最大の改善は所有権システムに対するものです。何を行ったかを理解するために既存のものを振り返りましょう。 Swiftの多くのパフォーマンス問題は不要なデータのコピーに起因します。あるデータが一方にあり別の場所でも必要ですそのためデータを新しいストレージにコピーします。コンポーネントが大きい場合もありますアプリのモデル層やビュー層のように小さい場合もあります forループのin両側の 2つの変数のようにしかし基本的なパターンは同じです。コピーによる遅延を解決するにはあることを認識する必要があります特定の状況ではコピーが不要だということです。ストレージが割り当てられたままであることが分かっていれば両コンポーネントがSwiftの排他性ルールに従うなら双方がアクセスできるデータを変更しないためデータをコピーする必要はありません既存のストレージへのアクセスを許可するだけです。コピーを避ける最もシンプルな方法はデータをオブジェクトに入れることですそのオブジェクトを別のコンポーネントに渡します。これで十分な場合が多いですが問題を完全には解消しません。オブジェクトは参照カウント方式のためオブジェクトの受け渡しで参照カウントが変わります。解放と保持のオーバーヘッドは大きな値のコピーより少ないですが最もパフォーマンスに敏感なコードではまだ遅すぎる場合があります。オブジェクトが使えない場合代わりにUnsafePointerをストレージに渡すしかありませんでした。しかしその名の通り UnsafePointerは安全ではありません。このようなストレージ共有が安全なのは両コンポーネントが特定のルールに従っているためですがコンパイラはそのルールを知らず確認できません各側がその取り決めを守るかどうかを。 Component 1が変更しないはずのデータを変更するかもしれません Component 2が使用中にストレージを解放するかもしれません。 C言語のようなメモリ安全性のない世界に戻ります。
そこで数年前により良い解決策に取り組み始めました。ストレージを安全に共有するための保証の集合をborrowとして規定しました。 Component 2がストレージを借用している間は両コンポーネントは読み取りのみ書き込みはできません。 Component 2が先にストレージの使用を終える必要がありますそうすると Component 1が完全制御を取り戻します。 mutationも同様ですが他のコンポーネントはストレージへのアクセスを完全にブロックされます。途中更新データの読み取りや動作の不一致を防ぎます他のコンポーネントが変更を書き戻すタイミングに関わらずです。借用またはmutationのどちらでもコンパイル時に検証できます両コンポーネントがルールに従っているかどうかを。
しかし私たちの目標はこれらの高度なユースケースをサポートしながら通常のSwiftコードの書き方に影響を与えないことです。これにより所有権機能の慎重なインクリメンタル設計が必要でした。数年にわたるプロセスでまだ完了していませんが今年さらに数歩前進しました。たとえばEquatable、Comparable、 Hashableプロトコルが noncopyable型でも使えるようになりました。 EquatableとComparableは non-escapable型でも使えます。パフォーマンスと安全性のために調整された型が最も普遍的な機能の一部を活用できます通常のSwift型が持つものです。 Associated typeも non-copyableやnon-escapableにできるようになりました。これにより強力な新機能が開かれます高パフォーマンスなプロトコル駆動開発に向けてここに見られる Iterableプロトコルのようにです。 element型はnon-copyableで iterator型はnon-copyableかつ non-escapableです。もちろんcopyableや escapable型を使えないわけではありませんプロトコルがそれを要求しないということです。ところでこのIterableはとても便利そうです。実際にあったらいいと思いませんか朗報です、本当にあります！
Swift 6.4のforループは新しいIterableプロトコルをサポートします。皆さんご存知の Sequenceプロトコルはシーケンスから要素をコピーして取り出します Iterableプロトコルでは forループが要素を借用できます。 non-copyable要素でも動作しますまた参照カウントを実行する必要もありませんオブジェクトや copy-on-write型で動作する場合でも。さらにループ中にエラーをスローすることも可能で async Sequenceと同様です。ただし借用と同様に排他性チェックにより Iterableを変更できませんループ中は必ずしも悪いことではありませんが Sequenceではパフォーマンスの落とし穴でした。この動作の違いから forループはSequenceプロトコルを優先的に使用しますなければIterableにフォールバックします。 Sequenceと同様に Iterableはイテレータを作成して動作します forループが要素を取得するためです。ただしSequenceと異なり要素をバッチで取得します。 forループはイテレータに要素のスパンを要求して 1つずつ処理します。次のスパンを要求してそれも処理します。要素がなくなると空のスパンを返します forループが終了します。このバッチ設計によりループの効率が大幅に向上しますすべてを1つの大きなスパンで返せる型に特に有効です。 Swift 6.4はアクセサにも大幅な改善をもたらします。重要性を理解するためにこのUniqueBox structを見てみましょう。大きな値へのポインタを自動的に管理しますアクセスのための computed propertyを提供します。残念ながら現状の実装ではこのプロパティに深刻なパフォーマンス問題があります。理由を見てみましょう。 UniqueBoxに256個のIntの InlineArrayを入れるとしましょう。 InlineArrayはインラインなので 64ビットデバイスでは 2キロバイトのstructになります。頻繁にコピーしたくないサイズですね！ getとsetはデータをコピーして動作するので問題です。配列の1つのIntを変更するには全体をコピーして取り出しまた戻す必要があります。パフォーマンスの改善にはなりません！幸いより良い選択肢が利用できるようになりました getとsetから borrowとmutateに切り替えられます。新しいborrowアクセサは共有ストレージへの読み取り専用アクセスを提供しますコピーなしで mutateアクセサはインプレース修正の排他アクセスを提供します。切り替えると Swiftは何もコピーせずに元の配列の要素を変更できます。さらにボーナスとして新しいアクセサにより UniqueBoxはnon-copyable値も扱えます。 borrowとmutateアクセサはパフォーマンスと表現力の両方に役立ちます皆さんに使っていただける状態になり嬉しく思います。ところでこのUniqueBoxもとても便利そうです。実際にあったらいいと… 分かりました分かりましたそのくだりはもうしません。
UniqueBoxは実際の型で標準ライブラリに追加されました。 unsafeなコードを書かずに済む他の新しいAPIもあります Unique Arrayは通常のSwift Arrayとよく似ていますが non-copyableである点が異なります。 non-copyable要素を格納でき固定サイズに縛られずに参照カウントのオーバーヘッドを回避できます。 withTemporaryAllocation関数は OutputSpanを使います UnsafeMutableBufferPointerの代わりに一時メモリを安全に処理します。 Continuation型はコンパイル時に 1度だけresumeされることを確認します CheckedContinuationよりさらに安全で UnsafeContinuationと同様の効率を持ちます。さらに紹介したい 2つの型のペアがあります既存のAPIの改善版ではなく言語に新しい機能をもたらします。 Refは Spanに似ていますが多値でなく単一値用です。借用またはmutationのコンテナのようなものです変数に格納でき関数から渡したり返したりジェネリック型でも使用できます。ストレージを借用して読み取りアクセスから Ref型のインスタンスを作れますまたは書き込みアクセスから MutableRef型のインスタンスを作れますプレフィックスアンパサンドを使用して。これらの型でこれまで書けなかった新しいAPIを作れますプロパティのMutableRefを返すメソッドのようにパフォーマンスの問題にも対処できます。たとえばこの updateCount関数を見てみましょう。インクリメントが必要なたびにディクショナリキーを検索しますキーは常に同じであっても。通常このような繰り返し作業をループの外に出したいはずです 1度だけ実行するためにしかしこれまではディクショナリルックアップを行いしばらく保持し続ける唯一の方法はループを関数に移動してルックアップをinoutで渡すことでした。かなりマニアックなテクニックです！
MutableRefでより良い方法が得られます。ディクショナリルックアップから 1度MutableRefを作成してループ開始前にディクショナリエントリを変更したい時に使用します。 Refはnon-escapableなので Swiftはアクセスが終了することを知っています変数がスコープを外れた時に。これらの新しい所有権機能がすべて組み合わさって最もパフォーマンスに敏感なコードの高速化が今まで以上に安全で簡単になります。所有権システムだけが進行中のものではありません。 EvanにSwiftの将来について伝えてもらいましょう。
今日紹介した機能はオープンソースで開発され全体的なエクスペリエンスを向上させています Apple OS群、Linux、 Windowsなど様々なプラットフォームで。オープンソースコミュニティで進行中のさらなる将来の開発を紹介します参加することもできます。昨年 XcodeのビルドシステムSwift Buildをオープンソース化すると発表しました。 Swift BuildはSwift Package Managerのデフォルトビルドシステムバックエンドになりました Swiftパッケージビルドの一貫性が向上します Xcodeでの体験と合わせて。増加するワークグループに加わったのはビルド・パッケージングワークグループです Swiftコミュニティのビルドとパッケージングのニーズに対応します。ネットワーキングワークグループは次世代のクロスプラットフォームネットワークAPIを設計しています。 WindowsワークグループはWindowsでの Swiftエクスペリエンスを向上させています。今年 AndroidワークグループはSwift 6.3で Android向けSwift SDKを初リリースしました。 AndroidとiOSアプリ間で Swiftコードの共有が可能になりました。 Swiftエコシステムの開発に参加してみたい場合は forums.swift.orgの Swiftフォーラムにご参加ください。皆さんの貴重なフィードバックをお待ちしています。 Swiftの新機能についてご覧いただきありがとうございます。バグレポートの提出プルリクエスト、イベント参加、フォーラムへの参加皆さんの貢献が Swiftの将来を形作りますプログラミングをより安全で誰もが取り組みやすくするために。ありがとうございました。

1:12 - Better Swift Concurrency diagnostics (catching in the task)

Task {
    do {
        try lander.fly(to: moon)
    }
    catch {
        lander.abort()
    }
}

1:21 - Better Swift Concurrency diagnostics (saving the task for later)

let landingTask = Task {
    try lander.fly(to: moon)
}

defer {
    await orbiter.rendezvous(with: lander)
}

try await orbiter.justHangOut(waitingFor: landingTask)

1:27 - Better 'Sendable' conformances

final class Spacecraft: Sendable {
    ...
    weak let dockedAt: SpaceStation?
    ...
}

class Mission: ~Sendable { ... }

class CrewedMission: Mission, @unchecked Sendable { ... }

1:48 - More accessible memberwise initializers

struct Briefing {
    internal var topic: String
    internal var scheduledAt: Date
    private  var attendees: [Person] = []
}

// Generated memberwise initializers:
// extension Briefing {
//     private init(topic: String, scheduledAt: Date, attendees: [Person] = []) { 
//          self.topic = topic
//          self.scheduledAt = scheduledAt
//          self.attendees = attendees
//     }
// 
//     internal init(topic: String, scheduledAt: Date) {
//          self.topic = topic
//          self.scheduledAt = scheduledAt
//          self.attendees = []
//     }
// }

2:03 - 'anyAppleOS' availability (before)

extension Mission {
    @available(macOS 27, iOS 27, watchOS 27, tvOS 27, visionOS 27, *)
    func showStatus() { ... }

    @available(macOS 27, iOS 27, watchOS 27, visionOS 27, *)
    @available(tvOS, unavailable)
    func launch() { ... }
  
    #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS) || os(visionOS)
    func makeLiveActivityWidget() -> some Widget { ... }
    #endif
}

2:17 - 'anyAppleOS' availability (after)

extension Mission {
    @available(anyAppleOS 27, *)
    func showStatus() { ... }

    @available(anyAppleOS 27, *)
    @available(tvOS, unavailable)
    func launch() { ... }
  
    #if os(anyAppleOS)
    func makeLiveActivityWidget() -> some Widget { ... }
    #endif
}

2:40 - Controlling warnings with '@diagnose'

@diagnose(DeprecatedDeclaration, as: ignored, reason: "Flying with surplus hardware")
func makeApolloSoyuzMission() -> Mission {
    CrewedMission(
        rocket: makeSaturnIRocket(),
        payload: makeApolloCSM(),
        crew: [.daniellePoole, .nathanMorrison]
    )
}

@diagnose(StrictMemorySafety, as: warning)
func uplinkCommand(from receiver: inout Receiver, to computer: inout Computer) {
    let commandSize = receiver.receiveInt()
    receiver.withReceivedData(byteCount: commandSize) {
        computer.receiveUplinkedCommand($0)
    }
}

@diagnose(ErrorInFutureSwiftVersion, as: error)
func fetchPosition() -> (x: Double, y: Double, z: Double) {
    return self.rotation
}

3:47 - Clarifying code with module selectors

import Rocket
import GiftShopToys

let rocket1 = SaturnV()            // could mean `Rocket::SaturnV` or `GiftShopToys::SaturnV`
let rocket2 = Rocket.SaturnV()     // prefers `Rocket::Rocket.SaturnV`
let rocket3 = Rocket::SaturnV()    // correctly finds `Rocket::SaturnV`

5:00 - Clarifying code with module selectors (module selectors work on members, too)

//
// Module Chemistry
//

public protocol Flammable { ... }

extension Flammable {
    /// Set `self` on fire.
    public func fire() { ... }
}

//
// Module HumanResources
//

import Chemistry

public protocol Employee { ... }

extension Employee {
    /// Remove `self` from job.
    public func fire() { ... }
}

public class LaunchPadTechnician: Employee, Flammable { ... }

//
// Module main
//

import HumanResources
import Chemistry

let launchPadTechnician = LaunchPadTechnician(...)

launchPadTechnician.HumanResources::fire()

6:26 - Task cancellation

// Radio for help

extension Radio {
  func send(_ data: [UInt8] {
    if Task.isCancelled { return }
    // ...
  }
}
  
extension EmergencyTransponder {
  func sendSOS() {
    radio.send(makeSOSPacket())
  }
}

6:40 - Task cancellation shield

// Radio for help

extension Radio {
  func send(_ data: [UInt8] {
    if Task.isCancelled { return }
    // ...
  }
}
  
extension EmergencyTransponder {
  func sendSOS() {
    withTaskCancellationShield {
    	radio.send(makeSOSPacket())
    }
  }
}

6:53 - Constructing a new dictionary

// Map values with keys

func makeCalendarDisplayNames(for missions: [Mission: LaunchWindow]) -> [Mission: String] {
    let new: [Mission: String] = .init(
        uniqueKeysWithValues: missions.lazy.map { mission, launchWindow in
            (mission, makeDisplayName(for: mission, in: launchWindow))
        }
    )
    return new
}

7:06 - Dictionary.mapKeyedValues

// Map values with keys

func makeCalendarDisplayNames(for missions: [Mission: LaunchWindow]) -> [Mission: String] {
    missions.mapKeyedValues { mission, launchWindow in
        makeDisplayName(for: mission, in: launchWindow)
    }
}

7:14 - The new FilePath type

// FilePath handling macOS-named resources

var path: FilePath = "/var/www/static"
path.components.append("WWDC")
print(path.components)
// [ "var", "www", "static", "WWDC" ]

var path: FilePath = "/var/www/static/..namedresource/rsrc"
print(path.components)
// [ "var", "www", "static" ]

7:41 - Issue Severity

// Issue severity

@Test(arguments: allRockets)
func testBurn(rocket: Rocket) throws {
    rocket.burn(for: .seconds(150))
    let remaining = rocket.propellantKg / rocket.totalPropellantKg

    if remaining < 0.10 {
        Issue.record(
            "\(rocket.name) remaining fuel is below 10% reserve target",
            severity: .warning
        )
    }

    #expect(remaining > 0.02, "\(rocket.name) propellant critically low - abort")
}

7:52 - Test Cancellation

// Test Cancellation

@Test(arguments: allRockets)
func testBurn(rocket: Rocket) throws {
    // solid-fuel rocket engines can't be stopped
    if rocket.engineType == .solid {
        try Test.cancel("\(rocket.name) has solid fuel")
    }
 
    rocket.burn(for: .seconds(150))
    let remaining = rocket.propellantKg / rocket.totalPropellantKg

    if remaining < 0.10 {
        Issue.record(
            "\(rocket.name) remaining fuel is below 10% reserve target",
            severity: .warning
        )
    }

    #expect(remaining > 0.02, "\(rocket.name) propellant critically low - abort")
}

8:34 - XCTest interoperability: Using XCTest from Swift Testing

// XCTest interoperability: Using XCTest from Swift Testing

func checkedTransmitAndReceive(on radio: Radio,
                               packet: Packet,
                               expectedByteCount: Int) throws -> [UInt8] {
    try radio.transmit(bytes: packet.data)
    let bytes = try radio.receive()
    XCTAssertEqual(bytes.count, expectedByteCount)
    return bytes
}

@Test
func pingTest() throws {
    let radio = Radio()
    let bytes = try checkedTransmitAndReceive(on: radio, packet: .ping, expectedByteCount: 8)
    #expect(bytes == [0x00, 0x00, 0xf0, 0x37, 0x0f, 0xc7, 0x00, 0x01])
}

8:48 - XCTest interoperability: Using Swift Testing from XCTest

// XCTest interoperability: Using Swift Testing from XCTest

class RadioTests: XCTestCase {
    func testPingPacketTransmission() {
        let radio = Radio()
        let bytes = try checkedTransmitAndReceive(on: radio,
                                                  packet: .ping,
                                                  expectedByteCount: 8)

        #expect(bytes == [0x00, 0x00, 0xf0, 0x36, 0x0f, 0xc7, 0x00, 0x02])
    }
}

10:01 - Subprocess Output Stream

// Subprocess output streaming

let result = try await Subprocess.run(.name("ls"),
                                      input: .none,
                                      output: .sequence,
                                      error: .string(limit:4096)) { execution in
		execution.standardOtput.strings().filter { $0.hasSuffix(".obj") }
}

for try await objectFiles in result.closureOutput {
  	print("Object file: \(objectFile)")
}

10:37 - Progress Manager - Concurrency

// Progress reporting - Concurrency

let manager = ProgressManager(totalCount: 100)
try await rocket.launch(mission.subprogress(assigningCount: 100))

extension Rocket {
    func launch(_ progress: consuming Subprogress? = nil) async throws {
        let stage = progress?.start(totalCount: 3)
        try await ignite(); stage?.complete(count: 1)
        try await liftoff(); stage?.complete(count: 1)
        try await stageSeparation(); stage?.complete(count: 1)
    }
}

10:37 - Progress Manager - progress reporting

// Progress reporting - progress reporting

let manager = ProgressManager(totalCount: 100)
try await rocket.launch(mission.subprogress(assigningCount: 100))

Task {
    for await update in Observations({ mission.fractionCompleted }) {
        print("🚀 Mission \(Int(update * 100))%")
    }
}

10:37 - Progress reporting - metadata

// Progress reporting - metadata

extension Rocket {
    func ascend(_ progress: consuming Subprogress) async throws {
        let stage = progress.start(totalCount: 3)
        stage.detlaV = 3_400; try await burn(); stage.complete(count: 1)
        stage.detlaV = 2_100; try await stageSeparation(); stage.complete(count: 1)
        stage.detlaV = 1_800; try await coast(); stage.complete(count: 1)
    }
}

print("Δv to orbit: \(mission.summary(of: \.deltaV)) m/s")

20:56 - Directly control inlining (source code)

func histogram<Values>(of values: Values) -> [256 of Int] where Values: Sequence<UInt8> {
    var result = makeInts(randomized: false)
  
    for value in values {
        result[Int(value)] += 1
    }
  
    return result
}

func makeInts(randomized: Bool) -> [256 of Int] {
    if randomized {
        InlineArray { _ in Int.random(in: (.min)...(.max)) }
    } else {
        InlineArray(repeating: 0)
    }
}

21:01 - Directly control inlining (inlined, but not optimized)

func histogram<Values>(of values: Values) -> [256 of Int] where Values: Sequence<UInt8> {
    var result = if false {                                                  //
                     InlineArray { _ in Int.random(in: (.min)...(.max)) }    //
                 } else {                                                    // Inlined code
                     InlineArray(repeating: 0)                               //
                 }                                                           //

   for value in values {
        result[Int(value)] += 1
    }
    return result
}

func makeInts(randomized: Bool) -> [256 of Int] {
    if randomized {
        InlineArray { _ in Int.random(in: (.min)...(.max)) }
    } else {
        InlineArray(repeating: 0)
    }
}

21:07 - Directly control inlining (inlined and optimized)

func histogram<Values>(of values: Values) -> [256 of Int] where Values: Sequence<UInt8> {
    var result = InlineArray(repeating: 0)    // Inlined and optimized code

   for value in values {
        result[Int(value)] += 1
    }
    return result
}

func makeInts(randomized: Bool) -> [256 of Int] {
    if randomized {
        InlineArray { _ in Int.random(in: (.min)...(.max)) }
    } else {
        InlineArray(repeating: 0)
    }
}

21:30 - Directly control inlining (preventing inlining)

@inline(never)
func makeInts(randomized: Bool) -> [256 of Int] {
    if randomized {
        InlineArray { _ in Int.random(in: (.min)...(.max)) }
    } else {
        InlineArray(repeating: 0)
    }
}

21:39 - Directly control inlining (forcing inlining)

@inline(always)
func makeInts(randomized: Bool) -> [256 of Int] {
    if randomized {
        InlineArray { _ in Int.random(in: (.min)...(.max)) }
    } else {
        InlineArray(repeating: 0)
    }
}

21:55 - Making generic functions faster with '@specialized'

func histogram<Values>(of values: Values) -> [256 of Int] where Values: Sequence<UInt8> {
    var result = makeInts(randomized: false)
  
    for value in values {
        result[Int(value)] += 1
    }
  
    return result
}

// Note: Specialized function doesn't actually have a directly callable name.
func `histogram of [UInt8]`(of values: [UInt8]) -> [256 of Int] {    //
    var result = makeInts(randomized: false)                         //
                                                                     //
    for value in values {                                            //
        result[Int(value)] += 1                                      // Specialized code
    }                                                                //
                                                                     //
    return result                                                    //
}                                                                    //

22:17 - Making generic functions faster with '@specialized' (explicitly requesting specialization)

@specialized(where Values == [UInt8])
func histogram<Values>(of values: Values) -> [256 of Int] where Values: Sequence<UInt8> {
    var result = makeInts(randomized: false)
  
    for value in values {
        result[Int(value)] += 1
    }
  
    return result
}

// Note: Specialized function doesn't actually have a directly callable name.
func `histogram of [UInt8]`(of values: [UInt8]) -> [256 of Int] {    //
    var result = makeInts(randomized: false)                         //
                                                                     //
    for value in values {                                            //
        result[Int(value)] += 1                                      // Specialized code
    }                                                                //
                                                                     //
    return result                                                    //
}                                                                    //

25:46 - Associated types can be '~Copyable' and '~Escapable'

protocol Iterable<Element, Failure>: ~Copyable, ~Escapable {
    associatedtype Element: ~Copyable
    associatedtype IterableIterator: IterableIteratorProtocol<Element, Failure>, ~Copyable, ~Escapable
    associatedtype Failure: Error = Never

    func makeIterableIterator() -> IterableIterator
  
    var underestimatedCount: Int { get }
}

protocol IterableIteratorProtocol<Element, Failure>: ~Copyable, ~Escapable {
    associatedtype Element: ~Copyable
    associatedtype Failure: Error = Never

    mutating func nextSpan(maximumCount: Int) throws(Failure) -> Span<Element>
  
    mutating func skip(by maximumOffset: Int) throws(Failure) -> Int
}

27:28 - The problem with existing accessors

@safe public struct UniqueBox<Value>: ~Copyable {
    private let valuePointer: UnsafeMutablePointer<Value>

    public init(_ value: consuming Value) {
        valuePointer = UnsafeMutablePointer.allocate(capacity: 1)
        valuePointer.initialize(to: value)
    }

    public var value: Value {
        get { valuePointer.pointee }
        set { valuePointer.pointee = newValue }
    }

    deinit {
        valuePointer.deinitialize(count: 1)
        valuePointer.deallocate()
    }
}

28:19 - 'borrow' and 'mutate' accessors

@safe public struct UniqueBox<Value: ~Copyable>: ~Copyable {
    private let valuePointer: UnsafeMutablePointer<Value>

    public init(_ value: consuming Value) {
        valuePointer = UnsafeMutablePointer.allocate(capacity: 1)
        valuePointer.initialize(to: value)
    }

    public var value: Value {
        borrow { valuePointer.pointee }
        mutate { &valuePointer.pointee }
    }

    deinit {
        valuePointer.deinitialize(count: 1)
        valuePointer.deallocate()
    }
}

30:14 - Using 'MutableRef' to eliminate repeated accesses (with un-hoisted access)

func updateCount<Key: Hashable>(
    for key: Key,
    from sets: [Set<Key>],
    in counts: inout [Key: Int]
) {
    for set in sets {
        if set.contains(key) {
            counts[key, default: 0] += 1
        }
    }
}

30:34 - Using 'MutableRef' to eliminate repeated accesses (hoisted by 'inout' parameter)

func updateCount<Key: Hashable>(
    for key: Key,
    from sets: [Set<Key>],
    in counts: inout [Key: Int]
) {
    func updateCountImpl(count: inout Int) {
        for set in sets {
            if set.contains(key) {
                count += 1
            }
        }
    }
    
    updateCountImpl(count: &counts[key, default: 0])
}

30:41 - Using 'MutableRef' to eliminate repeated accesses (hoisted by 'MutableRef')

func updateCount<Key: Hashable>(
    for key: Key,
    from sets: [Set<Key>],
    in counts: inout [Key: Int]
) {
    var countRef = MutableRef(&counts[key, default: 0])

    for set in sets {
        if set.contains(key) {
            countRef.value += 1
        }
    }
}

- 0:07 - Introduction
- A preview of the session's four topics: language improvements, library updates, cross-platform support, and performance tuning in Swift 6.3 and 6.4.
- 0:44 - Everyday Language Improvements
- Quality-of-life changes land in Swift 6.4, including optional parentheses removal, concurrency task warnings, weak let, ~Sendable, and a new memberwise initializer.
- 1:55 - anyAppleOS Availability
- Swift now lets you condense multi-platform availability attributes into a single anyAppleOS condition, reducing boilerplate across iOS, macOS, watchOS, and more.
- 3:02 - @diagnose Attribute
- The new @diagnose attribute gives fine-grained control over warnings within a specific declaration, letting you suppress, enable, or promote them to errors.
- 3:52 - Module Selectors (::)
- Swift 6.3 introduces double-colon module selector syntax to unambiguously reference a type or member from a specific module when name conflicts arise.
- 5:59 - Library Updates
- Updates across four key libraries: the standard library, Swift Testing, Subprocess, and Foundation.
- 6:16 - Standard Library
- New additions include a task cancellation shield, mapKeyedValues for dictionaries, and a cross-platform FilePath type.
- 7:31 - Swift Testing Updates
- Swift Testing gains configurable issue severity, dynamic test cancellation, flaky test repetition, and improved two-way interoperability with XCTest.
- 9:29 - Subprocess 1.0
- Subprocess reaches 1.0 with a refined API, improved error handling, convenient line-by-line output streaming, and expanded cross-platform support.
- 10:14 - Foundation
- Foundation gains a new ProgressManager type and continues its Swift migration, with performance improvements to Data, NSURL, and CFURL.
- 11:59 - Beyond Apple Platforms
- Swift 6.4 extends language interoperability and broadens its reach to new environments including web, Android, and embedded devices.
- 12:35 - Swift–C Interoperability (@C attribute)
- The new @C attribute lets you expose Swift functions directly to C, enabling safe, incremental migration of C codebases to Swift.
- 15:09 - Swift-Java
- The Swift-Java package now supports async and throwing Swift functions from Java, constrained extensions, and conforming Java classes to Swift protocols.
- 16:03 - Editor support
- The Swift VSCode extension adds Swiftly integration for toolchain management and is now available on the OpenVSX marketplace for editors like Cursor and VSCodium.
- 16:44 - WebAssembly (Wasm) & JavascriptKit
- Swift can now compile to WebAssembly, with JavascriptKit improvements delivering up to 40x faster safe bridging between Swift and JavaScript.
- 18:08 - Embedded Swift
- Embedded Swift expands its language subset with existential types, untyped throws, and improved DWARF debug info for coredump debugging on constrained hardware.
- 19:59 - Performance Tuning
- Two areas of advanced performance work: explicit optimizer control and extensions to the ownership system to prevent unnecessary copying.
- 21:29 - Optimizer Control: @inline(always) & @specialized
- New @inline(always) and @specialized attributes give you direct control over the compiler's inlining and generic specialization decisions.
- 24:29 - Ownership System & Noncopyable Types
- Equatable, Comparable, Hashable, and associated types now work with noncopyable and non-escapable types, broadening the ownership system's reach.
- 26:18 - Iterable Protocol & Borrow/Mutate Accessors
- A new Iterable protocol enables efficient borrow-based for loops over noncopyable elements, while new borrow and mutate accessors eliminate costly copies in computed properties.
- 28:57 - New Standard Library Types: UniqueBox, UniqueArray, Ref
- The standard library gains UniqueBox, UniqueArray, Continuation, and the new Ref/MutableRef types for safe, high-performance ownership patterns.
- 31:11 - The Future of Swift
- Highlights open-source progress including Swift Build, new workgroups for build, networking, Windows, and Android, and an invitation to participate at forums.swift.org.

「今すぐ始める」を詳しく見る

最新情報

プラットフォームを詳しく見る

特集

テクノロジーを詳しく見る

特集

コミュニティを詳しく見る

特集

ドキュメントを詳しく見る

リリースノート

ダウンロードを詳しく見る

特集

サポートを詳しく見る

特集

クイックリンク

関連する章

リソース

関連ビデオ

WWDC26