Apply modern Swift language patterns and idioms for non-concurrency, non-SwiftUI code. Covers if/switch expressions (Swift 5.9+), typed throws (Swift 6+), result builders, property wrappers, opaque and existential types (some vs any), guard patterns, Never type, Regex builders (Swift 5.7+), basic Co

Swift Language Patterns Apply current Swift language syntax without changing behavior or evaluation order. Route deep decoding to swift codable , formatting to swift formatstyle , naming to swift api design guidelines , concurrency to swift concurrency , and SwiftUI state/view work to swiftui patterns . Contents [If/Switch Expressions]( ifswitch expressions) [Typed Throws]( typed throws) [Result Builders]( result builders) [Property Wrappers]( property wrappers) [Opaque and Existential Types]( opaque and existential types) [Guard Patterns]( guard patterns) [Never Type]( never type) [Regex Builders]( regex builders) [Codable Best Practices]( codable best practices) [Modern Collection APIs]( modern collection apis) [FormatStyle]( formatstyle) [String Interpolation]( string interpolation) [Common Mistakes]( common mistakes) [Review Checklist]( review checklist) [References]( references) If/Switch Expressions For modernization, pin current behavior and evaluation order, make one semantic rewrite, compile the affected module, and run focused fixtures/tests. Fix any change before continuing; repeat until behavior is preserved. Swift 5.9+ allows if and switch as expressions that return values. Use them to assign, return, or initialize directly. Rules: Every branch must produce a value of the same type. Multi statement branches are not allowed each branch is a single expression. Wrap in parentheses when used as a function argument to avoid ambiguity. Typed Throws Swift 6+ allows specifying the error type a function throws. Rules: Use throws(SomeError) only when callers benefit from exhaustive error handling. For mixed error sources, use untyped throws . When modernizing a helper with one local error enum, prefer throws(ErrorEnum) and note Swift 6+. throws(Never) marks a function that syntactically throws but never actually does useful in generic contexts. Typed throws propagate: a function calling throws(A) and throws(B) must itself throw a type that covers both (or use untyped throws ). Result Builders @resultBuilder enables DSL style syntax. SwiftUI's @ViewBuilder is the most common example, but you can create custom builders for any domain. Builder methods: buildBlock (combine statements), buildExpression (single value), buildOptional ( if without else ), buildEither ( if/else ), buildArray ( for..in ), buildFinalResult (optional post processing). Property Wrappers Custom @propertyWrapper types encapsulate storage and access patterns. Design rules: wrappedValue is the primary getter/setter. projectedValue (accessed via $property ) provides metadata or bindings. Property wrappers can be composed: @A @B var x applies outer wrapper first. Do not use property wrappers when a simple computed property suffices. Opaque and Existential Types some Protocol (Opaque Type) The caller does not know the concrete type, but the compiler does. A some P return has one fixed underlying concrete type across all return branches. Use some for: Return types when you want to hide implementation but preserve type identity. Parameter types (Swift 5.7+): some P is shorthand for an unnamed generic parameter such as <T: P . any Protocol (Existential Type) An existential box that can hold any conforming type at runtime. It uses dynamic dispatch and may allocate when the value does not fit in the inline buffer. When to choose Use some Use any Return type hiding concrete type Heterogeneous collections Function parameters (replaces simple generics) Dynamic type erasure needed Better performance (static dispatch) Protocol has Self or associated type requirements you need to erase Rule of thumb: Default to some . Use any only when you need a heterogeneous collection or runtime type flexibility. Guard Patterns guard enforces preconditions and enables early exit. It keeps the happy path left aligned and reduces nesting. Best practices: Use guard for preconditions, if for branching logic. Combine related guards: guard let a, let b else { return } . The else block must exit scope: return , throw , continue , break , or fatalError() . Use shorthand unwrap: guard let value else { ... } (Swift 5.7+). Never Type Never is an uninhabited type for code paths that never produce a value. It behaves like Swift's bottom type only where a value expression can be used or inferred; it is not a universal type witness, does not implicitly conform to arbitrary protocols, and cannot satisfy generic constraints such as T: P unless the constraint is otherwise valid for Never . Regex Builders Swift 5.7+ Regex builder DSL provides compile time checked, readable patterns. When to use builder vs. literal: Builder: complex patterns, reusable components, strong typing on captures. Literal ( /pattern/ ): simple patterns, familiarity with regex syntax. Both can be mixed: embed /.../ literals inside builder blocks. Codable Best Practices Use CodingKeys for simple renames and custom decoding only for real payload shape or transformation mismatches. Load [extended Swift patterns](references/swift patterns extended.md) for a compact language example; use swift codable for implementation and verification. Modern Collection APIs Prefer these modern APIs over manual loops: FormatStyle Use .formatted() and Text( :format:) for basic display. Route style selection, parsing, localization testing, and reusable formatter design to swift formatstyle . String Interpolation Extend DefaultStringInterpolation for domain specific formatting. Use """ for multi line strings (indentation is relative to the closing """ ). See [references/swift patterns extended.md](references/swift patterns extended.md) for custom interpolation examples. Common Mistakes 1. Using any when some works. Default to some for return types and parameters, but every some P branch must return the same concrete type. 2. Manual loops or .filter { }.count instead of collection APIs. Use count(where:) for conditional counts, plus contains(where:) , compactMap , and flatMap instead of extra iteration or arrays. 3. DateFormatter instead of FormatStyle. .formatted() is simpler, type safe, and handles localization automatically. 4. Force unwrapping Codable decodes. Use decodeIfPresent with defaults for optional or missing keys. 5. Reordering preconditions during modernization. Use guard without moving normalization or transformations before validation. 6. Invalid @c signatures. Say UnsafeBufferPointer is a Swift struct/value wrapper, then reject String , Array , closures, and generic placeholders. 7. Ignoring typed throws. When a function has a single, clear error type, typed throws give callers exhaustive switch without casting. 8. Overusing property wrappers. A computed property is simpler when there is no reuse or projected value needed. 9. Underspecifying Never . For Result<T, Never or throws(Never) , write the caveat explicitly: Never does not implicitly conform to arbitrary protocols, cannot satisfy arbitrary T: P constraints, and is bottom like only in valid expression/inference contexts. 10. Owning sibling implementation. Name the owner skill and stop. Avoid snippets for CodingKeys , decoders, formatters, SwiftUI, or concurrency. Review Checklist [ ] some used only when every opaque return branch has one concrete type [ ] guard for preconditions; count(where:) instead of manual counting or .filter { }.count [ ] .formatted() used instead of DateFormatter / NumberFormatter [ ] Codable types use CodingKeys for API mapping; decodeIfPresent with defaults for optional fields [ ] if/switch expressions for conditional assignment; property wrappers have clear reuse justification [ ] Regex builder used for complex patterns (literal OK for simple ones) [ ] Typed throws used for single local error domains, with Swift 6+ compatibility noted [ ] @c corrections call UnsafeBufferPointer a Swift struct/value wrapper and enumerate rejected Swift only types by name [ ] Never guidance uses uninhabited and bottom like, and says no implicit arbitrary protocol/generic conformance [ ] deep Codable to swift codable ; FormatStyle APIs to swift formatstyle ; market/localized display QA to ios localization ; naming/concurrency/SwiftUI routed to sibling skills References Extended patterns and Codable examples: [references/swift patterns extended.md](references/swift patterns extended.md) Attributes and C interop: [references/swift attributes interop.md](references/swift attributes interop.md)

swift-language