Swift Reference

Getting Started — what Swift is, a short history from 2014 to Swift 6.3, the language-mode-versus-compiler-version distinction, the available toolchains, the REPL and swiftc, and your first Swift package.

Lexical Structure and Style — whitespace, comments and documentation comments, identifiers and backtick-escaped keywords, every literal form, operators and how they are tokenised, semicolons, the API Design Guidelines, MARK/TODO comments, and swift-format.

Basics: Constants, Variables and Types — let/var, type annotations and inference, printing and interpolation, the integer and floating-point types, numeric literals and conversions, type aliases, Bool, tuples, and assertions/preconditions/fatalError.

Optionals — nil and the Optional enum, optional binding, the nil-coalescing operator, forced unwrapping, implicitly unwrapped optionals, optional chaining, the optional pattern, and map/flatMap on optionals.

Operators — assignment, arithmetic, comparison, the ternary operator, nil-coalescing, ranges, logical operators and short-circuiting, and the full precedence table.

Strings and Characters — string literals, value semantics, concatenation and interpolation, Unicode scalars versus extended grapheme clusters, String.Index, Substring and slicing, comparison, and the UTF-8/UTF-16/scalar views.

Collections — Array, Set and Dictionary, slices and ranges as collections, the Sequence/Collection protocol family, the higher-order essentials, lazy, zip, stride, and the Swift 6.2 InlineArray and Span types.

Control Flow — for-in, while/repeat-while, if/switch as statements and expressions, exhaustiveness and value binding, continue/break/ fallthrough, guard, defer, and #available/#unavailable.

Pattern Matching — the eight pattern kinds and where each may appear, nested destructuring, custom ~= overloads, and matching against ranges and regular expressions.

Functions — parameters and return values, argument labels, default and variadic parameters, inout and the copy-in copy-out model, borrowing/consuming, function types, nested functions, @discardableResult, and overloading.

Closures — closure expressions and shorthand syntax, trailing closures, capturing values, escaping versus non-escaping, autoclosures, capture lists, and @Sendable closures.

Enumerations — enum syntax and matching with switch, CaseIterable, associated values, raw values, recursive enums with indirect, OptionSet, and enums as state machines.

Structures and Classes — definition syntax, memberwise initializers, value versus reference types, identity operators, copy-on-write, and noncopyable types (~Copyable).

Properties — stored and lazy properties, computed properties, property observers, property wrappers, type properties, and the Observation module’s @Observable.

Methods and Subscripts — instance and type methods, mutating methods, subscript syntax and variants, callAsFunction, and @dynamicCallable.

Inheritance — base classes, subclassing, overriding and super, final, dynamic dispatch and polymorphism, and when to subclass versus compose or use protocols.

Initialization and Deinitialization — initializer parameters, default and memberwise initializers, designated versus convenience initializers, two-phase initialization, required and failable initializers, and deinit.

Extensions and Nested Types — extension syntax, adding computed properties/initializers/methods/subscripts, retroactive conformance, and nested types for namespacing.

Protocols — requirements, protocols as types (any P), conformance via extensions and conditional conformance, synthesized conformances, protocol inheritance and composition, and protocol-oriented design.

Generics — generic functions and types, constraints, associated types, generic where clauses, integer generic parameters, and some P as lightweight generic-parameter syntax.

Opaque and Boxed Protocol Types — returning some P, boxed protocol (existential) types any P and their runtime cost, opaque parameter types, implicitly opened existentials, and choosing between some, any and explicit generics.

Type Casting and Reflection — is, as?, as!, Any versus AnyObject, metatypes, bridging casts to Foundation types, and reflection with Mirror.

Error Handling — the Error protocol, throw, the four ways to handle errors, typed throws, rethrows, Result<Success, Failure>, and defer.

Automatic Reference Counting — how ARC works, strong reference cycles between class instances and in closures, resolving them with weak and unowned, and diagnosing leaks.

Memory Safety and Unsafe Pointers — the exclusivity rules for inout parameters and mutating methods, and the unsafe pointer layer together with the safe non-owning Span/RawSpan alternatives.

Access Control — the six access levels, the guiding principle and defaults, and access levels for custom types, properties, initializers, protocols and generics.

Async/Await and Tasks — async functions and await, AsyncSequence, async let, structured concurrency with Task and task groups, cancellation, and task-local values.

Actors, Isolation and Sendable — isolation domains, @MainActor, actors and reentrancy, global actors, Sendable and sending, strict concurrency checking, default actor isolation, and the Synchronization module.

Dispatch and Legacy Concurrency — Grand Central Dispatch queues, DispatchGroup, barriers and semaphores, Operation/OperationQueue, and wrapping both for async/await.

Advanced Operators — bitwise operators and shifts, overflow operators, operator methods on custom types, and custom operators and precedence groups.

Result Builders — @resultBuilder, buildBlock and the other build methods, building a small DSL, and how SwiftUI’s ViewBuilder uses the same mechanism.

Key Paths and Dynamic Member Lookup — the KeyPath hierarchy, reading and writing through key paths, and @dynamicMemberLookup.

Regular Expressions — regex literals and extended delimiters, the Regex type, typed captures, and the RegexBuilder DSL.

Macros — freestanding and attached macros, macro declarations and hygiene, and implementing a macro with swift-syntax.

Attributes and Compiler Control — the declaration and type attributes that matter day to day, declaration modifiers, and conditional compilation.

Functional Programming — immutability, pure and higher-order functions, composition, currying and recursion, and Optional/Result as containers.

Standard Library Overview — the numeric, Equatable/Hashable/Comparable and ExpressibleBy…​Literal protocols, Sequence/Collection, Optional/Result, and print/readLine.

Codable and Serialization — Encodable/Decodable, synthesized conformance, JSONEncoder/JSONDecoder, custom encoding, and parsing XML with Foundation’s XMLParser.

Foundation Essentials — Date, Calendar, URL, Data, FileManager, URLSession with async/await, and bridging between Swift and NS types.

Interoperability with C, Objective-C and C++ — how the Clang importer maps C into Swift, Objective-C interop and bridging, C++ interop, and cross-references to the C, C++ and Objective-C references.

Swift Package Manager — Package.swift and PackageDescription, products and targets, dependency version rules, the swift build/run/test/ package commands, and publishing a package.

Build and Tooling — swiftc essentials, language modes versus compiler versions, Swiftly, cross-platform builds, debugging with LLDB, and DocC.

Testing — Swift Testing (@Test, #expect, #require, @Suite) and XCTest, @testable import, and a pointer to XCUITest as Apple-platform-only.

Cheat Sheet (PDF) — a single-page, printable Swift quick reference covering types, optionals, strings, collections, control flow, functions and closures, enums, structs and classes, properties, initializers, protocols, generics, error handling, ARC, access levels, concurrency, regex and key paths, macros, attributes, Package.swift, and Swift Testing/XCTest.