Swiftの新機能

Swiftの新機能

Swiftに関する最新情報を紹介します。生産性をさらに向上させるワークフローの改善や、基本的なプログラミングタスクで使用する最新のライブラリAPIについて説明します。また、ソフトウェアスタックのさまざまなレイヤーにわたるSwiftの導入例を紹介します。最後に、並行処理の使いやすさを向上させ、必要なときに優れたパフォーマンスを実現するための新しい言語機能について解説します。

関連する章
- 0:00 - Introduction & Agenda
- 0:48 - swiftlang updates
- 3:06 - Development workflow: Writing code
- 4:40 - Development workflow: Building
- 7:36 - Development workflow: Debugging
- 9:14 - Libraries: Subprocess
- 10:45 - Libraries: Foundation
- 12:31 - Libraries: Observation
- 14:13 - Libraries: Testing
- 16:08 - Swift throughout the stack: Embedded Swift
- 18:00 - Swift throughout the stack: Security
- 19:37 - Swift throughout the stack: Server
- 23:23 - Swift throughout the stack: Platforms
- 26:11 - Language evolution: Performance
- 30:28 - Language evolution: Concurrency
- 37:15 - Wrap up
リソース
関連ビデオ

WWDC25
WWDC24
「What’s New in Swift」へようこそ Hollyです Allanですこのセッションでは Swift 6.2の新機能と改善点を紹介しますこれらのアップデートの目的はどのようなコードをどこで書くかに関わらず Swiftプログラマーの生産性を向上させることです最初にコードの記述、ビルド、デバッグのワークフローの改善点についてお話しします次に基本的なプログラミングタスクのためのライブラリ関連の新しいAPIを紹介しますまたソフトウェアスタックのすべてのレイヤーに Swiftを導入する方法を説明します最後は新しい言語機能の紹介ですこれは並行処理の利用をより容易にし最高のパフォーマンスを必要時に発揮できるよう支援する機能です今回カバーする改善点はすべてオープンソースで共同開発されました GitHubのswiftlang Organizationは 50プロジェクトを超えるほどに拡大しコンパイラ、swift.orgのWebサイト、 Foundation、テストライブラリやその他の重要コンポーネントが広範なエコシステムを支えています swiftlangへのプロジェクト移行のほかにも Swift Buildというオープンソースの Xcodeのビルドシステムがあります Swift Buildは Appleの各OSのビルドプロセスもサポートしています Swift Package Managerの低レベルのビルドシステムとして Swift Buildを採用するための取り組みがオープンソースで進行中ですこれにより Xcodeとswift.orgのツールチェーン間でビルドエンジンが統一されます Swift Buildの詳細についてはブログ記事「The Next Chapter in Swift Build Technologies」をお読みください swiftlangの最新プロジェクトの1つとして Swiftlyというバージョンマネージャーの開発があります Swiftlyの開発は元々オープンソースコミュニティ内で SwiftツールチェーンのLinux上での管理の効率化のために進められていました Swiftlyは現在macOSをサポートしており 1.0のリリースをswift.orgで入手可能です最新のSwiftツールチェーンを 1つのコマンドのみでインストールできますまたはGitHubブランチから毎夜作成されるスナップショットをインストールして開発中の言語機能を試してみることもできます Xcodeでは Swiftlyで取得したツールチェーンはメニューから利用できますなおアプリをビルドしている場合 App Storeにアプリを提出するには Xcodeツールチェーンの使用が必要です VS Codeでは Swiftlyでインストールしたツールチェーンは Toolchainコマンドで選択できます Swiftly 1.0の詳細は Swiftブログでご確認いただけます Swiftを円滑に使い始めるための改善点はツールのインストールに関するものに留まりません swift.orgのホームページの外観が刷新されアプリ、クラウドサービス、埋め込みシステムなどの各領域を詳細に調べやすいように重点構成が変更されていますこれは Swift Website Workgroupとの協働のもと実施されました Swiftをこれまで以上に手軽に使い始められるようになっています次にデベロッパの皆さんにとってより優れた開発環境を構築するための Swift 6.2における柔軟性の強化について Allanが解説しますありがとう Holly Swiftの今年のリリースではデベロッパのワークフローが様々な面で向上しています Swiftコードの記述方法に関わらずメリットを得ることができますこれらの機能強化はコードの記述、ビルド、デバッグなど幅広いワークフローをカバーしていますまずは今年の新機能が VS Codeでの開発にどう影響するか見てみましょう
VS Codeのマーケットプレイスで提供されているSwift拡張機能が swift.orgによって公式に検証され現在配信されていますこの拡張機能にはここ数年でいくつかの新機能も追加されています 1つ目はバックグラウンドでのインデックス作成です Swift 6.1では Swift PMプロジェクト用のデフォルト機能としてバックグラウンドでのインデックス作成を VS Codeおよび他のIDEに追加しましたこれにより Jump to Definitionなどのエディタ機能を使用してプロジェクトに変更を加えた際も最新の状態を維持できます VS Codeのコード補完はより関連性の高い結果を返すようになりましたこれはSourceKit-LSPの向上のおかげですデバッグもよりシンプルになりました Swift拡張機能をインストールすると LLDBのサポートも自動追加されます拡張機能の最新バージョンは新しいプロジェクトパネルも備えていますパッケージの依存関係、ターゲット、タスクをより簡単に把握できます最後に VS Code用のSwift拡張機能にプロジェクトのドキュメントの新しい表示方法も追加されていますコードの横に並べて DocCのプレビューを表示できますプレビューは入力に応じて更新されます VS Code用のSwift拡張機能はオープンソースで開発されており GitHubのswiftlang Organizationから入手できます次は Swiftコードのビルドに関する様々な領域の改善点についてお話しします生産性に関して重要となる要素の1つがツールのパフォーマンスです
Swift 6.2ではマクロベースのAPIを使用するプロジェクトでのクリーンビルドの所要時間が大幅に短縮されています例として「Stringify」という架空のパッケージのマクロを利用するプロジェクトがあるとします従来プロジェクトのビルドでは Swift PMはまずマクロが利用するライブラリであるswift-syntaxのソースを取得する必要がありました次に swift-syntaxと Stringifyマクロプラグインをビルドし最後にコードをビルドしました swift-syntaxのビルドはキャッシュ可能でしたがクリーンビルドを実行するには長時間を要していましたこれは特に継続的インテグレーション環境で顕著でした Swift PMとXcodeの最新リリースではビルドを高速化するために事前ビルド済みの swift-syntaxの依存関係をサポートしていますこれにより時間のかかるビルドのステップが完全に不要になり一部のプロジェクトでは数分単位でクリーンビルドの時間が短縮されます
マクロを提供するパッケージがある場合 swift-syntaxのタグ付きリリースに依存するパッケージがあればクライアントはこの最適化を利用できますしかし生産性に影響するのは必ずしもビルドのパフォーマンスだけではありませんコンパイラが特定した問題の解決に時間がかかることもあります例えば Swift 6の言語モードで並行処理コードを記述する場合コンパイラが回避すべき潜在的なデータ競合を検出することがありますここで検出されたエラーは重要なものかもしれませんがその解決方法が明らかであるとは限りませんそのため Swift 6.2では診断のカテゴリを幅広くカバーできるようドキュメントの拡張に着手しています一般的な警告やエラーの説明をより広範に提供することで問題の理解と具体的な解決方法の特定を促進しますドキュメントにはお使いのIDEか swift.orgからアクセスできます診断の動作を制御できることも重要です例えばコード記述時に警告が出ないようにするために「warnings as errors」の設定を使う方もおられるでしょうこれは警告が簡単に解決できるものである場合は有効ですが非推奨のAPIに関するものなど一部の警告ではすぐに解決することを強制されるのが煩わしい場合もあります Swift 6.2ではどの警告をエラーとして扱うかを柔軟に選択できます例えばすべての警告をデフォルトでエラーとして扱いつつ非推奨の宣言だけは例外とするよう設定できますあるいは特定のカテゴリの警告のみに対し予防措置を取りたい場合それらの警告をエラーに昇格させるだけでOKですコンパイラの警告の制御の向上はすべてのデベロッパにとって Swiftを使いやすくするためのコミュニティの尽力を表す好例です提案の作成者およびフォーラムでの議論に参加したすべての方にこの場を借りてお礼申し上げます最後に Swift 6.2におけるデバッグ関連の優れた改善点を紹介します
このリリースでは非同期コードのデバッグの体験が大幅に向上しました Swiftタスクで実行されているコードをステップごとにデバッグしていく際 LLDBが非同期関数の実行の追跡においてスレッド間の切り替えが必要な場合でも追跡できるようになりましたデバッガが Swiftのタスク中心のモデルを理解しているためどのタスクが実行中か示すことができますさらにタスクに名前を付けてより特定しやすくすることも可能ですタスク名は Instrumentsの並行処理テンプレートに記録される Instrumentsプロファイルにも表示されます swift task infoなどの新しいコマンドを使用して現在実行中のタスクについて優先度や子タスクなどに関するより多くの情報を得ることもできます最後にデバッグセッションの応答性も今年のリリースで向上していますこれはモジュールの依存関係の構築時に並列処理と再利用を可能にする明示的にビルドされたモジュールというビルドシステムの機能によるものです明示的にビルドされたモジュールの登場前は Xcodeのビルドとデバッガは完全に別個のモジュールグラフを使用していました現在ではデバッガはビルドのモジュールを再利用できますそのためデバッガで初めて pやpoのコマンドを実行する際これらによる評価が大幅に高速化します型情報が即座に得られるからです明示的にビルドされたモジュールは Xcode 26ではデフォルトで有効です以上 Swiftに今年追加されたツールの改善点の一部をご紹介しました次は私から皆さんが日々使用する Swiftのコアライブラリに関する重要なアップデートについてお話ししますライブラリはあらゆる種類のタスクで役立ちます Swiftのコアライブラリは Swiftコードを記述する上で不可欠な構成要素を提供します Swift 6.2は FoundationのAPIサーフェスをより広範にモダナイズするほか日々のプログラミングタスクを効率化する新しいAPIを提供しますスクリプト記述タスクでの Swiftの使用体験を向上させるために Foundation Workgroupはサブプロセスを開始するためのAPIを含む新しいパッケージを導入しましたまずは新しいSubprocessパッケージを追加およびインポートします次に run関数を呼び出して結果を待つサブプロセスを開始しますプロセス名を含む文字列を入力すると runメソッドが $PATH環境変数に基づき実行可能ファイルを検索します
多くの場合サブプロセスの開始には FilePathを使用して実行可能ファイルのパス全体を指定しますサブプロセスが終了すると終了ステータス、standardOutput、プロセス実行に関するその他の情報を調べることができますこのサブプロセスライブラリにはさらに多くの機能がありプロセスの実行に対するきめ細かい制御や各プラットフォームに固有の構成オプションなどを利用できます swift-subprocessリポジトリですべてのAPIサーフェスを確認できますパッケージは現在バージョン1.0でありデベロッパからのフィードバックはバージョン1.0でリリースされたAPIに有益な情報となります Foundation Workgroupはアプリプロジェクトで日常的に使用される一般的なAPIにも機能強化を行いました UIKitからの通知への応答は iOSアプリで非常によく使用されますが通知を監視するためのコードではミスが生じがちですまずオブジェクトが投稿をサポートする通知の名前を登録する際に注意が必要ですここでミスすると通知のコールバックは実行されません通知に関する情報は型指定のない辞書に格納されますここでは正しいキーを使用して手動で登録を行い結果を正しい型へと動的キャストする必要がありますまた通知がメインスレッドに投稿されることが確証された場合でも MainActorのAPIへのアクセスで並行処理のエラーが出ることがあります通知の名前とペイロードが具象型をサポートするようになりました具象型では登録する通知の種類をオブジェクトがサポートしているかをコンパイラがチェックできますまた通知のペイロードに関する記述で定型表現が不要になります通知の型により通知の投稿先が指定されます通知がMainActorに投稿されている場合 MainActorのAPIに自由にアクセスできます MainActorMessageに適合させると通知が常にメインスレッド上で同期的に投稿されることが確証されます一方 AsyncMessageに適合させると通知は任意のスレッドに非同期的に投稿されます通知の具象型はSDKで利用可能であり UIKitやFoundationなどのフレームワークで投稿される通知に適用できます通知の具象型は皆さん独自の通知にも追加できます登録済みのオブザーバへのシステム通知のブロードキャスト配信はより一般的なオブザーバパターンに基づきますオブザベーションライブラリはオブジェクトグラフの状態変更を自動トラッキングするための汎用APIを提供します
クラスを監視トラッキングの対象として指定するには @Observableマクロを使用します Swift 6.2では監視可能な型から AsyncSequenceによって状態の変化をストリーミングする方法が導入されますまず Observations型の新規のインスタンスをクロージャを使って作成しますこのクロージャ内で変更を監視する対象の値を計算しますここではプレーヤーの現在の状態を説明する文字列を監視しスコアが更新されるかプレーヤーが新規アイテムを入手するたびに新しい値を取得するようにしますクロージャ内で使用されている監視可能なプロパティに基づき更新された値を取得します更新はトランザクションとして発生します更新のトラッキングの開始はクロージャ内の監視可能なプロパティのいずれかでwillSetが呼び出された時ですトラッキングはコードが一時停止する次のawaitで終了します更新された値にはコードにおけるトラッキング開始と終了の 2点間で発生した同期された変更がすべて含まれますこれにより複数のプロパティでの同期された更新によってオブジェクトの状態が不整合になる監視のアップデートが引き起こされません
スコアとアイテムの両方を同期させて更新した場合取得するのは両方の変更を含む更新された値1つのみです Observations型は AsyncSequenceに適合しているので for-awaitループを使用して更新された値を反復処理できますデベロッパは毎日テストを記述します Swift Testingはクロスプラットフォームのライブラリですテストを記述し整理するためのマクロを提供します例えばテスト機能を宣言する @Test属性のようなマクロです expectとrequireのマクロを使って仮定を検証し期待や要求に失敗した際に Swift Testingで実用的な情報を入手できますテストの失敗の優先順位付けが難しいことがあります CIなどのリモート環境でのみ失敗する場合は特にそうですテストの失敗を理解するにはテストで使うデータについてより多くのコンテキストが必要です
Swift 6.2にはテスト失敗の診断に役立つカスタム添付ファイルが導入されています Attachment.recordメソッドを呼び出してテストに添付ファイルを追加できます DataやStringなどのライブラリ型を添付できるほか添付可能なプロトコルに従って独自の型について添付ファイルのサポートを実装できます Swift 6.2は終了テストもサポートし特定の状況で終了するようコードをテストできます例えば必要条件に従って入力パラメータに関する仮定を検証する関数を書く場合必要条件が失敗したときに成功するテストケースを記述できます
processExitsWithという引数を #expectや#requireに渡し終了テストを作成します終了テストを作成する場合 Swift Testingは新しいプロセスを開始しテストを実行して特定の終了コード、シグナル、失敗ステータスによりプロセスが終了するかどうかを検証できますこれらの汎用ライブラリを使用するとアプリコード以外でもプロジェクト全体でポータブルなSwiftコードを作成しテストできます Appleはソフトウェアスタック全体で Swiftを使っていますファームウェア、アプリ、フレームワーク、大規模なWebサービスに使います組み込みデバイス、セキュリティクリティカルなコンポーネント、サーバ向けにコードを書く際は Swift 6.2の機能強化が役立ちますいくつかの新しいプラットフォームをターゲットにすることもできます Embedded Swiftがあるスタックの一番下から始めましょう Embedded SwiftはSwiftのサブセットで制約の多い環境をターゲットにしてコードを書けます組み込みデバイスのファームウェアや OSのカーネルなどです Swiftのコア機能をサポートするコンパイルモードで値、参照タイプ、クロージャ、オプション、エラー処理、ジェネリックなどがあります AppleはiPhoneに搭載されている一部の下位のソフトウェアで Embedded Swiftを使っています例えば iOS 26のEmbedded Swiftはコプロセッサーを実行して CPUとGPU間の共有メモリページへのアクセスを管理します Embedded Swiftを試してみたい方は「Go small with Embedded Swift」をご確認ください Swift 6.2ではEmbedded Swiftに新しい機能が追加され文字列補間を含む Swiftの完全な文字列APIに対応しました Swiftのany型はプロトコルに適合した型の値を表すことができプロトコルがクラス型に制限されている場合に利用できます Swiftの標準ライブラリに追加される InlineArrayとSpanはメモリ領域を効率化する新しい2つのAPIです Hollyが後で詳しく説明するこれらのタイプは組み込みプログラムによくみられるパフォーマンスが重要なコードに最適です Embedded Swiftの機能が高まるにつれてコミュニティは活況を呈し組み込みプロジェクトに使える例が様々に作成されてきました GitHubのswift-embedded-examples リポジトリでご確認ください Embedded Swiftのメリットの1つはデフォルトでメモリセーフな言語で下位のソフトウェアを書けることですメモリセーフなコードはより安全であり私たちはSwiftをさらに向上させ強力なセキュリティ要件を持つコードに対応できるように取り組んできました本質的な安全性のないものを仕上げるためにコードが必要になることもありますたとえばCで書かれた依存関係と統合する場合ポインタを取るAPIを使うことが一般的ですセキュリティクリティカルな状況では安全でないコードはなるべく避けましょう避けられない場合は簡単に識別できるようにしておきますそこでSwift 6.2に厳格なメモリ安全性というオプトイン機能を導入しましたこのモードでは安全でないAPIの使用はすべてソースコードに明示的な承認が必要ですこのモードには注釈が必要でコードのどの部分にセキュリティ的に注意が必要かを特定できますこの新しいモードに加えて Swift 6.2はCとC++ヘッダーの新しい注釈にも対応しており Spanなどの安全で人間工学に基づいた型を使って APIをSwiftにインポートします新しい相互運用機能について詳しくは「Safely mix C, C++, and Swift」をご確認ください AppleのOSではセキュリティクリティカルな2つの要素に厳格なメモリ安全性を導入し WebKitとメッセージアプリのサブシステムで受信したメッセージと添付ファイルを分析しますこれらは信頼性の低い入力を処理するので安全でないAPIの使用を制限するうえでこの機能は特に重要ですではサーバエコシステムでの Swiftの利用方法を確認しましょう
SwiftはAppleのサービスに大きな役割を果たしています Swiftを活用したバックエンドサービスが毎秒大量のリクエストを処理していますこれらのサービスの１つにデータが漏えいしパスワードが侵害された場合にユーザーに警告するものがありますこれは以前Javaで構築していましたが最近Swiftで書き直したことで大きなメリットが生まれました Swiftの効率的なネイティブコードと確定的なメモリ管理によりサービスのスループットが40%向上しハードウェア要件が半分になりました
サーバにSwiftを利用することは多くの方にとって有益でしょう例えば Cultured Codeのエンジニアは Things Cloudという有名なThingsアプリのバックエンドを Swiftで再実装しその体験をswift.orgで語りました
Things CloudでSwiftを使用するとコンピューティングコストが 1/3に削減され平均応答時間が400%向上しましたパフォーマンスの向上に加え Swiftを利用するもう1つのメリットは同じ言語とツールを使ってクライアントとサーバを開発できることです Swiftでサーバのバックエンドを構築するうえで重要なのがライブラリです Swiftのパッケージエコシステムは基本的なユースケースを幅広くカバーしていますライブラリはネットワーク、データベースドライバ、可観測性、メッセージストリーミングなどがあります今年の大きなアップデートは gRPC Swiftバージョン2のリリースです gRPCはサービスAPIを構築する最新で高パフォーマンスのパッケージですバージョン2の特徴はモダナイズされたAPIで Swift Concurrency、イディオマティックなSwiftコード、プラグイン可能で高パフォーマンスのトランスポート層を活用します gRPC Swiftの保守担当者がswift.orgにアップデートに関する記事を書いていますぜひご確認ください C、Objective-C、C++との相互運用性は Swiftの大きな強みですこれらの言語で書いた既存のコードベースを Swiftを利用することで段階的に向上させることができますサーバエコシステムでは多くの既存アプリがJavaで書かれていますこれらのコードベースでも Swiftの段階的な利用が大きな効果を発揮すると思います昨年 swift-javaという刺激的な新規オープンソースプロジェクトを発表しました言語のシームレスな相互運用が目的です
swift-javaではバインディングを作成して Swiftコードと Javaが呼び出し合えるようにしますこれらのバインディングは過度なオーバーヘッドなく各言語の値のネイティブ表現をラップします JavaのSwift向けバインディングは Javaの次世代の他言語インターフェイス技術を活用し必要に応じてJNIにフォールバックします Swift-Javaプロジェクトは現在実験段階にあり急速に進化していますこの仕組みについて詳しくは「Explore Swift and Java interoperability」をご確認ください
クライアントとサーバを両方持つアプリを実行する場合ローカルで両環境のコードをテストするワークフローが必要です Appleは新たにオープンソースのコンテナ化ライブラリをリリースします Macで動作する Linuxコンテナをベースにしたツールの作成に利用できるライブラリですライブラリはSwiftに完全実装されセキュリティやプライバシーやパフォーマンス重視で設計してあります Swiftを使ったシステムレベルの開発で威力を発揮してくれますライブラリの詳細は「Meet Containerization」で紹介しています GitHubのコンテナ化リポジトリではコンテナ実行用のコマンドラインバイナリもご覧いただけます最後に Swiftで対応可能なプラットフォームの最新情報です Swift 6.2はサーバや埋め込みプラットフォームで普及しているオペレーティングシステム FreeBSDに正式対応します Swiftは他にも WebAssembly いわゆる「Wasm」にも対応します WebAssemblyはポータビリティやセキュリティやハイパフォーマンス重視の仮想マシンプラットフォームですデベロッパはクライアントとサーバ両方のWasmアプリをビルドしてブラウザや他のランタイムにデプロイできます WebAssemblyサポートの端緒はコミュニティプロジェクトでした今年に入って Swiftでの WebAssembly正式サポートの展望に関する文書が公開されプロジェクトは大きな節目を迎えました Wasm対応の具体例を紹介しますファイルから3Dモデルを読み込んでブラウザでレンダリングするアプリを Swiftで作成しましたアプリは現在こういう状態です
Wasm仮想マシンで動作しています Swiftロゴは実験段階のWeb標準「WebGPU」でレンダリングしています
アプリにはJavascriptKitという SwiftWasm Organizationが開発したオープンソースパッケージを使いますライブラリを利用すればネイティブのSwift API経由で Javascriptランタイムを操作できます最終的なバイナリを極力コンパクトにするため Embedded Swiftを使ってアプリをコンパイルしますがこのコードの大部分はノーマルなSwiftコードです
例えばジェネリクスを使ったジオメトリユーティリティを追加して Wavefrontファイルのパーサーは SwiftネイティブのString APIを使います
動きを加えてみましょうレンダラーのupdateメソッドに移動します
モデルをスピンさせるにはフレーム単位でロゴの回転を更新する必要があります
テストしてみますアプリを再実行するため Project Panelからタスクをトリガーします Swift Buildを呼び出してWasmアプリをコンパイルするよう構成してありますビルド出力で最小化ツールを実行してバイナリを極力小さくします最後に Webサーバを起動してコンテンツをホストさせます上出来ですねソフトウェアスタック全般で Swiftが選ばれているのは言語として優れているからです Swiftはデフォルトで安全性と使いやすさを重視しつつ上級プログラマー向けのツールも用意しており複雑なコーディングやパフォーマンスの最大化にも対応できます言語の機能については使いながら学んでいけます簡単なタスクから始めて慣れてきたらより高度な機能に手を広げられます
Swift 6.2の言語は初心者から上級者まで誰でも使いやすいように進化しましたプロジェクト内での並行処理によって一段と敷居が低くなりましたパフォーマンス重視のコードを手がける上級者のニーズにも十分応えられる言語になっていますパフォーマンスのアップデートからご紹介します Array型は要素の順序付きリストであり Swiftプロジェクトで最も一般的に使用されるデータ型の1つです動的なサイズ変更など使いやすい機能が備わっているArrayは多数のタスクに適していますただしこの柔軟性には代償が伴います動的なサイズ変更をサポートするため Arrayはヒープ割り当てバッファへの参照を格納します多数の要素が追加されて Arrayがいっぱいになると新しいメモリが動的に割り当てられ既存の要素がコピーされます Arrayをホットパスで使用するパフォーマンス重視のコードを記述する場合 Arrayバッファではメモリの割り当てまたは参照を削除する必要があることに気づくと思います Arrayのサイズが変わらない場合ヒープ割り当てのコストは発生しません InlineArrayは要素用のインラインストレージを備えた新しい固定サイズのArray型ですサイズはこの型の一部であり Element型の前に山括弧で囲んで記述されます
要素を含むバッファへの参照を格納する代わりに InlineArrayの要素が直接格納されますつまりこれらの要素は追加のヒープを割り当てなくてもスタック上に格納するかまたは他の型内に格納できます InlineArrayにはコピー可能およびコピー不可能な型を格納できますコピー可能な型を格納する場合 InlineArray自体がコピーされさらに要素の値がコピーされます型の一部としてサイズを記述するには型パラメータとして整数を指定できる新しいジェネリック機能を使用します Element型と同様 InlineArrayのサイズも配列リテラルによって示されます InlineArrayをと記述した場合この型は<3, int>の InlineArrayとみなされますコンパイル時に InlineArrayのサイズがわかればインデックスがそのサイズより小さい場合に境界チェックを削除するなどより詳細な最適化が可能になります Container型は基盤となるストレージへの直接アクセスを提供する必要がありますこれは連続メモリでローカル処理を実行する場合に便利です元のコンテナのレイアウトを把握している必要がありません例えば関数で ArrayまたはInlineArrayの連続ストレージを直接操作したい場合があります Swift 6.2より前の一般的な解決策は安全でないポインタにドロップダウンすることでした効率的ですが基本的に安全ではなくミスも発生しやすくなります
新しいSpan型は抽象型ですメモリの安全性を損なうことなく連続するメモリに高速かつ直接的にアクセスできます標準ライブラリは連続ストレージを使用するすべてのContainer型に Spanプロパティを提供しますストレージの対象はArray、ArraySlice、 InlineArrayなどの要素です
このプロパティは Spanの使用中は連続メモリの有効性を維持することでメモリの安全性を保証しますこれらの保証により Use-After-Freeや変更の重複などメモリの安全性に関するポインタに固有の問題が特定されますこれらは実行時オーバーヘッドなしでコンパイル時にチェックされます例えば元のコンテナを変更するとその後は同じSpanにアクセスできなくなります変更後は Span変数に再びアクセスできません
さらにSpanは元のコンテナより長く存続できませんこれは寿命依存と呼ばれ Spanからまだアクセス可能な時に基盤となるストレージが破壊されないようにします InlineArrayとSpanを使ってパフォーマンスを管理する新しい方法については「Improve memory usage and performance with Swift」をご視聴ください Swiftコードのパフォーマンス特性について詳しくは「Explore Swift performance」をご覧ください
パフォーマンスのもう1つの側面は応答性ですプログラムは複数のタスクを同時に実行する必要があります並行プログラミングは簡単ではありません複数のタスク間でメモリを共有するとエラーが生じやすくなり予測できない動作につながります Swift 6のデータ競合の安全性によりこれらのエラーがコンパイル時に検出されるため並行コードを記述する際デバッグが難しい実行時エラーを回避できますとはいえ多くの場合記述するほとんどのコードはデータ競合が発生しやすくコンパイラエラーにつながるため対処する必要がありますこのPhotoProcessorクラスのようにミュータブルな状態を持つクラスは同時にアクセスしない限り安全です指定されたイメージデータの被写体を計算することによってステッカーを抽出する非同期メソッドがありますしかし MainActorで extractStickerを UIコードから呼び出そうとするとデータ競合の原因となるエラーが発生しますこの言語ではコードの並列実行が不要な場合でも暗黙的に処理をバックグラウンドにオフロードするケースがあるためです
Swift 6.2ではこの考え方が見直され並行処理の導入を選択しない限りデフォルトではシングルスレッドで動作します
Swift 6.2での言語変更によりデフォルトでは記述するほとんどの自然コードでデータ競合が発生しませんそのためプロジェクトに並行処理を導入しやすくなりますコードを並行実行するために並行処理の導入を選択した場合はデータ競合の安全性により保護されますまずミュータブル状態を使用する型での非同期関数の呼び出しを簡単にしました特定のアクターに結び付けられていない非同期関数をオフロードする代わりにこの関数は呼び出し元のアクターでの実行を継続します非同期関数に渡される値はアクター外に送られることがないためデータ競合が排除されますそれぞれの実装で非同期関数は処理オフロードできますがクライアントはミュータブル状態について心配する必要がありません
次に MainActor型での適合性の実装が簡単になりましたここでは「Exportable」というプロトコルを使用します MainActorのStickerModelクラスに適合性を実装しましょうエクスポート要件にはアクター分離がありません MainActorからの呼び出しが可能であり StickerModelがその実装で MainActorの状態を使用しないことを前提としています
Swift 6.2はこれらの適合性をサポートしています MainActor状態を必要とする適合性は「isolated」と呼ばれます MainActorの適合性は MainActorでのみ使用されるため安全性を確保できます MainActorにとどまることを条件に Exportableアイテムの配列に StickerModelを追加する ImageExporter型を作成できますただし ImageExporterをどこからでも使用できるようにした場合は StickerModelを配列に追加できません StickerModelでのエクスポートを MainActor外から呼び出す処理は安全でないためですコードで適合性の同時使用が必要な場合 isolated適合性を使用すればデータ競合の安全性の問題を解決するだけで済みます
グローバル変数と静的変数の場合どこからでもミュータブル状態にアクセスできるためデータ競合が発生しやすくなります
グローバル状態を保護する最も一般的な方法はMainActorです一般に同時タスクがあまり多くないプロジェクトでは特に MainActorを使用してクラス全体に注釈を付けすべてのミュータブル状態を保護します完全にシングルスレッドのプログラムをモデル化するにはプロジェクトのすべての箇所に @MainActorを記述しますシングルスレッドコードのモデリングをより簡単にするためデフォルトでMainActorを推測するモードを導入しました MainActorはすべてのミュータブル状態をデフォルトで保護するので安全でないグローバル／静的変数やその他のMainActor関数の呼び出し（SDKなど）に伴うデータ競合の安全性エラーをなくすことができますまたほとんどシングルスレッドのコードでの並行性注釈も削減されますこのモードは多くの処理をMainActorで実行するプロジェクトに適しており特定の型やファイル内に並行コードがカプセル化されますオプトインでありアプリやスクリプトなどの実行可能ターゲットに適しています CPU負荷の高いタスクの実行時にアプリの応答性を維持する場合などは処理をバックグラウンドにオフロードすることも重要です PhotoProcessorでextractStickerメソッドを実装する方法を見てみましょうまずイメージのステッカーを既に抽出しているかどうかをチェックしてキャッシュ済みステッカーを即座に返せるようにしますステッカーがキャッシュされていない場合はイメージデータから被写体を抽出して新しいステッカーを作成します extractSubjectメソッドが負荷の高いイメージ処理を実行するので MainActorやその他のアクターをブロックしたくありません @concurrent属性を使用してこの処理をオフロードできます @Concurrentは常に同時スレッドプールで関数が実行されることを保証しアクターが複数のタスクを同時に実行できるようにしますこれらの言語変更の連係により並行処理が使いやすくなりますまずデフォルトでMainActorで実行されるコードを記述しますここではデータ競合のリスクがありません非同期関数の使用を開始するとそれらの関数は呼び出された場所で実行されますこの場合もすべてのコードは MainActorで実行されるためデータ競合のリスクはありませんパフォーマンスを向上させるために並行処理を取り入れる準備ができたら特定のコードをバックグラウンドにオフロードして並行して実行します並行処理を実際に使用する方法について詳しくは「Elevate an App with Swift concurrency」をご覧ください. 並行処理機能の基本的な概念については「Embracing Swift Concurrency」をご視聴ください一部の言語変更は実装にあたってプロジェクトでの変更が必要なためオプトインとなっています利用可能な並行処理の言語変更はいずれもXcodeビルド設定の「Swift Compiler - Concurrency」セクションにあります Swiftパッケージのマニフェストファイルで SwiftSettings APIを使用してこれらの機能を有効にすることもできます Swift 6.2の移行ツールを使用すると必要なコード変更を自動的に行うことができます移行ツールの詳細については swift.org/migrationをご覧くださいこれらの並行処理はプロジェクトでの安全なデータ利用に関するフィードバックに基づいて強化されました皆さんから報告されたバグ、並行処理の問題に関するご質問、フォーラムでの革新的な提案、皆さんの手による言語変更やご意見などが反映されています並行処理の使いやすさ向上にご協力いただきありがとうございました Swiftの強化に関心がございましたら swift.orgのフォーラムにご参加ください Swift言語とエコシステムの向上にもぜひご協力くださいコミュニティのショーケースセクションで皆さんのプロジェクトをご紹介いただけるのを楽しみにしています Swiftフォーラムではカンファレンス、交流会、ソーシャルメディアなど Swiftに関する様々な最新情報を入手できます本日はありがとうございましたフォーラムでお会いしましょう

