The Swift Programming Language

https://github.com/swiftlang/swift-book
Admin
The Swift Programming Language is the official comprehensive guide and documentation for the Swift...
Tokens:377,943
Snippets:3,212
Trust Score:8.8
License:Apache-2.0
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Read and Write Access Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/MemorySafety.md

Shows a write access (variable initialization) and a read access (print) to the same memory location. This is a safe example because the accesses do not overlap.

```swift
// A write access to the memory where one is stored.
var one = 1

// A read access from the memory where one is stored.
print("We're number \(one)!")
```

--------------------------------

### Accessing Integer Bounds with min and max

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/TheBasics.md

Demonstrates using the min and max properties of integer types to get their bounds. The example shows UInt8's minimum and maximum values.

```swift
let minValue = UInt8.min  // minValue is equal to 0, and is of type UInt8
let maxValue = UInt8.max  // maxValue is equal to 255, and is of type UInt8
```

--------------------------------

### Initial array for sorted(by:) examples

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Closures.md

Initial array of String values used in the sorted(by:) examples. The array is not modified by the sorting method.

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
```

--------------------------------

### try with infix operators

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Examples showing how try applies to whole infix expressions and the effect of parentheses.

```swift
// Writing 'try' applies to both function calls.
sum = try someThrowingFunction() + anotherThrowingFunction()

// Writing 'try' applies to both function calls.
sum = try (someThrowingFunction() + anotherThrowingFunction())

// Error: Writing 'try' applies only to the first function call.
sum = (try someThrowingFunction()) + anotherThrowingFunction()
```

--------------------------------

### Instantaneous memory access example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/MemorySafety.md

Shows that most memory accesses are instantaneous. The function call and assignments are all instantaneous accesses, and the output is "2".

```swift
func oneMore(than number: Int) -> Int {
    return number + 1
}

var myNumber = 1
myNumber = oneMore(than: myNumber)
print(myNumber)
// Prints "2".
```

--------------------------------

### Create and configure a VideoMode instance

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/ClassesAndStructures.md

Creates a new VideoMode instance and configures its properties. This example is used to illustrate that classes are reference types, so the instance is not copied when assigned to a constant.

```swift
let tenEighty = VideoMode()

tenEighty.resolution = hd

tenEighty.interlaced = true

tenEighty.name = "1080i"

tenEighty.frameRate = 25.0
```

--------------------------------

### Array Examples for allEqual()

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Protocols.md

Defines two integer arrays to demonstrate the allEqual() method: one with all equal elements and one with differing elements.

```swift
let equalNumbers = [100, 100, 100, 100, 100]
let differentNumbers = [100, 100, 200, 100, 200]
```

--------------------------------

### Combining Logical Operators (&& and ||) Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/BasicOperators.md

Combines multiple logical operators (&& and ||) into a compound expression. The example relies on previously defined variables and prints "Welcome!" because knowsOverridePassword is true.

```swift
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// Prints "Welcome!"
```

--------------------------------

### Equivalent extensions with generic where clauses

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Generics.md

Alternative to the contextual where clause example, using two separate extensions with generic where clauses. This version has the same behavior as the previous example but requires one extension per requirement.

```swift
extension Container where Item == Int {
    func average() -> Double {
        var sum = 0.0
        for index in 0..<count {
            sum += Double(self[index])
        }
        return sum / Double(count)
    }
}
extension Container where Item: Equatable {
    func endsWith(_ item: Item) -> Bool {
        return count >= 1 && self[count-1] == item
    }
}
```

--------------------------------

### Define a simple protocol

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AccessControl.md

Defines a protocol with a single method requirement. This is the base example used to illustrate how extensions can add conformance.

```swift
protocol SomeProtocol {
    func doSomething()
}
```

--------------------------------

### Bitwise XOR Operator Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AdvancedOperators.md

Shows how to use the bitwise XOR operator (^) to compare bits of two UInt8 values. The result has bits set to 1 where the input bits differ and 0 where they are the same. The example uses firstBits and otherBits to produce outputBits equal to 0b00010001.

```swift
let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits  // equals 00010001
```

--------------------------------

### Using #keyPath with a Class Property

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Demonstrates using #keyPath to get the string for a property of a class, and then using it with value(forKey:) to retrieve the value. The output is '12'.

```swift
class SomeClass: NSObject {
    @objc var someProperty: Int
    init(someProperty: Int) {
       self.someProperty = someProperty
    }
}

let c = SomeClass(someProperty: 12)
let keyPath = #keyPath(SomeClass.someProperty)

