Modern Swift

What it does

This skill generates clean, modern Swift code snippets for SwiftUI views and related frontend tasks, optimized for performance using Swift 6.2+ features. It focuses on utilizing new concurrency patterns like async/await, @MainActor, and actor to replace older approaches (completion handlers, DispatchQueue, locks) and ensure compile-time safety against data races. The skill emphasizes leveraging these modern techniques for thread-safe code and efficient asynchronous operations.

When to use it

• When needing to convert existing completion handler based code to Swift's new async/await syntax.
• For implementing UI updates that require execution on the main thread using @MainActor.
• When dealing with shared mutable state, replacing locks or serial queues with actors for safer concurrency.
• To run multiple asynchronous operations in parallel utilizing TaskGroup.
• When migrating legacy code to incorporate modern Swift attributes like @preconcurrency and @backDeployed.

Key capabilities

• Generates code using async/await for asynchronous operations.
• Utilizes @MainActor for UI updates on the main thread.
• Employs actor for managing shared mutable state safely.
• Supports the use of TaskGroup for parallel task execution.
• Provides guidance on implementing task cancellation with Task.isCancelled and Task.checkCancellation().

Example prompts

• "Generate a SwiftUI view that fetches data asynchronously using async/await."
• "Show me how to update a UI element safely using @MainActor."
• "How do I use an actor to manage shared state in Swift?"

Tips & gotchas

• Reference Loading: Always load reference files, especially when dealing with concurrency patterns. This ensures the skill has access to necessary context and best practices.
• Avoid @unchecked Sendable: Using this as a quick fix silences compiler errors but can mask potential data races; address the underlying issue instead.
• Task Cancellation is Crucial: Remember to check Task.isCancelled or call Task.checkCancellation() within loops for long-running operations to ensure cancellation signals are processed correctly.