9:44 - Subprocess: Call `run` with string

import Subprocess

let result = try await run(
  .name("pwd")
)

10:04 - Subprocess: Call `run` with file path

import Subprocess

let swiftPath = FilePath("/usr/bin/swift")
let result = try await run(
  .path(swiftPath),
  arguments: ["--version"]
)

10:05 - Subprocess: Accessing standard output

import Subprocess

let swiftPath = FilePath("/usr/bin/swift")
let result = try await run(
  .path(swiftPath),
  arguments: ["--version"]
)

let swiftVersion = result.standardOutput

10:51 - NotificationCenter: Dynamic types

import UIKit

@MainActor 
class KeyboardObserver {
 func registerObserver(screen: UIScreen) {
    let center = NotificationCenter.default
    let token = center.addObserver(
      forName: UIResponder.keyboardWillShowNotification,
      object: screen,
      queue: .main
    ) { notification in
      guard let userInfo = notification.userInfo else { return }
      let startFrame = userInfo[UIResponder.keyboardFrameBeginUserInfoKey] as? CGRect
      let endFrame = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect

      guard let startFrame, let endFrame else { return }

      self.keyboardWillShow(startFrame: startFrame, endFrame: endFrame)
    }
  }
  
  func keyboardWillShow(startFrame: CGRect, endFrame: CGRect) {}
}

