The Swift Programming Language (TSPL)

The Swift documentation is organized into three distinct parts, each serving a different purpose:

1. A Swift Tour: A high-level overview designed to be read in one sitting. It provides syntax and a taste of the language, making it suitable for beginners or experienced programmers looking to get started quickly. It relies on the Guide for in-depth explanations.
2. Language Guide: A pedagogical, step-by-step instructional text. It follows a linear order (Basic, Data Modeling, and Advanced topics) and uses examples to explain how features work and when to use them.
3. Language Reference: An exhaustive, technical description of the language following its formal grammar. It is not instructional and is intended for unambiguous, detailed lookups. It uses a predictable four-part structure: brief description, code outline, detailed prose, and formal grammar.

A Set is a collection that stores distinct values of the same type in no defined order. Use a Set instead of an Array when:

1. The order of items is not important.
2. You need to ensure that each item appears only once (uniqueness).

Note: Swift's Set type is bridged to Foundation's NSSet class.

Swift statements group expressions and control the flow of execution. They are categorized into three main types:

1. Simple statements: The most common type, consisting of either an expression or a declaration.
2. Compiler control statements: Used to change aspects of the compiler's behavior (e.g., conditional compilation blocks).
3. Control flow statements: Used to manage execution flow. These include:
   • Loop statements: For repeated execution.
   • Branch statements: For conditional execution.
   • Control transfer statements: To alter the order of execution.
   • do statement: To introduce scope and handle errors.
   • defer statement: To run cleanup actions before a scope exits.

A semicolon (;) can optionally be used to separate multiple statements on a single line.

Swift uses Automatic Reference Counting (ARC) to track and manage your app's memory usage. ARC automatically frees up the memory used by class instances when those instances are no longer needed.

Key details:

• ARC applies only to instances of classes.
• Structures and enumerations are value types and are not managed by ARC.
• ARC tracks how many properties, constants, and variables are currently referring to each class instance. An instance is only deallocated when its reference count reaches zero.

Optional chaining is a process for querying and calling properties, methods, and subscripts on an optional that might be nil.

• If the optional contains a value, the call succeeds.
• If the optional is nil, the call fails gracefully and returns nil.
• Multiple queries can be chained together; if any link in the chain is nil, the entire chain fails gracefully.

Key Behavior: The result of an optional chaining call is always an optional value, even if the property or method being queried returns a non-optional value. For example, accessing an Int property through optional chaining returns an Int?.

Type casting is a way to determine a value's runtime type or to treat an instance as a different superclass or subclass within its own class hierarchy. This allows you to access specific properties or methods that are not available on the instance's current declared type.

In Swift, type casting is primarily implemented using the is and as operators. You can also use type casting to check if a type conforms to a specific protocol.

Swift provides three primary collection types for storing collections of values. All collection types are type-safe, meaning they are clear about the types of values and keys they can store, preventing accidental insertion of incorrect types and ensuring predictable retrieval.

• Arrays: Ordered collections of values.
• Sets: Unordered collections of unique values.
• Dictionaries: Unordered collections of key-value associations.

Initialization is the process of preparing an instance of a class, structure, or enumeration for use. This involves setting an initial value for every stored property and performing any necessary one-time setup required before the instance is ready.

You implement this process by defining initializers—special methods used to create new instances. Unlike Objective-C initializers, Swift initializers do not return a value; their sole purpose is to ensure instances are correctly initialized before use.

A result builder is a type that provides a declarative syntax for creating nested data structures (like lists or trees). It allows you to use standard Swift syntax, such as if, else, and for loops, within a closure to build a complex value.

When you apply a result builder attribute to a function parameter, Swift transforms the declarative code inside the closure into a series of calls to specific static methods on the result builder type. This eliminates the need for deeply nested initializers and manual logic for conditional or repeated data.

@resultBuilder
struct DrawingBuilder {
    static func buildBlock(_ components: Drawable...) -> Drawable {
        return Line(elements: components)
    }
}

func draw(@DrawingBuilder content: () -> Drawable) -> Drawable {
    return content()
}

// Usage
draw {
    Stars(length: 3)
    Text("Hello")
}

A Dictionary stores associations between keys of the same type and values of the same type in a collection with no defined ordering. Each value is associated with a unique Key, which acts as an identifier. Use a dictionary when you need to look up values based on an identifier.

Key Requirements:

• The Key type must conform to the Hashable protocol.
• Swift's Dictionary type is bridged to Foundation's NSDictionary class.