Swift Structs

struct Product {
    let name: String
    var price: Double
    var stock: Int = 0
}

var mug = Product(name: "Mug", price: 8.5, stock: 12)
let pen = Product(name: "Pen", price: 1.2)       // stock uses its default
mug.price = 9.0
print(mug.name, mug.price)

• Type names use UpperCamelCase; properties use lowerCamelCase.
• Swift writes a memberwise initializer for you, with a labelled argument for each property. Properties with default values can be left out.
• let properties can't change after creation; var properties can, but only if the instance itself is a var.

A computed property calculates its value each time it's read:

struct Rectangle {
    var width: Double
    var height: Double
    var area: Double { width * height }
    func describe() -> String { "\(width)x\(height), area \(area)" }
}

Methods are functions inside the type and can read its properties directly. A method that changes properties must be marked mutating, because changing a struct changes the whole value:

mutating func scale(by factor: Double) {
    width *= factor
    height *= factor
}

Write your own init to validate or calculate values. A failable initializer, init?, returns nil when the input isn't valid:

struct Temperature {
    let celsius: Double
    init?(celsius: Double) {
        guard celsius >= -273.15 else { return nil }
        self.celsius = celsius
    }
}

Property observers run code when a stored property changes: didSet runs after the change, with the previous value available as oldValue; willSet runs just before. They're handy for keeping values in range or reacting to updates. static properties and methods belong to the type itself, such as Temperature.absoluteZero.

var a = Rectangle(width: 2, height: 3)
var b = a
b.width = 10
print(a.width)     // 2.0: a is unchanged

Each variable holds its own copy. A function that receives a struct can't change the caller's copy unless it's passed inout. This makes code predictable: data only changes where you can see it change. Apple recommends structs by default, using classes only when you need shared identity or inheritance, as the classes lesson explains.

The free memberwise initializer only exists while you haven't written an init inside the struct's braces. Once you add one, Swift assumes you want full control and removes it:

struct User {
    let name: String
    let joinedYear: Int
    init(name: String) {
        self.name = name
        self.joinedYear = 2024
    }
}
User(name: "Ada")                    // fine
User(name: "Ada", joinedYear: 2020)  // error: extra argument 'joinedYear' in call

If you want both, put your custom init in an extension instead, and the memberwise initializer stays available. The extensions lesson shows this pattern.

Because assigning a struct makes a copy, you can create a variation of a value without touching the original. This is a common way to build a "changed version" of some data:

let mug = Product(name: "Mug", price: 10.0)
var saleMug = mug
saleMug.price *= 0.8
print(mug.price, saleMug.price)      // 10.0 8.0

The original mug can even stay a let. Only the copy needs to be a var, since that's the one you change. SwiftUI uses exactly this idea: each change produces a new value, and the screen updates to match it.

You can also give a property private(set), as in private(set) var balance = 0. Code outside the struct can read it, but only the struct's own mutating methods can change it.