11:34 - NotificationCenter: Concrete types

import UIKit

@MainActor
class KeyboardObserver {
  func registerObserver(screen: UIScreen) {
    let center = NotificationCenter.default
    let token = center.addObserver(
      of: screen,
      for: .keyboardWillShow
    ) { keyboardState in
      let startFrame = keyboardState.startFrame
      let endFrame = keyboardState.endFrame

      self.keyboardWillShow(startFrame: startFrame, endFrame: endFrame) 
    }
  }
  
  func keyboardWillShow(startFrame: CGRect, endFrame: CGRect) {}
}

12:01 - NotificationCenter: Conformances

extension UIResponder { 
  public struct KeyboardWillShowMessage: NotificationCenter.MainActorMessage
}

extension HTTPCookieStorage {
  public struct CookiesChangedMessage: NotificationCenter.AsyncMessage
}

12:48 - Observation: The @Observable macro

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

12:58 - Observation: The Observations type

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

let player = Player(name: "Holly")
let values = Observations {
  let score = "\(player.score) points"
  let item =
    switch player.item {
    case .none: "no item"
    case .banana: "a banana"
    case .star: "a star"
    }
  return "\(score) and \(item)"
}

13:56 - Observation: Transactional updates

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

let player = Player(name: "Holly")
let values = Observations {
  let score = "\(player.score) points"
  let item =
    switch player.item {
    case .none: "no item"
    case .banana: "a banana"
    case .star: "a star"
    }
  return "\(score) and \(item)"
}