if let value = c.value(forKey: keyPath) {
    print(value)
}
// Prints "12".
```

--------------------------------

### Check Prefix with hasPrefix(_:)

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/StringsAndCharacters.md

Uses hasPrefix(_:) to check if a string starts with a specific extended grapheme cluster. The example shows that both the composed and decomposed forms of é are recognized as the same prefix.

```swift
let ecole = "\u{E9}cole"
if ecole.hasPrefix("\u{E9}") {
    print("Has U+00E9 prefix, as expected.")
} else {
    print("Does not have U+00E9 prefix, which is unexpected.")
}
// Has U+00E9 prefix, as expected.
if ecole.hasPrefix("\u{65}\u{301}") {
    print("Has U+0065 U+0301 prefix, as expected.")
} else {
    print("Does not have U+0065 U+0301 prefix, which is unexpected.")
}
// Has U+0065 U+0301 prefix, as expected.
```

--------------------------------

### Package.swift setup for macros

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Macros.md

Beginning of a Package.swift file for adding macros to an existing project. Requires a Swift tools version of 5.9 or later, importing CompilerPluginSupport, and including macOS 10.15 as a minimum deployment target in the platforms list.

```swift
// swift-tools-version: 5.9

import PackageDescription
import CompilerPluginSupport

let package = Package(
    name: "MyPackage",
    platforms: [ .iOS(.v17), .macOS(.v13)],
    // ...
)
```

--------------------------------

### Using startsWith(_:) on an Array

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Generics.md

Checks whether an array of integers starts with a given value using the startsWith(_:) method from a Container extension. The output confirms the method works with equatable items.

```swift
if [9, 9, 9].startsWith(42) {
    print("Starts with 42.")
} else {
    print("Starts with something else.")
}
// Prints "Starts with something else."
```

--------------------------------

### Call asynchronous functions with await

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Concurrency.md

Demonstrates calling asynchronous functions using await, which marks possible suspension points. The example fetches photo names, sorts them, and downloads a photo.

```swift
let photoNames = await listPhotos(inGallery: "Summer Vacation")
let sortedNames = photoNames.sorted()
let name = sortedNames[0]
let photo = await downloadPhoto(named: name)
show(photo)
```

--------------------------------

### Create and call incrementer closure

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Closures.md

Creates an incrementer closure with a starting increment of 7 and calls it, returning 7. This example demonstrates that the closure captures and increments its own runningTotal variable.

```swift
let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()
// returns a value of 7
```

--------------------------------

### Key-Path Expression with Optional Chaining

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Demonstrates using a key-path expression with optional chaining to access a property of an optional string. The example shows both optional chaining and the equivalent key-path syntax.

```swift
let firstGreeting: String? = greetings.first
print(firstGreeting?.count as Any)
// Prints "Optional(5)".

// Do the same thing using a key path.
let count = greetings[keyPath: \[String].first?.count]
print(count as Any)
// Prints "Optional(5)".
```

--------------------------------

### Print "Hello, world!"

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/GuidedTour/GuidedTour.md

The traditional first program in Swift. Prints a greeting to the console. This single line is a complete program; no imports or main() function are needed.

```swift
print("Hello, world!")
// Prints "Hello, world!"
```

--------------------------------

### Type annotation examples

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Types.md

Shows the syntax for type annotations: a colon followed by a type. The first line annotates a tuple type, the second annotates a function parameter.

```swift
let someTuple: (Double, Double) = (3.14159, 2.71828)
func someFunction(a: Int) { /* ... */ }
```

--------------------------------

### Nested Macro Expansion Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Shows nested macro-expansion expressions. The outer macro expands first, and the unexpanded inner macro appears in the AST passed to the outer macro.

```swift
#outerMacro(12, #innerMacro(34), "some text")
```

--------------------------------

### Immediate cancellation notification with withTaskCancellationHandler

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Concurrency.md

Use this snippet to get immediate notification when a task is canceled. The cancellation handler prints "Canceled!" when task.cancel() is called. Note that cancellation is cooperative and the task may still be running when the handler starts.

```swift
let task = Task {
    await withTaskCancellationHandler {
        // ...
    } onCancel: {
        print("Canceled!")
    }
}

// ... some time later...
task.cancel()  // Prints "Canceled!"
```

--------------------------------

### Define a simple initializer with init()

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Initialization.md

Shows the basic syntax for an initializer that takes no parameters. Use this when you need to set up a new instance and perform one-time setup. The initializer body is where you set initial values for stored properties.

```swift
init() {
    // perform some initialization here
}
```

--------------------------------

### Conform Stack to SuffixableContainer with Same Suffix Type

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Generics.md

Adds SuffixableContainer conformance to the generic Stack type, where the suffix operation returns another Stack. The example creates a Stack<Int>, appends values, and calls suffix(2) to get the last two elements.

```swift
extension Stack: SuffixableContainer {
    func suffix(_ size: Int) -> Stack {
        var result = Stack()
        for index in (count-size)..<count {
            result.append(self[index])
        }
        return result
    }
    // Inferred that Suffix is Stack.
}
var stackOfInts = Stack<Int>()
stackOfInts.append(10)
stackOfInts.append(20)
stackOfInts.append(30)
let suffix = stackOfInts.suffix(2)
// suffix contains 20 and 30
```

--------------------------------

### Using a Type That Adopts a Protocol

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Protocols.md

After adopting the protocol, instances of Hamster can be used wherever TextRepresentable is required. The example creates a Hamster instance and prints its textual description.

```swift
let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentable = simonTheHamster
print(somethingTextRepresentable.textualDescription)
// Prints "A hamster named Simon".
```

--------------------------------

### Create department and courses with unowned optional nextCourse

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AutomaticReferenceCounting.md

Creates a department and three courses, then links them via the unowned optional nextCourse property and assigns the courses to the department. This demonstrates how to set up a chain of unowned optional references.

```swift
let department = Department(name: "Horticulture")

