swift-lang

Swift language mastery skill covering advanced language features beyond UI.Use when working with macros, concurrency (async/await, actors), networking,Swift Testing, generics, memory optimization, or result builders. Not for SwiftUI patterns - see swift-ui.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

The swift-lang skill is a specialized resource for mastering advanced Swift programming features beyond basic UI implementation. It provides deep technical guidance on implementing Swift Macros for code automation, managing structured concurrency with actors and async/await, and optimizing memory performance. Designed for professional developers, it ensures the creation of robust, high-performance systems by leveraging modern Swift 5.9+ capabilities like the Swift Testing framework and custom result builders.

Use Cases

  • Developing custom Swift Macros (Freestanding or Attached) to automate repetitive boilerplate and create expressive, compile-time checked APIs.
  • Architecting thread-safe applications using actors, @MainActor, and Sendable protocols to eliminate data races in complex asynchronous environments.
  • Migrating legacy test suites to the modern Swift Testing framework to utilize parameterized tests and advanced trait-based filtering.
  • Optimizing application performance by analyzing memory management patterns, reducing allocations, and implementing copy-on-write optimizations.
  • Designing highly reusable and type-safe components using advanced generics, primary associated types, and existential types with 'any' and 'some' keywords.
nameswift-lang
description|

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
  • swift-ui - SwiftUI view patterns and architecture
  • design-review - App Store submission prep