player.score += 2
player.item = .banana

14:05 - Observation: AsyncSequence

import Observation

enum Item {
  case none
  case banana
  case star
}

@Observable
class Player {
  let name: String
  var score: Int = 0
  var item: Item = .none

  init(name: String) {
    self.name = name
  }
}

let player = Player(name: "Holly")
let values = Observations {
  let score = "\(player.score) points"
  let item =
    switch player.item {
    case .none: "no item"
    case .banana: "a banana"
    case .star: "a star"
    }
  return "\(score) and \(item)"
}

player.score += 2
player.item = .banana

for await value in values { print(value) }

14:17 - Swift Testing

import Testing
import Foundation
import EvolutionMetadataModel

@Test
func validateProposalID() async throws {
  let (data, _) = try await URLSession.shared.data(from: evolutionJSONMetadataURL)

  let jsonDecoder = JSONDecoder()
  let metadata = try jsonDecoder.decode(EvolutionMetadata.self, from: data)
  for proposal in metadata.proposals {
    #expect(proposal.id.starts(with: "SE"))
  }
}

14:54 - Swift Testing: Attachments

import Testing
import Foundation
import EvolutionMetadataModel

@Test
func validateProposalID() async throws {
  let (data, _) = try await URLSession.shared.data(from: evolutionJSONMetadataURL) 
  Attachment.record(data, named: "evolution-metadata.json")

  let jsonDecoder = JSONDecoder()
  let metadata = try jsonDecoder.decode(EvolutionMetadata.self, from: data)
  for proposal in metadata.proposals {
    #expect(proposal.id.starts(with: "SE"))
  }
}

