SuperAPI AI Directory

swift-language

General & other

View repository

Updated 10-16 06:47

About this skill

Swift Language Patterns

Apply modern Swift 6.3 syntax and idioms without altering behavior or evaluation order. Route concurrency to swift-concurrency, deep serialization to swift-codable, formatting to swift-formatstyle, naming to swift-api-design-guidelines, and SwiftUI state to swiftui-patterns.

Contents

  • Expressions & Control Flow
  • Typed Throws (Swift 6+)
  • Opaque vs Existential Types
  • Result Builders & Property Wrappers
  • Modern Collections & Regex
  • Common Mistakes
  • Review Checklist
  • References

Expressions & Control Flow

Use value-producing if and switch expressions for direct assignment, initialization, and single-expression returns:

// Direct variable initialization from expression
let statusColor = switch order.status {
case .pending: Color.orange
case .completed: Color.green
case .failed: Color.red
}

let badge = if isFeatured { "star.fill" } else { "circle" }

Every branch must produce identical value types without multi-statement bodies.

Typed Throws (Swift 6+)

Specify concrete error types when callers benefit from exhaustive compile-time error handling:

enum PaymentError: Error {
    case cardExpired, insufficientFunds
}

func processPayment() throws(PaymentError) {
    guard hasFunds else { throw .insufficientFunds }
}

// Caller error handling is exhaustive without casting
do {
    try processPayment()
} catch {
    switch error {
    case .cardExpired: promptNewCard()
    case .insufficientFunds: promptDeposit()
    }
}

Use throws(Never) for non-throwing conformance in generic protocols. For mixed or open error sources, retain untyped throws.

Opaque vs Existential Types

  • some Protocol (Opaque): Preferred for return and parameter types. Preserves underlying static type information, enables compiler optimizations, and avoids existential container allocation overhead.
  • any Protocol (Existential): Use only when dynamic heterogeneous collections or runtime polymorphism is explicitly required (e.g. [any Plugin]).
// Parameter pack / opaque parameter
func render(item: some Displayable) { ... }

// Heterogeneous collection requires existential boxing
let plugins: [any Plugin] = [AudioPlugin(), VisualPlugin()]

Result Builders & Property Wrappers

  • @resultBuilder: Construct declarative DSLs by implementing buildBlock, buildOptional, and buildEither.
  • @propertyWrapper: Encapsulate reusable property storage or validation via wrappedValue and projected projectedValue ($).
@propertyWrapper
struct Clamped<T: Comparable> {
    var value: T
    let range: ClosedRange<T>

    var wrappedValue: T {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
}

Modern Collections & Regex

  • Use regex literals #/pattern/# with typed capture groups and RegexBuilder.
  • Leverage Swift collection operations: contains(where:), allSatisfy, min(by:), and non-mutating transformations.

Common Mistakes

  • Defaulting to any instead of some: Using any Protocol incurs existential boxing costs and suppresses type relationship inference. Prefer some Protocol.
  • Overusing typed throws for general errors: Forcing throws(MyError) on functions that wrap URLSession or system APIs requires fragile error translation. Use untyped throws for mixed errors.
  • Multi-statement branches in expressions: if/switch expressions only evaluate single-expression branches. Multi-line logic requires traditional statements.
  • Forgetting parentheses in function calls: Wrap expression arguments in parentheses when passing to functions to avoid parsing ambiguity.
  • Modifying evaluation order during refactoring: When modernizing with expressions, ensure parameter evaluation order remains strictly preserved.

Review Checklist

  • Value-producing if/switch used for concise variable initialization
  • throws(SpecificError) used only where callers genuinely need exhaustive handling
  • some Protocol chosen over any Protocol unless heterogeneous storage is required
  • Regex patterns use modern regex literals or RegexBuilder
  • Property wrappers maintain thread safety and avoid re-entrant side effects

References