let intro = Course(name: "Survey of Plants", in: department)
let intermediate = Course(name: "Growing Common Herbs", in: department)
let advanced = Course(name: "Caring for Tropical Plants", in: department)

intro.nextCourse = intermediate
intermediate.nextCourse = advanced
department.courses = [intro, intermediate, advanced]
```

--------------------------------

### Read-Only Computed Property in Cuboid

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Properties.md

Defines a Cuboid structure with a read-only computed property volume that calculates the product of width, height, and depth. The property is declared without a get keyword, and the example shows how to access it via dot syntax and print its value.

```swift
struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}
let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
// Prints "the volume of fourByFiveByTwo is 40.0".
```

--------------------------------

### Postfix operator starting with question mark fails

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/LexicalStructure.md

Attempts to define a postfix operator that starts with a question mark. The compiler rejects it with two errors, because postfix operator names starting with `?` or `!` are disallowed to avoid collisions with built-in unwrapping operators.

```swift
>> postfix operator ?+
>> postfix func ?+ (x: Int) -> Int {
       if x > 10 {
           return x
       }
       return x + 1
   }
>> print(1?+)
!$ error: postfix operator names starting with '?' or '!' are disallowed to avoid collisions with built-in unwrapping operators
!! postfix operator ?+
!!                  ^
!$ error: '+' is not a postfix unary operator
!! print(1?+)
!!         ^
```

--------------------------------

### Call Counter instance methods with dot syntax

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Methods.md

Creates a Counter instance and calls its methods using dot syntax. The example shows the initial counter value, then increments by 1, increments by 5, and resets, printing the counter's value after each operation.

```swift
let counter = Counter()
// the initial counter value is 0
counter.increment()
// the counter's value is now 1
counter.increment(by: 5)
// the counter's value is now 6
counter.reset()
// the counter's value is now 0
```

--------------------------------

### Create instances of a structure and a class using initializer syntax

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/ClassesAndStructures.md

Creates instances of the Resolution structure and VideoMode class using the default initializer syntax, which is the type name followed by empty parentheses.

```swift
let someResolution = Resolution()
let someVideoMode = VideoMode()
```

--------------------------------

### Assignment Operator Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Example of the assignment operator with tuple destructuring. The value is assigned to corresponding parts of the tuple, and the underscore is ignored.

```swift
(a, _, (b, c)) = ("test", 9.45, (12, 3))
// a is "test", b is 12, c is 3, and 9.45 is ignored
```

--------------------------------

### Use shorthand @available syntax for multiple platforms

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Attributes.md

Shows the shorthand syntax for `available` attributes that specify only an `introduced` argument. The first block is the generic form; the second is a concrete example. The shorthand form is preferred when possible and is functionally equivalent to the longer form.

```swift
@available(<#platform name#> <#version number#>, *)
@available(swift <#version number#>)

```

```swift
@available(iOS 10.0, macOS 10.12, *)
class MyClass {
    // class definition
}

```

--------------------------------

### Wildcard Expression Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Demonstrates using a wildcard expression to ignore a value during assignment. In this example, 10 is assigned to x and 20 is ignored.

```swift
(x, _) = (10, 20)
// x is 10, and 20 is ignored
```

--------------------------------

### Use swift() platform condition with version checks

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Statements.md

Demonstrates the swift() platform condition with version comparisons and logical operators. The '<<' lines show expected output; the third condition is false and produces no output.

```swift
-> #if swift(>=2.1)
       print(1)
   #endif
<< 1
-> #if swift(>=2.1) && true
       print(2)
   #endif
<< 2
-> #if swift(>=2.1) && false
       print(3)
   #endif
-> #if swift(>=2.1.9.9.9.9.9.9.9.9.9)
       print(5)
   #endif
<< 5
```

--------------------------------

### Bitwise NOT operator example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AdvancedOperators.md

The bitwise NOT operator (~) inverts all bits in a number. This example initializes a UInt8 with binary 00001111 and inverts it to 11110000 (decimal 240).

```swift
let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits  // equals 11110000
```

--------------------------------

### Define a read-only subscript without get keyword

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Subscripts.md

Defines a read-only subscript by omitting the get keyword and its braces, similar to read-only computed properties.

```swift
subscript(index: Int) -> Int {
    // Return an appropriate subscript value here.
}
```

--------------------------------

### Construct a String from an array of Characters

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/StringsAndCharacters.md

Pass an array of Character values to the String initializer to construct a String. The example builds "Cat!🐱" from an array and prints it.

```swift
let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
print(catString)
// Prints "Cat!🐱".
```

--------------------------------

### Subclassing with super call

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AccessControl.md

Extends the previous example by having the subclass's override call super.someMethod(). This is allowed because both classes are in the same source file, making the fileprivate superclass member accessible.

```swift
public class A {
    fileprivate func someMethod() {}
}

internal class B: A {
    override internal func someMethod() {
        super.someMethod()
    }
}
```

--------------------------------

### Operator precedence example: 2 + 3 % 4 * 5

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AdvancedOperators.md

Shows the original expression and its result. The comment indicates the expression equals 17, demonstrating that remainder and multiplication are evaluated before addition.

```swift
2 + 3 % 4 * 5
// this equals 17
```

--------------------------------

### Using Key Path with subscript(keyPath:)

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Demonstrates creating a key path to a property and using it with the subscript(keyPath:) subscript to access the value. The comment shows the resulting value.

```swift
struct SomeStructure {
    var someValue: Int
}

let s = SomeStructure(someValue: 12)
let pathToProperty = \SomeStructure.someValue

let value = s[keyPath: pathToProperty]
// value is 12
```

--------------------------------

### Bitwise AND operator example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AdvancedOperators.md

The bitwise AND operator (&) combines bits of two numbers, setting a bit to 1 only if both inputs have that bit set. This example produces 00111100 (decimal 60).

```swift
let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8  = 0b00111111
let middleFourBits = firstSixBits & lastSixBits  // equals 00111100
```

--------------------------------

### Overflow error example with Int16

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AdvancedOperators.md

Attempting to add 1 to Int16.max causes an error because the value exceeds the type's range. This example shows the default overflow behavior in Swift.

```swift
var potentialOverflow = Int16.max
// potentialOverflow equals 32767, which is the maximum value an Int16 can hold
potentialOverflow += 1
// this causes an error
```

--------------------------------

### Using TowardsZeroSource with Counter

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Protocols.md

Sets up a Counter with a TowardsZeroSource data source and increments five times. The output shows the count moving towards zero and then staying at zero.

```swift
counter.count = -4
counter.dataSource = TowardsZeroSource()
for _ in 1...5 {
    counter.increment()
    print(counter.count)
}
// -3
// -2
// -1
// 0
// 0
```

--------------------------------

### Bitwise OR operator example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AdvancedOperators.md

The bitwise OR operator (|) compares bits of two numbers, setting a bit to 1 if either input has that bit set. This example produces 11111110 (decimal 254).

```swift
let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits  // equals 11111110
```

--------------------------------

### Query and set type properties with dot syntax

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Properties.md

Demonstrates querying and setting type properties using dot syntax on the type itself, not on an instance. The output shows the initial and updated values for the stored property and the computed properties.

```swift
print(SomeStructure.storedTypeProperty)
// Prints "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// Prints "Another value."
print(SomeEnumeration.computedTypeProperty)
// Prints "6".
print(SomeClass.computedTypeProperty)
// Prints "27".
```

--------------------------------

### Forced-Value Expression Mutation Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Demonstrates that the unwrapped value of a forced-value expression can be modified, either by mutating the value itself or by assigning to one of its members. The example shows incrementing an optional integer and modifying a dictionary value through subscripting.

```swift
var x: Int? = 0
x! += 1
// x is now 1

var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
someDictionary["a"]![0] = 100
// someDictionary is now ["a": [100, 2, 3], "b": [10, 20]]
```

--------------------------------

### Use inherited initializers to create ShoppingListItem instances

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Initialization.md

Creates an array of ShoppingListItem instances using inherited initializers, modifies the first item's name and purchased state, then prints each item's description. Output shows the expected default states.

```swift
var breakfastList = [
    ShoppingListItem(),
    ShoppingListItem(name: "Bacon"),
    ShoppingListItem(name: "Eggs", quantity: 6),
]
breakfastList[0].name = "Orange juice"
breakfastList[0].purchased = true
for item in breakfastList {
    print(item.description)
}
// 1 x Orange juice ✔
// 1 x Bacon ✘
// 6 x Eggs ✘
```

--------------------------------

### Protocol with gettable and settable property requirements

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Protocols.md

Declares a protocol with two property requirements: one that must be gettable and settable, and one that only needs to be gettable. Property requirements are always declared with var and use { get set } or { get } after the type.

```swift
protocol SomeProtocol {
    var mustBeSettable: Int { get set }
    var doesNotNeedToBeSettable: Int { get }
}
```

--------------------------------

### Use compiler() platform condition with version checks

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Statements.md

Demonstrates the compiler() platform condition with version comparisons and logical operators. The '<<' lines show expected output; the third condition is false and produces no output.

```swift
-> #if compiler(>=4.2)
       print(1)
   #endif
<< 1
-> #if compiler(>=4.2) && true
       print(2)
   #endif
<< 2
-> #if compiler(>=4.2) && false
       print(3)
   #endif
```

--------------------------------

### Nested Types Access Control Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AccessControl.md

This example shows that nested types are inaccessible from outside their module if they are declared with a lower access level than the enclosing type. The code attempts to access various nested types and produces errors because they are private or internal to the other module.

```swift
// these are all expected to fail, because they're private or internal to the other module
import nestedTypes_Module1
let internalNestedInsidePublic = PublicStruct.InternalEnumInsidePublicStruct.a
let automaticNestedInsidePublic = PublicStruct.AutomaticEnumInsidePublicStruct.a
let privateNestedInsidePublic = PublicStruct.PrivateEnumInsidePublicStruct.a

let internalNestedInsideInternal = InternalStruct.InternalEnumInsideInternalStruct.a
let automaticNestedInsideInternal = InternalStruct.AutomaticEnumInsideInternalStruct.a
let privateNestedInsideInternal = InternalStruct.PrivateEnumInsideInternalStruct.a

let privateNestedInsidePrivate = PrivateStruct.PrivateEnumInsidePrivateStruct.a
let automaticNestedInsidePrivate = PrivateStruct.AutomaticEnumInsidePrivateStruct.a

!$ error: 'InternalEnumInsidePublicStruct' is inaccessible due to 'internal' protection level
!! let internalNestedInsidePublic = PublicStruct.InternalEnumInsidePublicStruct.a
!!                                               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!$ note: 'InternalEnumInsidePublicStruct' declared here
!! internal enum InternalEnumInsidePublicStruct {
!!               ^
!$ error: 'AutomaticEnumInsidePublicStruct' is inaccessible due to 'internal' protection level
!! let automaticNestedInsidePublic = PublicStruct.AutomaticEnumInsidePublicStruct.a
!!                                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!$ note: 'AutomaticEnumInsidePublicStruct' declared here
!! internal enum AutomaticEnumInsidePublicStruct {
!!               ^
!$ error: 'PrivateEnumInsidePublicStruct' is inaccessible due to 'private' protection level
!! let privateNestedInsidePublic = PublicStruct.PrivateEnumInsidePublicStruct.a
!!                                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!$ note: 'PrivateEnumInsidePublicStruct' declared here
!! private enum PrivateEnumInsidePublicStruct {
!!              ^
!$ error: cannot find 'InternalStruct' in scope
!! let internalNestedInsideInternal = InternalStruct.InternalEnumInsideInternalStruct.a
!!                                    ^~~~~~~~~~~~~~
!$ error: cannot find 'InternalStruct' in scope
!! let automaticNestedInsideInternal = InternalStruct.AutomaticEnumInsideInternalStruct.a
!!                                     ^~~~~~~~~~~~~~
!$ error: cannot find 'InternalStruct' in scope
!! let privateNestedInsideInternal = InternalStruct.PrivateEnumInsideInternalStruct.a
!!                                   ^~~~~~~~~~~~~~
!$ error: cannot find 'PrivateStruct' in scope
!! let privateNestedInsidePrivate = PrivateStruct.PrivateEnumInsidePrivateStruct.a
!!                                  ^~~~~~~~~~~~~
!$ error: cannot find 'PrivateStruct' in scope
!! let automaticNestedInsidePrivate = PrivateStruct.AutomaticEnumInsidePrivateStruct.a
!!                                    ^~~~~~~~~~~~~~
```

--------------------------------

### Define a protocol with protocol syntax

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Protocols.md

Shows the basic syntax for defining a protocol. The protocol name should begin with a capital letter to match other Swift type names.

```swift
protocol SomeProtocol {
    // protocol definition goes here
}
```

--------------------------------

### Dynamic member lookup by name with @dynamicMemberLookup

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Attributes.md

Example of using @dynamicMemberLookup with a String subscript to enable runtime member lookup by name. The subscript returns a default value (1054) when the member is not found. The example shows both dynamic member access and direct subscript call.

```swift
@dynamicMemberLookup
struct DynamicStruct {
    let dictionary = ["someDynamicMember": 325,
                      "someOtherMember": 787]
    subscript(dynamicMember member: String) -> Int {
        return dictionary[member] ?? 1054
    }
}
let s = DynamicStruct()

// Use dynamic member lookup.
let dynamic = s.someDynamicMember
print(dynamic)
// Prints "325".

// Call the underlying subscript directly.
let equivalent = s[dynamicMember: "someDynamicMember"]
print(dynamic == equivalent)
// Prints "true".
```

--------------------------------

### Create Customer and CreditCard instances and link them

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AutomaticReferenceCounting.md

Creates a Customer instance and assigns a new CreditCard instance to its card property, using force unwrapping for the customer reference. This links the two instances, demonstrating the unowned reference relationship.

```swift
john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
```

--------------------------------

### Key-Path Expression as Function Replacement

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Shows how to use key-path expressions in place of closures for filtering and mapping. The example demonstrates that using key paths is equivalent to using closures with $0 syntax.

```swift
struct Task {
    var description: String
    var completed: Bool
}
var toDoList = [
    Task(description: "Practice ping-pong.", completed: false),
    Task(description: "Buy a pirate costume.", completed: true),
    Task(description: "Visit Boston in the Fall.", completed: false),
]

// Both approaches below are equivalent.
let descriptions = toDoList.filter(\.completed).map(\.description)
let descriptions2 = toDoList.filter { $0.completed }.map { $0.description }
```

--------------------------------

### Create a Bicycle instance

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Initialization.md

Creates a Bicycle instance and prints its description, showing 'Bicycle: 2 wheel(s)'.

```swift
let bicycle = Bicycle()
print("Bicycle: \(bicycle.description)")
// Bicycle: 2 wheel(s)
```

--------------------------------

### Required Modifier on Subclass Overrides of Protocol Initializer (Error Example)

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Protocols.md

Shows that a subclass overriding a superclass designated initializer and conforming to a protocol must mark the initializer with both required and override. The error example shows that omitting required on a non-final class causes a compile error.

```swift
protocol P {
    init(s: String)
}
class C: P {
    required init(s: String) {}
}
class D1: C {
    required init(s: String) { super.init(s: s) }
}
class D2: C {
    init(s: String) { super.init(s: s) }
}
```

--------------------------------

### Overload ~= Operator for Custom Matching

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Patterns.md

Overloads the `~=` operator to match a string with an integer, enabling custom expression matching. The example rewrites the previous point-matching example to compare the `point` expression with string representations, printing "The point is at (1, 2)."

```swift
// Overload the ~= operator to match a string with an integer.
func ~= (pattern: String, value: Int) -> Bool {
    return pattern == "\(value)"
}
switch point {
case ("0", "0"):
    print("(0, 0) is at the origin.")
default:
    print("The point is at (\(point.0), \(point.1)).")
}
// Prints "The point is at (1, 2)."
```

--------------------------------

### Adopting Copyable and BitwiseCopyable

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Protocols.md

Shows how to adopt protocols that have only semantic requirements. The structure declaration includes no code for Copyable conformance, and the extension for BitwiseCopyable has an empty body because neither protocol has any required methods or properties.

```swift
struct MyStruct: Copyable {
    var counter = 12
}

extension MyStruct: BitwiseCopyable { }
```

--------------------------------

### Nested multiline comment

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/TheBasics.md

Swift allows multiline comments to be nested. Start an outer /* ... */ block, then start an inner /* ... */ block inside it. The inner block must be closed before the outer block. This enables commenting out large blocks of code that already contain multiline comments.

```swift
/* This is the start of the first multiline comment.
    /* This is the second, nested multiline comment. */
This is the end of the first multiline comment. */
```

--------------------------------

### Using compiler() and swift() Conditions

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Statements.md

Demonstrates using the compiler() and swift() platform conditions with version comparisons. The compiler() version is the compiler version, while swift() is the language version currently being compiled; for example, compiling with the Swift 5 compiler in Swift 4.2 mode makes the compiler version 5 and the language version 4.2.

```swift
#if compiler(>=5)
print("Compiled with the Swift 5 compiler or later")
#endif
#if swift(>=4.2)
print("Compiled in Swift 4.2 mode or later")
#endif
#if compiler(>=5) && swift(<5)
print("Compiled with the Swift 5 compiler or later in a Swift mode earlier than 5")
#endif
// Prints "Compiled with the Swift 5 compiler or later".
// Prints "Compiled in Swift 4.2 mode or later".
// Prints "Compiled with the Swift 5 compiler or later in a Swift mode earlier than 5".
```

--------------------------------

### Property Wrapper with Initial Value Using init(wrappedValue:)

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Properties.md

Demonstrates using the `init(wrappedValue:)` initializer by specifying an initial value for a property with a property wrapper. The wrapper is set up with the provided value and the default maximum of 12.

```swift
struct UnitRectangle {
    @SmallNumber var height: Int = 1
    @SmallNumber var width: Int = 1
}

var unitRectangle = UnitRectangle()
print(unitRectangle.height, unitRectangle.width)
// Prints "1 1".
```

--------------------------------

### Concatenating Multiline String Literals

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/StringsAndCharacters.md

Shows how line breaks in multiline string literals affect concatenation. The first example produces two lines because the last line of badStart lacks a line break, while the second example produces three lines because goodStart ends with a line break.

```swift
let badStart = """
    one
    two
    """
let end = """
    three
    """
print(badStart + end)
// Prints two lines:
// one
// twothree

let goodStart = """
    one
    two

    """
print(goodStart + end)
// Prints three lines:
// one
// two
// three
```

--------------------------------

### Create a Person instance and assign to reference1

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AutomaticReferenceCounting.md

Creates a new Person instance and assigns it to reference1, printing the initialization message.

```swift
reference1 = Person(name: "John Appleseed")
// Prints "John Appleseed is being initialized".
```

--------------------------------

### Iterate over one-sided closed ranges in array subscripts

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/BasicOperators.md

Iterates over a one-sided closed range used as an array subscript. The first loop starts at index 2 and continues to the end, printing Brian and Jack. The second loop goes from the start through index 2, printing Anna, Alex, and Brian.

```swift
for name in names[2...] {
    print(name)
}
// Brian
// Jack

for name in names[...2] {
    print(name)
}
// Anna
// Alex
// Brian
```

--------------------------------

### Creating Color instances with argument labels

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Initialization.md

Creates Color instances using the two initializers defined above, showing that argument labels are required when calling initializers.

```swift
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
let halfGray = Color(white: 0.5)
```

--------------------------------

### String interpolation examples

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/LexicalStructure.md

Shows five equivalent string literals that produce the same value "1 2 3". The examples demonstrate string interpolation with a string literal, an integer, an expression, and a variable. The interpolated expression can contain a string literal but cannot contain an unescaped backslash, carriage return, or line feed.

```swift
"1 2 3"
"1 2 \("3")"
"1 2 \(3)"
"1 2 \(1 + 2)"
let x = 3; "1 2 \(x)"
```

--------------------------------

### Parallel async-let calls to downloadPhoto(named:)

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Concurrency.md

Starts three downloadPhoto(named:) calls in parallel using async-let, then awaits all results together. Use this when you don't need the results until later in your code.

```swift
async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])

let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)
```

--------------------------------

### Delegating to Superclass Initializer

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Example of using an initializer expression to delegate to the initializer of a superclass in a subclass.

```swift
class SomeSubClass: SomeSuperClass {
    override init() {
        // subclass initialization goes here
        super.init()
    }
}
```

--------------------------------

### Multiline comment

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/TheBasics.md

Use /* ... */ to write a comment that spans multiple lines. The comment starts with /* and ends with */.

```swift
/* This is also a comment
but is written over multiple lines. */
```

--------------------------------

### Creating instances of RecipeIngredient

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Initialization.md

Creates three RecipeIngredient instances using the inherited convenience initializer and the designated initializer.

```swift
let oneMysteryItem = RecipeIngredient()
let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
```

--------------------------------

### Define a structure and a class with struct and class keywords

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/ClassesAndStructures.md

Shows the basic definition syntax for a structure and a class in Swift. Both use the respective keyword followed by a name and a pair of braces containing the definition.

```swift
struct SomeStructure {
    // structure definition goes here
}
class SomeClass {
    // class definition goes here
}
```

--------------------------------

### Create a substring and convert it to String

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/StringsAndCharacters.md

Shows how to get a substring using firstIndex(of:) and a subscript, then convert it to a String for long-term storage. The substring reuses the original string's memory, so it's not suitable for long-term storage.

```swift
let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..<index]
// beginning is "Hello"

// Convert the result to a String for long-term storage.
let newString = String(beginning)
```

--------------------------------

### Tuple Member Access

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Shows how tuple members are implicitly named using integers starting from zero, and how to access them.

```swift
var t = (10, 20, 30)
t.0 = t.1
// Now t is (20, 20, 30)
```

--------------------------------

### Single-line comment

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/TheBasics.md

Use // to start a single-line comment. Everything after // on that line is ignored by the Swift compiler.

```swift
// This is a comment.
```

--------------------------------

### Call an async function with try await

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Concurrency.md

Demonstrates the syntax for calling an asynchronous throwing function, using both try and await because the function can throw an error.

```swift
let photos = try await listPhotos(inGallery: "A Rainy Weekend")
```

--------------------------------

### Call the greet(person:) function and print results

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Functions.md

Calls the greet(person:) function with different arguments and prints the returned greetings. The output shows "Hello, Anna!" and "Hello, Brian!".

```swift
print(greet(person: "Anna"))
// Prints "Hello, Anna!"
print(greet(person: "Brian"))
// Prints "Hello, Brian!"
```

--------------------------------

### Define a String with Unicode Characters

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/StringsAndCharacters.md

Defines the string 'Dog‼🐶' used in the following examples to demonstrate Unicode representations.

```swift
let dogString = "Dog‼🐶"
```

--------------------------------

### Default parameter value example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Declarations.md

Demonstrates a function with a default parameter value. Calling without the argument uses the default, calling with the label uses the provided value, and calling without the label is invalid.

```swift
func f(x: Int = 42) -> Int { return x }
f()       // Valid, uses default value
f(x: 7)   // Valid, uses the value provided
f(7)      // Invalid, missing argument label
```

--------------------------------

### Printing Tuple Constants

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Declarations.md

Prints the values of the constants declared in the previous tuple example, showing the expected output in comments.

```swift
print("The first number is \(firstNumber).")
// Prints "The first number is 10."
print("The second number is \(secondNumber).")
// Prints "The second number is 42."
```

--------------------------------

### Key-Path String Expression Syntax

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Shows the basic syntax of a key-path string expression using #keyPath with a property name placeholder.

```swift
#keyPath(<#property name#>)
```

--------------------------------

### Attempt to use a non-boolean in an if statement

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/TheBasics.md

Shows a compile-time error because an Int cannot be used as a boolean. The comment indicates the example will not compile.

```swift
let i = 1
if i {
    // this example will not compile, and will report an error
}
```

--------------------------------

### Assignment Operator Example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/BasicOperators.md

Shows the assignment operator (=) initializing or updating a variable's value. After the assignment, a is equal to 10.

```swift
let b = 10
var a = 5
a = b
// a is now equal to 10
```

--------------------------------

### Accessing a Property via Explicit Member Expression

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Example of accessing a property of a class instance using an explicit member expression.

```swift
class SomeClass {
    var someProperty = 42
}
let c = SomeClass()
let y = c.someProperty  // Member access
```

--------------------------------

### Protocol Conformance with Different Access Levels

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AccessControl.md

These examples show how types with different access levels can conform to a public protocol. The first block demonstrates that public, internal, and private classes can all conform to a public protocol. The second block shows that attempting to conform to internal, file-private, or private protocols from another module results in errors because those protocols are not visible outside their defining module.

```swift
// these should all be allowed without problem
import protocols_Module1
public class PublicClassConformingToPublicProtocol: PublicProtocol {
      public var publicProperty = 0
      public func publicMethod() {}
   }
internal class InternalClassConformingToPublicProtocol: PublicProtocol {
      var publicProperty = 0
      func publicMethod() {}
   }
private class PrivateClassConformingToPublicProtocol: PublicProtocol {
      var publicProperty = 0
      func publicMethod() {}
   }
```

```swift
// these will all fail, because InternalProtocol, FilePrivateProtocol, and PrivateProtocol
// aren't visible to other modules
import protocols_Module1
public class PublicClassConformingToInternalProtocol: InternalProtocol {
      var internalProperty = 0
      func internalMethod() {}
   }
public class PublicClassConformingToFilePrivateProtocol: FilePrivateProtocol {
      var filePrivateProperty = 0
      func filePrivateMethod() {}
   }
public class PublicClassConformingToPrivateProtocol: PrivateProtocol {
      var privateProperty = 0
      func privateMethod() {}
   }
// error: cannot find type 'InternalProtocol' in scope
// public class PublicClassConformingToInternalProtocol: InternalProtocol {
// ^~~~~~~~~~~~~~~~
// error: cannot find type 'FilePrivateProtocol' in scope
// public class PublicClassConformingToFilePrivateProtocol: FilePrivateProtocol {
// ^~~~~~~~~~~~~~~~~~~
// error: cannot find type 'PrivateProtocol' in scope
// public class PublicClassConformingToPrivateProtocol: PrivateProtocol {
// ^~~~~~~~~~~~~~~
```

--------------------------------

### Define DrawingBuilder usage and makeGreeting function

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/AdvancedOperators.md

Shows how to apply @DrawingBuilder to function parameters and use the builder syntax to create a drawing with conditional content. The example defines draw(_:), caps(_:), and makeGreeting(for:), then prints the resulting drawings for both a generic and a personalized greeting.

```swift
func draw(@DrawingBuilder content: () -> Drawable) -> Drawable {
    return content()
}
func caps(@DrawingBuilder content: () -> Drawable) -> Drawable {
    return AllCaps(content: content())
}

func makeGreeting(for name: String? = nil) -> Drawable {
    let greeting = draw {
        Stars(length: 3)
        Text("Hello")
        Space()
        caps {
            if let name = name {
                Text(name + "!")
            } else {
                Text("World!")
            }
        }
        Stars(length: 2)
    }
    return greeting
}
let genericGreeting = makeGreeting()
print(genericGreeting.draw())
// Prints "***Hello WORLD!**".

let personalGreeting = makeGreeting(for: "Ravi Patel")
print(personalGreeting.draw())
// Prints "***Hello RAVI PATEL!**".
```

--------------------------------

### try placement error example

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/ReferenceManual/Expressions.md

Test code showing that try cannot appear on the right-hand side of an infix operator without parentheses.

```swift
func someThrowingFunction() throws -> Int { return 10 }
var sum = 0
sum = 7 + try someThrowingFunction() // Error
sum = 7 + (try someThrowingFunction()) // OK
```

--------------------------------

### Create a Tandem instance and use inherited properties

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Inheritance.md

Creates a Tandem instance, sets inherited and new properties, and prints the inherited description property, showing the output.

```swift
let tandem = Tandem()
tandem.hasBasket = true
tandem.currentNumberOfPassengers = 2
tandem.currentSpeed = 22.0
print("Tandem: \(tandem.description)")
// Tandem: traveling at 22.0 miles per hour
```

--------------------------------

### Use computed properties in a calculation

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Extensions.md

Uses the computed properties from the previous example in a mathematical calculation. The result is a Double value in meters.

```swift
let aMarathon = 42.km + 195.m
print("A marathon is \(aMarathon) meters long")
// Prints "A marathon is 42195.0 meters long".
```

--------------------------------

### Using the default Rect initializer

Source: https://github.com/swiftlang/swift-book/blob/main/TSPL.docc/LanguageGuide/Initialization.md

Creates a Rect instance using the default initializer and shows that origin and size are both (0.0, 0.0).

```swift
let basicRect = Rect()
// basicRect's origin is (0.0, 0.0) and its size is (0.0, 0.0)
```
Tokens:
Raw