15:23 - Exit Tests: Preconditions

extension Proposal {
  public var number: Int {
    let components = id.split(separator: "-")
    precondition(
      components.count == 2 && components[1].allSatisfy(\.isNumber),
      "Invalid proposal ID format \(id); expected SE-<Number>"
    )

    return Int(components[1])!
  }
}

15:34 - Exit Tests: processExitsWith argument

import Testing
import EvolutionMetadataModel

@Test
func invalidProposalPrefix() async throws {
  await #expect(processExitsWith: .failure) {
    let proposal = Proposal(id: "SE-NNNN")
    _ = proposal.number 
  }
}

31:06 - Concurrency: Async function error message

class PhotoProcessor {
  func extractSticker(data: Data, with id: String?) async -> Sticker? {     }
}

@MainActor
final class StickerModel {
  let photoProcessor = PhotoProcessor()

  func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
    guard let data = try await item.loadTransferable(type: Data.self) else {
      return nil
    }

    return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
  }
}

32:06 - Concurrency: Run async functions on the caller's actor

// Run async functions on the caller's actor

class PhotoProcessor {
  func extractSticker(data: Data, with id: String?) async -> Sticker? {}
}

@MainActor
final class StickerModel {
  let photoProcessor = PhotoProcessor()

  func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
    guard let data = try await item.loadTransferable(type: Data.self) else {
      return nil
    }

