swift-language
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…
Install / Use
npx skills add dpearson2699/swift-ios-skills --skill swift-languageInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Content & MediaSupported Platforms
Our assessment of swift-language
swift-language scores 89/100 on our quality scale, 526th of 1,153 Content & Media skills we index (top 46%).
Its SKILL.md is 15 KB long, well organised into 20 sections with 10 code examples: a thorough specification that gives an agent plenty to work with.
With 1,143 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-10-31 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 86/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
swift-language compared with similar skills
All 4 of these similar skills score higher than swift-language; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| swift-language (this skill)by dpearson2699 | 89 | 1.1k | 4mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 9d ago | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
| Scraplingby D4Vinci | 100 | 103.6k | 2d ago | MCP Server |
| crawl4aiby unclecode | 100 | 87.4k | 3d ago | MCP Server |
Frequently asked questions
- How do I install swift-language?
- Run
npx skills add dpearson2699/swift-ios-skills --skill swift-language. The install tabs above show the steps for each supported agent. - Which AI agents does swift-language work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is swift-language safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 86/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is swift-language still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: swift-language description: "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 Codable shaping (CodingKeys, custom decoding, nested containers), modern collection APIs (count(where:), contains(where:), replacing()), basic FormatStyle usage, and string interpolation patterns. Use when writing core Swift code involving generics, protocols, enums, closures, or modern language features; route deep Codable to swift-codable, detailed formatting/localization to swift-formatstyle, and API naming to swift-api-design-guidelines."
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
- Typed Throws
- Result Builders
- Property Wrappers
- Opaque and Existential Types
- Guard Patterns
- Never Type
- Regex Builders
- Codable Best Practices
- Modern Collection APIs
- FormatStyle
- String Interpolation
- Common Mistakes
- Review Checklist
- 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.
// Assign from if expression
let icon = if isComplete { "checkmark.circle.fill" } else { "circle" }
// Assign from switch expression
let label = switch status {
case .draft: "Draft"
case .published: "Published"
case .archived: "Archived"
}
// Works in return position
func badgeText(for priority: Priority) -> String {
switch priority {
case .high: "High"
case .medium: "Medium"
case .low: "Low"
}
}
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.
enum ValidationError: Error {
case tooShort, invalidCharacters, alreadyTaken
}
func validate(username: String) throws(ValidationError) -> String {
guard username.count >= 3 else { throw .tooShort }
guard username.allSatisfy(\.isLetterOrDigit) else { throw .invalidCharacters }
return username.lowercased()
}
// Caller gets typed error -- no cast needed
do {
let name = try validate(username: input)
} catch {
// error is ValidationError, not any Error
switch error {
case .tooShort: print("Too short")
case .invalidCharacters: print("Invalid characters")
case .alreadyTaken: print("Taken")
}
}
Rules:
- Use
throws(SomeError)only when callers benefit from exhaustive error handling. For mixed error sources, use untypedthrows. - 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)andthrows(B)must itself throw a type that covers both (or use untypedthrows).
Result Builders
@resultBuilder enables DSL-style syntax. SwiftUI's @ViewBuilder is the most
common example, but you can create custom builders for any domain.
@resultBuilder
struct ArrayBuilder<Element> {
static func buildBlock(_ components: [Element]...) -> [Element] {
components.flatMap { $0 }
}
static func buildExpression(_ expression: Element) -> [Element] { [expression] }
static func buildOptional(_ component: [Element]?) -> [Element] { component ?? [] }
static func buildEither(first component: [Element]) -> [Element] { component }
static func buildEither(second component: [Element]) -> [Element] { component }
static func buildArray(_ components: [[Element]]) -> [Element] { components.flatMap { $0 } }
}
func makeItems(@ArrayBuilder<String> content: () -> [String]) -> [String] { content() }
let items = makeItems {
"Always included"
if showExtra { "Conditional" }
for name in names { name.uppercased() }
}
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.
@propertyWrapper
struct Clamped<Value: Comparable> {
private var value: Value
let range: ClosedRange<Value>
var wrappedValue: Value {
get { value }
set { value = min(max(newValue, range.lowerBound), range.upperBound) }
}
var projectedValue: ClosedRange<Value> { range }
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
self.range = range
self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
}
}
// Usage
struct Volume {
@Clamped(0...100) var level: Int = 50
}
var v = Volume()
v.level = 150 // clamped to 100
print(v.$level) // projected value: 0...100
Design rules:
wrappedValueis the primary getter/setter.projectedValue(accessed via$property) provides metadata or bindings.- Property wrappers can be composed:
@A @B var xapplies 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.
func makeCollection() -> some Collection<Int> {
[1, 2, 3] // Always returns Array<Int> -- compiler knows the concrete type
}
Use some for:
- Return types when you want to hide implementation but preserve type identity.
- Parameter types (Swift 5.7+):
some Pis 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.
func process(items: [any StringProtocol]) {
for item in items {
print(item.uppercased())
}
}
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.
func processOrder(_ order: Order?) throws -> Receipt {
// Unwrap optionals
guard let order else { throw OrderError.missing }
// Validate conditions
guard order.items.isEmpty == false else { throw OrderError.empty }
guard order.total > 0 else { throw OrderError.invalidTotal }
// Boolean checks
guard order.isPaid else { throw OrderError.unpaid }
// Pattern matching
guard case .confirmed(let date) = order.status else {
throw OrderError.notConfirmed
}
return Receipt(order: order, confirmedAt: date)
}
Best practices:
- Use
guardfor preconditions,iffor branching logic. - Combine related guards:
guard let a, let b else { return }. - The
elseblock must exit scope:return,throw,continue,break, orfatalError(). - 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.
// Function that terminates the program
func crashWithDiagnostics(_ message: String) -> Never {
let diagnostics = gatherDiagnostics()
logger.critical("\(message): \(diagnostics)")
fatalError(message)
}
enum Result<Success, Failure: Error> {
case success(Success)
case failure(Failure)
}
// Result<String, Never> -- a result that can never fail
// Exhaustive switch: no default needed since Never has no cases
func handle(_ result: Result<String, Never>) {
switch result {
case .success(let value): print(value)
// No .failure case needed -- compiler knows it's impossible
}
}
Regex Builders
Swift 5.7+ Regex builder DSL provides compile-time checked, readable patterns.
import Foundation
import RegexBuilder
// Parse "2024-03-15" into components
let dateRegex = Regex {
Capture { /\d{4}/ }; "-"; Capture { /\d{2}/ }; "-"; Capture { /\d{2}/ }
}
if let match = "2024-03-15".firstMatch(of: dateRegex) {
let (_, year, month, day) = match.output
_ = (year, month, day)
}
// TryCapture with transform
let priceRegex = Regex {
"$"
TryCapture { OneOrMore(.digit); "."; Repeat(.digit, count: 2) }
transform: { Decimal(string: String($0)) }
}
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 for a compact
language example; use swift-codable for implementation and verification.
Modern Collection APIs
Prefer these modern APIs over manual loops:
let numbers = [1, 2, 3, 4, 5, 6, 7, 8]
// count(where:) -- use instead of .filter { }.count
let evenCount = numbers.count(where: { $0.isMultiple(of: 2) })
// contains(where:) -- short-circuits on first match
let hasNegative = numbers.contains(where: { $0 < 0 })
// first(where:) / last(where:)
let firstEven = numbers.first(where: { $0.isMultiple(of: 2) })
// String replacing() -- Swift 5.7+, returns new string
let cleaned = rawText.replacing(/\s+/, with: " ")
let snakeCase = name.replacing("_", with: " ")
// compactMap -- unwrap optionals from a transform
let ids = strings.compactMap { Int($0) }
// flatMap -- flatten nested collections
let allTags = articles.flatMap(\.tags)
// Dictionary(grouping:by:)
let byCategory = Dictionary(grouping: items, by: \.category)
// reduce(into:) -- efficient accumulation
let freq = words.reduce(into: [:]) { counts, word in
counts[word, default: 0] += 1
}
FormatStyle
Use .formatted() and Text(_:format:) for basic display. Route style
selection, parsing, localization testing, and reusable formatter design to
swift-formatstyle.
String Interpolat
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Scrapling
103.6k🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
crawl4ai
87.4kOfficial Crawl4AI Cloud: a hosted web scraping, extraction, and search API for AI agents. Free API key, 1,000 credits a month, no card. Fully open source: this repo is the Apache-2.0 crawler that powers it, and you can self-host it.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
