1# Common code smells and remediation patterns
2 
3## Intent
4 
5Use this reference during code-first review to map visible SwiftUI patterns to likely runtime costs and safer remediation guidance.
6 
7## High-priority smells
8 
9### Expensive formatters in `body`
10 
11```swift
12var body: some View {
13    let number = NumberFormatter()
14    let measure = MeasurementFormatter()
15    Text(measure.string(from: .init(value: meters, unit: .meters)))
16}
17```
18 
19Prefer cached formatters in a model or dedicated helper:
20 
21```swift
22final class DistanceFormatter {
23    static let shared = DistanceFormatter()
24    let number = NumberFormatter()
25    let measure = MeasurementFormatter()
26}
27```
28 
29### Heavy computed properties
30 
31```swift
32var filtered: [Item] {
33    items.filter { $0.isEnabled }
34}
35```
36 
37Prefer deriving this once per meaningful input change in a model/helper, or store derived view-owned state only when the view truly owns the transformation lifecycle.
38 
39### Sorting or filtering inside `body`
40 
41```swift
42List {
43    ForEach(items.sorted(by: sortRule)) { item in
44        Row(item)
45    }
46}
47```
48 
49Prefer sorting before render work begins:
50 
51```swift
52let sortedItems = items.sorted(by: sortRule)
53```
54 
55### Inline filtering inside `ForEach`
56 
57```swift
58ForEach(items.filter { $0.isEnabled }) { item in
59    Row(item)
60}
61```
62 
63Prefer a prefiltered collection with stable identity.
64 
65### Unstable identity
66 
67```swift
68ForEach(items, id: \.self) { item in
69    Row(item)
70}
71```
72 
73Avoid `id: \.self` for non-stable values or collections that reorder. Use a stable domain identifier.
74 
75### Top-level conditional view swapping
76 
77```swift
78var content: some View {
79    if isEditing {
80        editingView
81    } else {
82        readOnlyView
83    }
84}
85```
86 
87Prefer one stable base view and localize conditions to sections or modifiers. This reduces root identity churn and makes diffing cheaper.
88 
89### Image decoding on the main thread
90 
91```swift
92Image(uiImage: UIImage(data: data)!)
93```
94 
95Prefer decode and downsample work off the main thread, then store the processed image.
96 
97## Observation fan-out
98 
99### Broad `@Observable` reads on iOS 17+
100 
101```swift
102@Observable final class Model {
103    var items: [Item] = []
104}
105 
106var body: some View {
107    Row(isFavorite: model.items.contains(item))
108}
109```
110 
111If many views read the same broad collection or root model, small changes can fan out into wide invalidation. Prefer narrower derived inputs, smaller observable surfaces, or per-item state closer to the leaf views.
112 
113### Broad `ObservableObject` reads on iOS 16 and earlier
114 
115```swift
116final class Model: ObservableObject {
117    @Published var items: [Item] = []
118}
119```
120 
121The same warning applies to legacy observation. Avoid having many descendants observe a large shared object when they only need one derived field.
122 
123## Remediation notes
124 
125### `@State` is not a generic cache
126 
127Use `@State` for view-owned state and derived values that intentionally belong to the view lifecycle. Do not move arbitrary expensive computation into `@State` unless you also define when and why it updates.
128 
129Better alternatives:
130- precompute in the model or store
131- update derived state in response to a specific input change
132- memoize in a dedicated helper
133- preprocess on a background task before rendering
134 
135### `equatable()` is conditional guidance
136 
137Use `equatable()` only when:
138- equality is cheaper than recomputing the subtree, and
139- the view inputs are value-semantic and stable enough for meaningful equality checks
140 
141Do not apply `equatable()` as a blanket fix for all redraws.
142 
143## Triage order
144 
145When multiple smells appear together, prioritize in this order:
1461. Broad invalidation and observation fan-out
1472. Unstable identity and list churn
1483. Main-thread work during render
1494. Image decode or resize cost
1505. Layout and animation complexity
151