    return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
  }
}

32:36 - Concurrency: Conformance error

protocol Exportable {
  func export()
}


extension StickerModel: Exportable { // error: Conformance of 'StickerModel' to protocol 'Exportable' crosses into main actor-isolated code and can cause data races
  func export() {
    photoProcessor.exportAsPNG()
  }
}

33:04 - Concurrency: Isolated conformances

// Isolated conformances

protocol Exportable {
  func export()
}


extension StickerModel: @MainActor Exportable {
  func export() {
    photoProcessor.exportAsPNG()
  }
}

33:20 - Concurrency: Isolated conformance use

// Isolated conformances

@MainActor
struct ImageExporter {
  var items: [any Exportable]

  mutating func add(_ item: StickerModel) {
    items.append(item)
  }

  func exportAll() {
    for item in items {
      item.export()
    }
  }
}

33:31 - Concurrency: Isolated conformance error

// Isolated conformances

nonisolated
struct ImageExporter {
  var items: [any Exportable]

  mutating func add(_ item: StickerModel) {
    items.append(item) // error: Main actor-isolated conformance of 'StickerModel' to 'Exportable' cannot be used in nonisolated context
  }

  func exportAll() {
    for item in items {
      item.export()
    }
  }
}

33:51 - Concurrency: Unsafe static variable

