swift-lang Skill | Agent Skills

swift-lang

Advanced Swift language features for building robust, performant code.

Scope

This skill covers Swift language internals - the deep features that make you a better Swift developer. For SwiftUI implementation patterns, see swift-ui.

Routing

Based on what you're building, load the appropriate reference:

Macros

When: Creating compile-time code generation, reducing boilerplate, building DSLs References:

references/macros/freestanding.md - ExpressionMacro, DeclarationMacro
references/macros/attached.md - PeerMacro, AccessorMacro, MemberMacro, ExtensionMacro, BodyMacro

Macro Types Overview: | Type | Category | Purpose | |------|----------|---------| | ExpressionMacro | Freestanding | Return an expression (like a global function) | | DeclarationMacro | Freestanding | Declare variables, structs, functions | | PeerMacro | Attached | Add sibling declarations | | AccessorMacro | Attached | Add get/set to properties | | MemberMacro | Attached | Add members to types | | MemberAttributeMacro | Attached | Add attributes to members | | ExtensionMacro | Attached | Add protocol conformance | | BodyMacro | Attached | Replace function body |

Concurrency

When: async/await patterns, actor isolation, Sendable conformance, data race prevention References:

references/concurrency/async-await.md - Structured concurrency patterns
references/concurrency/actors.md - Actor isolation, @MainActor
references/concurrency/sendable.md - Sendable conformance, crossing isolation boundaries

Testing

When: Writing tests with Swift Testing framework, test strategies References:

references/testing/swift-testing.md - @Test, #expect, traits, parameterized tests
references/testing/strategies.md - What to test, dependency injection for testing

Generics

When: Protocol design, associated types, existentials, type erasure References:

references/generics/protocols.md - Associated types, primary associated types
references/generics/existentials.md - any vs some, type erasure patterns

Optimization

When: Memory management, performance profiling, reducing allocations References:

references/optimization/memory.md - ARC, weak/unowned, copy-on-write
references/optimization/performance.md - Instruments, allocation patterns

Result Builders

When: Building custom DSLs, understanding @ViewBuilder internals References:

references/result-builders/custom-dsl.md - Building your own @resultBuilder

Networking

When: Making HTTP requests, API clients, async data fetching References:

references/networking/async-networking.md - URLSession with async/await, API client patterns

Key Patterns:

Async/await with URLSession
Actor-based API clients
Authentication and retry logic
Concurrent requests with async let
Error handling and cancellation

Quick Reference

Macro Package Setup

// Package.swift for macro development
// swift-tools-version: 5.9
import PackageDescription
import CompilerPluginSupport

let package = Package(
    name: "MyMacros",
    platforms: [.macOS(.v10_15), .iOS(.v13)],
    products: [
        .library(name: "MyMacros", targets: ["MyMacros"]),
    ],
    dependencies: [
        .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0"),
    ],
    targets: [
        .macro(
            name: "MyMacrosMacros",
            dependencies: [
                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
                .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
            ]
        ),
        .target(name: "MyMacros", dependencies: ["MyMacrosMacros"]),
    ]
)

Concurrency Essentials

// Structured concurrency
func fetchData() async throws -> Data {
    try await withThrowingTaskGroup(of: Data.self) { group in
        // Add tasks to group
    }
}

// Actor isolation
@MainActor
class ViewModel: ObservableObject {
    @Published var items: [Item] = []
}

// Sendable conformance
struct Config: Sendable {
    let apiKey: String
}

Swift Testing

import Testing

@Test("User authentication succeeds with valid credentials")
func validLogin() async throws {
    let auth = AuthService()
    let result = try await auth.login(user: "test", pass: "valid")
    #expect(result.isAuthenticated)
}

@Test(arguments: ["", "ab", "toolong123"])
func invalidUsername(_ username: String) {
    #expect(!Validator.isValidUsername(username))
}

Anti-Patterns

Force unwrapping in production code
Ignoring actor isolation warnings
Using nonisolated(unsafe) without understanding implications
Massive macro implementations (split into helpers)
Testing implementation details instead of behavior

Related Skills

swift-ui - SwiftUI view patterns and architecture
design-review - App Store submission prep

Agent Skills: swift-lang

Install this agent skill to your local

Skill Files