In the last section, an expense’s category was a String. That works until someone writes "Fod", or "food" in one place and "Food" in another, and the monthly total silently misses half your groceries. Nothing in the type said which strings were valid. An enum says exactly that: here is the complete list of possible values, and nothing else is allowed.
enum Category: String, CaseIterable {\n case food\n case transport\n case housing\n case fun\n\n var title: String {\n rawValue.capitalized\n }\n\n var symbolName: String {\n switch self {\n case .food: \"fork.knife\"\n case .transport: \"bus\"\n case .housing: \"house\"\n case .fun: \"ticket\"\n }\n }\n}Category now has exactly four values. Write .fod and the build fails. The : String gives each case a raw value, its name as a string by default (Category.food.rawValue is "food"), which is what you’ll save to disk and read from JSON later. Going the other way is failable, because not every string is a category: Category(rawValue: "fun") is .fun, and Category(rawValue: "Fun") is nil.
CaseIterable asks the compiler to generate Category.allCases, an array of every case in declaration order. Pocket Budget’s category picker will loop over it, so adding a case adds a row to the picker for free.
Enums can have computed properties and methods, just like structs. symbolName maps each case to an SF Symbols icon name, and the switch inside it has no default.
Suppose you add case gifts next month. The build immediately fails at symbolName with “switch must be exhaustive”, and at every other switch over Category in the project. The compiler has produced your to-do list. Compare that with the string version, where a new category quietly falls into whatever default branch existed and shows the wrong icon in production.
Raw values are fixed per case. Some data varies per instance. Pocket Budget records how an expense was paid, and each method needs different details:
\nenum PaymentMethod {\n case cash\n case card(lastFour: String)\n case transfer(bank: String, reference: String?)\n}\n\nlet lunch: PaymentMethod = .cash\nlet groceries: PaymentMethod = .card(lastFour: \"4242\")\nlet rent: PaymentMethod = .transfer(bank: \"Monzo\", reference: \"RENT-10\")Each case has its own shape. A cash payment carries nothing, a card payment carries four digits, and a transfer carries a bank and an optional reference. A struct would need three optional properties and a comment explaining which ones are filled in when. The enum makes invalid combinations, such as a cash payment with a bank name, impossible to construct.
\nYou read associated values with pattern matching in a switch:
func label(for method: PaymentMethod) -> String {\n switch method {\n case .cash:\n return \"Cash\"\n case .card(let lastFour):\n return \"Card ending \\(lastFour)\"\n case .transfer(let bank, let reference?):\n return \"\\(bank) transfer, ref \\(reference)\"\n case .transfer(let bank, nil):\n return \"\\(bank) transfer\"\n }\n}\n\nlabel(for: groceries) // \"Card ending 4242\"let lastFour binds the associated value to a new constant for that case. The two .transfer cases show how far patterns go: let reference? matches only when the optional reference has a value and unwraps it, and nil matches when it doesn’t. The compiler still checks that, between them, every possibility is covered.
When you care about a single case, if case is shorter than a full switch:
if case .card(let lastFour) = groceries {\n print(\"Remind me to check card \\(lastFour)\")\n}Enums are the right tool whenever a value is “exactly one of these”. A classic example is loading data. The first draft usually looks like three separate properties: isLoading, rates, and errorMessage. Nothing stops all three from being set at once, so every screen has to guess which one wins. One enum removes the guessing:
enum LoadState {\n case idle\n case loading\n case loaded([String: Decimal])\n case failed(String)\n}Now the rates exist only in the .loaded case and the message only in .failed, and a switch in the view handles each state once. You’ll build exactly this when Pocket Budget starts fetching exchange rates. Reach for an enum whenever you catch yourself comparing strings or juggling booleans that should never be true together.
Your types can now describe Pocket Budget’s data precisely. Next you’ll give them shared abilities with protocols, such as “can be compared” or “has a stable id”, and add behaviour to existing types with extensions.
\n","toc":[{"id":"sec-1","text":"Enums with raw values","level":2},{"id":"sec-2","text":"Exhaustive switches are a feature","level":2},{"id":"sec-3","text":"Associated values: cases that carry data","level":2},{"id":"sec-4","text":"Getting the data back out","level":2},{"id":"sec-5","text":"Enums instead of boolean soup","level":2}],"takeaways":["An enum lists every valid value of a type, so a typo like “Fod” becomes a compile error instead of a silent bug.","[object Object]","Associated values attach different data to different cases, such as the last four digits for.card.","Switch over enums without default, so adding a case makes the compiler list every switch you must update."],"further":[{"title":"Enumerations","url":"https://docs.swift.org/swift-book/documentation/the-swift-programming-language/enumerations/"},{"title":"CaseIterable","url":"https://developer.apple.com/documentation/swift/caseiterable"}],"quiz":[{"q":"enum Category: String { case food, transport }. What does Category(rawValue: "Food") return?
.food, because raw-value matching ignores case.","why":"Raw-value matching is exact. The raw value of food is “food”, lowercase."},{"text":"A crash, because “Food” isn’t a valid raw value.","why":"The failable initializer exists precisely to avoid crashing on bad input."},{"text":"nil","why":"Correct. init(rawValue:) is failable and returns Category?; “Food” doesn’t match “food”."}],"answer":2},{"q":"You add case gifts to Category. Every switch over Category uses explicit cases and no default. What happens on the next build?
.gifts.","why":"Correct. Exhaustiveness checking turns “find every place that needs updating” into a list of errors."},{"text":"The build succeeds, and .gifts falls into the last case at runtime.","why":"Swift never routes an unhandled case anywhere silently."},{"text":"The build succeeds, and the app crashes when it meets .gifts.","why":"Without a default, the gap is caught at compile time, not at runtime."}],"answer":0},{"q":"Which declaration models “paid by card, and we know the last four digits”?
","options":[{"text":"case card = "4242"","why":"A raw value is fixed for the case; every card payment would end in 4242."},{"text":"case card(lastFour: String)","why":"Correct. An associated value is stored per instance, so each payment carries its own digits."},{"text":"case card; var lastFour: String","why":"Enums can’t have stored instance properties; associated values are how cases carry data."},{"text":"case card(String) = "card"","why":"Swift doesn’t allow raw values on an enum whose cases have associated values."}],"answer":1}],"exercise":{"kind":"fill","language":"swift","template":"enum Category: String, {{0}} {\n case food, transport, fun\n}\nprint(Category.{{1}}.count) // 3\n\nenum PaymentMethod {\n case cash\n case card(lastFour: String)\n}\n\nfunc label(for method: PaymentMethod) -> String {\n switch method {\n case .cash:\n return \"Cash\"\n case .card({{2}} lastFour):\n return \"Card ending \\(lastFour)\"\n }\n}","blanks":[{"answers":["CaseIterable"]},{"answers":["allCases"]},{"answers":["let"]}],"title":"Model categories and payment methods","prompt":"Complete Pocket Budget’s two enums. Category must provide a list of all its cases so the picker can show them, and label(for:) must read the last four digits out of a card payment.
Category.____.","Inside a case pattern, the keyword that binds an associated value to a new constant is the same one you use to declare constants."],"explanation":"CaseIterable makes the compiler generate Category.allCases, an array of every case in declaration order, so count is 3. In the switch, case .card(let lastFour) matches card payments and binds the associated value to the constant lastFour for that branch.
Notice the switch has no default. If you add case transfer(bank: String) later, this function stops compiling until you handle it, which is exactly what you want.