final class StickerLibrary {
  static let shared: StickerLibrary = .init() // error: Static property 'shared' is not concurrency-safe because non-'Sendable' type 'StickerLibrary' may have shared mutable state
}

34:01 - Concurrency: Protecting static variables

final class StickerLibrary {
  @MainActor
  static let shared: StickerLibrary = .init()
}

34:05 - Concurrency: Protecting classes

@MainActor
final class StickerLibrary {
  static let shared: StickerLibrary = .init()
}

34:15 - Concurrency: A single-threaded program

@MainActor
final class StickerLibrary {
  static let shared: StickerLibrary = .init()
}

@MainActor
final class StickerModel {
  let photoProcessor: PhotoProcessor

  var selection: [PhotosPickerItem]
}

extension StickerModel: @MainActor Exportable {
  func export() {
    photoProcessor.exportAsPNG()
  }
}

34:22 - Concurrency: Mode to infer main actor by default

// Mode to infer main actor by default

final class StickerLibrary {
  static let shared: StickerLibrary = .init()
}

final class StickerModel {
  let photoProcessor: PhotoProcessor

  var selection: [PhotosPickerItem]
}

extension StickerModel: Exportable {
  func export() {
    photoProcessor.exportAsPNG()
  }
}

35:06 - Concurrency: Explicitly offloading async work

// Explicitly offloading async work

class PhotoProcessor {
  var cachedStickers: [String: Sticker]

  func extractSticker(data: Data, with id: String) async -> Sticker {
      if let sticker = cachedStickers[id] {
        return sticker
      }

      let sticker = await Self.extractSubject(from: data)
      cachedStickers[id] = sticker
      return sticker
  }

  @concurrent
  static func extractSubject(from data: Data) async -> Sticker {}
}

- 0:00 - Introduction & Agenda
- Learn what's new in Swift 6.2. Highlights include: workflow enhancements, new library APIs, expanded adoption across the software stack, and improved concurrency language features for more productive coding.
- 0:48 - swiftlang updates
- The swiftlang organization on GitHub has grown significantly, encompassing over 50 projects, including the Swift compiler, Xcode’s build system Swift Build, and the Swift.org website. Swift Build, now open source, supports the build process for Apple operating systems, and is adopted by the Swift Package Manager. A new version manager, swiftly, originally developed for Linux, now supports macOS and simplifies Swift toolchain management. The redesigned Swift.org homepage can also help you dive into different areas.
- 3:06 - Development workflow: Writing code
- The latest Swift release enhances development workflows across all platforms, with specific improvements for VS Code Swift extension users including official verification and distribution of the Swift extension by Swift.org. Now, there's also background indexing for real-time editor features, enhanced code completion, simplified debugging with automatic LLDB support, and new project panel and live DocC previews.
- 4:40 - Development workflow: Building
- Swift 6.2 introduces several enhancements to boost your productivity. Clean build times for projects utilizing macro-based APIs are significantly improved by eliminating the need to build the swift-syntax library during clean builds. This optimization, supported by Swift PM and Xcode, can reduce build times by minutes. This release also enhances compiler diagnostics documentation by providing more detailed explanations of common warnings and errors, making them easier to understand and resolve. Additionally, you now have greater control over compiler warnings; you can specify which warnings to treat as errors, a feature driven by community feedback.
- 7:36 - Development workflow: Debugging
- Debugging is also enhanced in Swift 6.2, particularly for asynchronous code, with improved LLDB functionality, task naming and visibility in Instruments profiles. It also has faster debugger response times due to explicitly built modules enabled by default in Xcode 26.
- 9:14 - Libraries: Subprocess
- This release introduces the new Subprocess package, with which you can launch and manage subprocesses directly from Swift code. The package gives you fine-grained control over process execution, so you can specify the executable path. When the subprocess terminates, you can inspect the exit status, standard output, and other information about the process execution, with version 0.1 now available and ready for feedback.
- 10:45 - Libraries: Foundation
- The Foundation Workgroup enhanced iOS app development by introducing concrete types for notification names and payloads, streamlining code, eliminating errors, and improving thread safety for both framework and custom notifications. You can also add concrete notification types for your own notifications.
- 12:31 - Libraries: Observation
- The Observation Library in Swift uses the observer pattern to track state changes in an object graph. The 'Observable' macro enables observation tracking. Swift 6.2 introduces the 'Observations' type, with which you can create an 'AsyncSequence' to stream state changes based on a closure that computes a value from observable properties. Updates are transactional, ensuring consistent state, and you can iterate over them using a for-await loop.
- 14:13 - Libraries: Testing
- Using Swift Testing, a cross-platform library, you can write and organize tests by using macros. Swift 6.2 enhances this capability with custom attachments for better failure diagnosis, especially in remote environments, and exit tests to validate code that terminates under specific conditions. These features support testing portable Swift code, beyond just your application code.
- 16:08 - Swift throughout the stack: Embedded Swift
- Swift 6.2 enhances Embedded Swift, enabling you to write code for embedded devices, servers, and security-critical components. It now includes full-string APIs, Swift's 'any' types for class-constrained protocols, and new APIs like 'InlineArray' and 'Span' for working efficiently with regions of memory. Apple uses Embedded Swift in some of the lowest-level software on iPhone, and the community created examples available on GitHub in the swift-embedded-examples repository.
- 18:00 - Swift throughout the stack: Security
- Swift 6.2 introduces strict-memory-safety mode, an opt-in feature that requires explicit acknowledgment of unsafe API uses, aiding in identifying security-critical code sections. Apple is adopting this mode in WebKit and a Messages app subsystem, which both handle untrusted input.
- 19:37 - Swift throughout the stack: Server
- Swift is widely used in the server ecosystem, particularly at Apple, where it powers backend services processing millions of requests per second. A notable example is a password alert service, previously built in Java, which saw a 40% increase in throughput and a 50% reduction in hardware requirements after being rewritten in Swift. Other companies, such as Cultured Code, also benefited significantly from adopting Swift. The Things Cloud backend, reimplemented in Swift, experienced a 3x reduction in compute costs and a 400% improvement in average response times. Swift's growing package ecosystem, interoperability with C, Objective-C, and C++, and new open source projects like swift-java and a containerization library, enable developers to build efficient, performant server backends, and seamlessly integrate Swift with existing codebases, particularly in Java.
- 23:23 - Swift throughout the stack: Platforms
- Swift 6.2 now officially supports FreeBSD and WebAssembly (Wasm), enabling you to build client and server applications for browsers and other runtimes. The Wasm support, which started as a community project, allows you to compile Swift code and run it in the browser, as demonstrated by a 3D rendering app using WebGPU and JavaScriptKit. Swift's safety, ease of use, and performance make it an attractive choice throughout the software stack.
- 26:11 - Language evolution: Performance
- The new release also introduces two new types, 'InlineArray' and 'Span', to enhance performance of critical code. 'InlineArray' is a fixed-size array that stores elements directly, eliminating the need for heap allocation. This improves performance, especially in hot paths, and enables more optimizations like eliminating bounds checking. The system specifies the size of an 'InlineArray' as part of the type, and can infer it from array literals. 'Span' provides fast, direct access to contiguous memory without compromising memory safety. It allows functions to operate over the underlying storage of various container types, such as 'Array' and 'InlineArray', safely and efficiently. 'Span' ensures memory validity through compile-time checks, preventing common memory safety issues inherent to pointers.
- 30:28 - Language evolution: Concurrency
- Concurrency is a challenging aspect of programming due to the potential for data races when multiple tasks share memory. Swift 6 introduced data-race safety at compile time, but this often led to compiler errors when because the language would offload work to the background implicitly, even if you never needed the code to run in parallel. Swift 6.2 addresses this issue by changing the default philosophy to stay single-threaded until the you explicitly introduce concurrency. This capability, by default, makes the most natural code to write data race-free. The language now allows async functions that aren't tied to a particular actor to continue in the same actor it was called from, eliminating data races. The release also introduces isolated conformances, enabling main actor types to conform to protocols while ensuring the compiler protects main actor state. Additionally, there's now an opt-in mode to infer the main actor by default, reducing concurrency annotations in mostly single-threaded code. When you need concurrency for performance improvement, such as offloading CPU-intensive tasks to the background, Swift 6.2 provides tools to do so safely. The concurrent attribute ensures that specific functions run on the concurrent thread pool, freeing up the current actor to perform tasks simultaneously. These changes work together to make concurrency more approachable and easier to implement in Swift projects.
- 37:15 - Wrap up
- User feedback led to Swift's concurrency improvements, making it more user friendly. The community is encouraged to participate in the forums at Swift.org to continue language and ecosystem development, share projects, and stay updated on Swift-related events.

関連する章

リソース

関連ビデオ

WWDC25

WWDC24