swift-code-reviewer-skill 1.1.1 → 1.2.1

package/skills/swift-expert/references/memory-performance.md

@@ -0,0 +1,380 @@
+# Memory & Performance
+
+> Reference for: Swift Expert
+> Load when: Memory management, ARC, performance optimization, profiling
+
+## Automatic Reference Counting (ARC)
+
+```swift
+// Strong references (default)
+class Person {
+    let name: String
+    var apartment: Apartment?
+
+    init(name: String) {
+        self.name = name
+    }
+
+    deinit {
+        print("\(name) is being deinitialized")
+    }
+}
+
+class Apartment {
+    let unit: String
+    weak var tenant: Person?  // Weak to break retain cycle
+
+    init(unit: String) {
+        self.unit = unit
+    }
+
+    deinit {
+        print("Apartment \(unit) is being deinitialized")
+    }
+}
+
+var john: Person? = Person(name: "John")
+var unit4A: Apartment? = Apartment(unit: "4A")
+
+john?.apartment = unit4A
+unit4A?.tenant = john
+
+// Setting to nil will properly deallocate both
+john = nil
+unit4A = nil
+```
+
+## Weak and Unowned References
+
+```swift
+// Weak - optional reference that doesn't keep object alive
+class ViewController: UIViewController {
+    weak var delegate: ViewControllerDelegate?
+
+    func performAction() {
+        delegate?.didPerformAction()
+    }
+}
+
+// Unowned - non-optional reference, assumes target outlives owner
+class Customer {
+    let name: String
+    var card: CreditCard?
+
+    init(name: String) {
+        self.name = name
+    }
+}
+
+class CreditCard {
+    let number: String
+    unowned let customer: Customer  // Customer always outlives card
+
+    init(number: String, customer: Customer) {
+        self.number = number
+        self.customer = customer
+    }
+}
+
+// Unowned optional (Swift 5+)
+class Department {
+    var courses: [Course] = []
+}
+
+class Course {
+    unowned var department: Department
+    unowned var nextCourse: Course?
+
+    init(department: Department) {
+        self.department = department
+    }
+}
+```
+
+## Capture Lists in Closures
+
+```swift
+class DataManager {
+    var data: [String] = []
+
+    func loadData() {
+        // Strong reference cycle - DataManager won't be deallocated
+        NetworkManager.fetch { response in
+            self.data = response  // self is captured strongly
+        }
+
+        // Weak self - breaks cycle
+        NetworkManager.fetch { [weak self] response in
+            guard let self = self else { return }
+            self.data = response
+        }
+
+        // Unowned self - when self definitely outlives closure
+        NetworkManager.fetch { [unowned self] response in
+            self.data = response  // Crashes if self is deallocated
+        }
+
+        // Capturing specific values
+        let identifier = UUID()
+        NetworkManager.fetch { [identifier] response in
+            print("Request \(identifier) completed")
+        }
+    }
+}
+```
+
+## Value Semantics
+
+```swift
+// Structs provide automatic copy-on-write for collections
+struct User {
+    var name: String
+    var friends: [String]  // Copy-on-write
+}
+
+var user1 = User(name: "Alice", friends: ["Bob"])
+var user2 = user1  // Shallow copy
+user2.friends.append("Charlie")  // Now triggers deep copy
+
+print(user1.friends)  // ["Bob"]
+print(user2.friends)  // ["Bob", "Charlie"]
+
+// Custom copy-on-write
+final class Storage<T> {
+    var value: T
+    init(_ value: T) { self.value = value }
+}
+
+struct MyArray<Element> {
+    private var storage: Storage<[Element]>
+
+    init(_ elements: [Element] = []) {
+        storage = Storage(elements)
+    }
+
+    var value: [Element] {
+        get { storage.value }
+        set {
+            if !isKnownUniquelyReferenced(&storage) {
+                storage = Storage(newValue)
+            } else {
+                storage.value = newValue
+            }
+        }
+    }
+
+    mutating func append(_ element: Element) {
+        if !isKnownUniquelyReferenced(&storage) {
+            storage = Storage(storage.value)
+        }
+        storage.value.append(element)
+    }
+}
+```
+
+## Performance Optimization
+
+```swift
+// Use lazy properties for expensive computations
+class Report {
+    let data: [DataPoint]
+
+    lazy var summary: String = {
+        // Expensive computation only when accessed
+        data.map { $0.description }.joined(separator: "\n")
+    }()
+
+    init(data: [DataPoint]) {
+        self.data = data
+    }
+}
+
+// Avoid repeated type casting
+// Bad
+for item in items {
+    if let user = item as? User {
+        processUser(user)
+    }
+}
+
+// Good
+let users = items.compactMap { $0 as? User }
+for user in users {
+    processUser(user)
+}
+
+// Use contiguous storage
+// Slower - pointer indirection for each element
+let arrayOfClasses: [MyClass] = [MyClass(), MyClass()]
+
+// Faster - contiguous memory
+let arrayOfStructs: [MyStruct] = [MyStruct(), MyStruct()]
+
+// Avoid string concatenation in loops
+// Bad
+var result = ""
+for item in items {
+    result += item.description  // Allocates new string each time
+}
+
+// Good
+let result = items.map { $0.description }.joined()
+
+// Or
+var result = ""
+result.reserveCapacity(estimatedSize)
+for item in items {
+    result.append(item.description)
+}
+```
+
+## Collection Performance
+
+```swift
+// Choose the right collection type
+// Array - ordered, random access O(1), append O(1) amortized
+let ordered: [Int] = [1, 2, 3]
+
+// Set - unique elements, contains O(1), no order
+let unique: Set<Int> = [1, 2, 3]
+
+// Dictionary - key-value pairs, lookup O(1)
+let mapping: [String: Int] = ["a": 1, "b": 2]
+
+// Use ContiguousArray for performance-critical code
+let contiguous = ContiguousArray<MyStruct>(repeating: MyStruct(), count: 1000)
+
+// Reserve capacity for known sizes
+var numbers: [Int] = []
+numbers.reserveCapacity(1000)
+for i in 0..<1000 {
+    numbers.append(i)
+}
+
+// Use enumerated() instead of indices
+// Bad
+for i in 0..<array.count {
+    process(index: i, value: array[i])
+}
+
+// Good
+for (index, value) in array.enumerated() {
+    process(index: index, value: value)
+}
+```
+
+## Memory Profiling with Instruments
+
+```swift
+// Add markers for profiling
+import os.signpost
+
+let log = OSLog(subsystem: "com.example.app", category: "Performance")
+
+func processData() {
+    os_signpost(.begin, log: log, name: "Data Processing")
+    defer { os_signpost(.end, log: log, name: "Data Processing") }
+
+    // Processing code
+}
+
+// Autoreleasepool for memory-intensive loops
+func processLargeDataset() {
+    for batch in dataBatches {
+        autoreleasepool {
+            // Process batch
+            // Memory released at end of each iteration
+        }
+    }
+}
+
+// Check for memory leaks
+#if DEBUG
+extension NSObject {
+    static func trackAllocations() {
+        let count = performSelector(
+            Selector(("instancesRespond:"))
+        )
+        print("\(self): \(count) instances")
+    }
+}
+#endif
+```
+
+## Optimization Levels
+
+```swift
+// Whole Module Optimization in Package.swift
+let package = Package(
+    name: "MyApp",
+    products: [
+        .executable(name: "MyApp", targets: ["MyApp"])
+    ],
+    targets: [
+        .target(
+            name: "MyApp",
+            swiftSettings: [
+                .unsafeFlags(["-O"], .when(configuration: .release))
+            ]
+        )
+    ]
+)
+
+// Inline optimization
+@inline(__always)
+func criticalPath() {
+    // Always inlined
+}
+
+@inline(never)
+func debugHelper() {
+    // Never inlined, good for debugging
+}
+
+// Optimization attributes
+@_specialize(where T == Int)
+@_specialize(where T == String)
+func process<T>(_ value: T) {
+    // Specialized versions generated
+}
+```
+
+## Memory Warnings
+
+```swift
+class ImageCache {
+    private var cache: [String: UIImage] = [:]
+
+    init() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(clearCache),
+            name: UIApplication.didReceiveMemoryWarningNotification,
+            object: nil
+        )
+    }
+
+    @objc private func clearCache() {
+        cache.removeAll()
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+}
+```
+
+## Best Practices
+
+- Use value types (structs) by default
+- Use weak references for delegates
+- Use unowned when lifetime is guaranteed
+- Always use capture lists in closures that reference self
+- Profile before optimizing (use Instruments)
+- Reserve collection capacity when size is known
+- Use lazy properties for expensive computations
+- Implement copy-on-write for custom types with reference storage
+- Handle memory warnings in iOS apps
+- Use autoreleasepool for memory-intensive loops
+- Choose appropriate collection types
+- Avoid premature optimization - measure first

package/skills/swift-expert/references/protocol-oriented.md

@@ -0,0 +1,357 @@
+# Protocol-Oriented Programming
+
+> Reference for: Swift Expert
+> Load when: Protocol design, generics, associated types, type erasure
+
+## Protocol Basics
+
+```swift
+// Protocol with requirements
+protocol Drawable {
+    var boundingBox: CGRect { get }
+    func draw(in context: CGContext)
+}
+
+// Protocol with default implementation
+extension Drawable {
+    func draw(in context: CGContext) {
+        // Default drawing behavior
+        context.stroke(boundingBox)
+    }
+}
+
+// Struct conforming to protocol
+struct Circle: Drawable {
+    let center: CGPoint
+    let radius: CGFloat
+
+    var boundingBox: CGRect {
+        CGRect(
+            x: center.x - radius,
+            y: center.y - radius,
+            width: radius * 2,
+            height: radius * 2
+        )
+    }
+}
+```
+
+## Associated Types
+
+```swift
+// Protocol with associated type
+protocol Container {
+    associatedtype Item
+    var count: Int { get }
+    mutating func append(_ item: Item)
+    subscript(index: Int) -> Item { get }
+}
+
+// Generic struct conforming
+struct Stack<Element>: Container {
+    typealias Item = Element  // Can be inferred
+    private var items: [Element] = []
+
+    var count: Int { items.count }
+
+    mutating func append(_ item: Element) {
+        items.append(item)
+    }
+
+    subscript(index: Int) -> Element {
+        items[index]
+    }
+}
+
+// Using where clause with associated types
+extension Container where Item: Equatable {
+    func firstIndex(of item: Item) -> Int? {
+        for (index, current) in enumerated() where current == item {
+            return index
+        }
+        return nil
+    }
+}
+```
+
+## Protocol Composition
+
+```swift
+// Multiple protocol conformance
+protocol Named {
+    var name: String { get }
+}
+
+protocol Aged {
+    var age: Int { get }
+}
+
+// Composing protocols
+typealias Person = Named & Aged
+
+func greet(_ person: some Named & Aged) {
+    print("Hello \(person.name), age \(person.age)")
+}
+
+// Protocol composition in constraints
+func process<T: Codable & Hashable>(_ items: [T]) {
+    // T must conform to both Codable and Hashable
+}
+```
+
+## Generics with Protocols
+
+```swift
+// Generic function with protocol constraint
+func compare<T: Comparable>(_ a: T, _ b: T) -> T {
+    return a > b ? a : b
+}
+
+// Generic type with protocol constraint
+class Repository<Model: Codable & Identifiable> {
+    private var items: [Model.ID: Model] = [:]
+
+    func save(_ model: Model) {
+        items[model.id] = model
+    }
+
+    func find(id: Model.ID) -> Model? {
+        items[id]
+    }
+
+    func all() -> [Model] {
+        Array(items.values)
+    }
+}
+
+// Using opaque return types
+func makeCollection() -> some Collection {
+    return [1, 2, 3, 4, 5]
+}
+
+// Primary associated types (Swift 5.7+)
+protocol DataSource<Element> {
+    associatedtype Element
+    func fetch() async throws -> [Element]
+}
+
+func loadData<T>(from source: some DataSource<T>) async throws -> [T] {
+    try await source.fetch()
+}
+```
+
+## Type Erasure
+
+```swift
+// Problem: Can't use protocol with associated types as type
+// protocol Storage {
+//     associatedtype Item
+//     func store(_ item: Item)
+// }
+// var storage: Storage  // Error: protocol can only be used as constraint
+
+// Solution: Type-erased wrapper
+protocol Storage {
+    associatedtype Item
+    func store(_ item: Item)
+    func retrieve() -> Item?
+}
+
+struct AnyStorage<T>: Storage {
+    typealias Item = T
+
+    private let _store: (T) -> Void
+    private let _retrieve: () -> T?
+
+    init<S: Storage>(_ storage: S) where S.Item == T {
+        _store = storage.store
+        _retrieve = storage.retrieve
+    }
+
+    func store(_ item: T) {
+        _store(item)
+    }
+
+    func retrieve() -> T? {
+        _retrieve()
+    }
+}
+
+// Now we can use it as a type
+class MemoryStorage<T>: Storage {
+    private var item: T?
+
+    func store(_ item: T) {
+        self.item = item
+    }
+
+    func retrieve() -> T? {
+        item
+    }
+}
+
+let storage: AnyStorage<String> = AnyStorage(MemoryStorage<String>())
+```
+
+## Protocol Inheritance
+
+```swift
+// Protocol inheriting from another
+protocol Identifiable {
+    var id: UUID { get }
+}
+
+protocol Timestampable {
+    var createdAt: Date { get }
+    var updatedAt: Date { get }
+}
+
+protocol Entity: Identifiable, Timestampable {
+    var version: Int { get }
+}
+
+struct User: Entity {
+    let id: UUID
+    let createdAt: Date
+    var updatedAt: Date
+    var version: Int
+    var name: String
+}
+```
+
+## Conditional Conformance
+
+```swift
+// Make Array conform to protocol when elements conform
+protocol Summarizable {
+    var summary: String { get }
+}
+
+extension Array: Summarizable where Element: Summarizable {
+    var summary: String {
+        map { $0.summary }.joined(separator: ", ")
+    }
+}
+
+struct Task: Summarizable {
+    let title: String
+    var summary: String { title }
+}
+
+let tasks = [Task(title: "Buy milk"), Task(title: "Walk dog")]
+print(tasks.summary)  // "Buy milk, Walk dog"
+```
+
+## Protocol Extensions
+
+```swift
+// Adding functionality to all conforming types
+protocol Collection {
+    associatedtype Element
+    var count: Int { get }
+    subscript(index: Int) -> Element { get }
+}
+
+extension Collection {
+    var isEmpty: Bool {
+        count == 0
+    }
+
+    func map<T>(_ transform: (Element) -> T) -> [T] {
+        var result: [T] = []
+        for i in 0..<count {
+            result.append(transform(self[i]))
+        }
+        return result
+    }
+}
+
+// Constrained extensions
+extension Collection where Element: Numeric {
+    func sum() -> Element {
+        var total: Element = 0
+        for i in 0..<count {
+            total += self[i]
+        }
+        return total
+    }
+}
+```
+
+## Advanced Patterns
+
+```swift
+// Phantom types for type safety
+enum Celsius {}
+enum Fahrenheit {}
+
+struct Temperature<Unit> {
+    let value: Double
+
+    init(_ value: Double) {
+        self.value = value
+    }
+}
+
+extension Temperature where Unit == Celsius {
+    func toFahrenheit() -> Temperature<Fahrenheit> {
+        Temperature<Fahrenheit>(value * 9/5 + 32)
+    }
+}
+
+extension Temperature where Unit == Fahrenheit {
+    func toCelsius() -> Temperature<Celsius> {
+        Temperature<Celsius>((value - 32) * 5/9)
+    }
+}
+
+let celsius = Temperature<Celsius>(100)
+let fahrenheit = celsius.toFahrenheit()
+
+// Witness tables pattern
+protocol Encoder {
+    func encode<T: Encodable>(_ value: T) throws -> Data
+}
+
+protocol Decoder {
+    func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T
+}
+
+struct Codec<E: Encoder, D: Decoder> {
+    let encoder: E
+    let decoder: D
+
+    func roundtrip<T: Codable>(_ value: T) throws -> T {
+        let data = try encoder.encode(value)
+        return try decoder.decode(T.self, from: data)
+    }
+}
+```
+
+## Retroactive Modeling
+
+```swift
+// Adding protocol conformance to types you don't own
+extension Int: Identifiable {
+    public var id: Int { self }
+}
+
+// Now Int can be used where Identifiable is required
+let numbers: [Int] = [1, 2, 3]
+ForEach(numbers) { number in
+    Text("\(number)")
+}
+```
+
+## Best Practices
+
+- Prefer protocols over base classes for abstraction
+- Use protocol extensions for default implementations
+- Design protocols with single responsibility
+- Use associated types for generic protocols
+- Apply type erasure when needed for storage
+- Leverage conditional conformance
+- Use opaque return types (some Protocol) for implementation hiding
+- Compose small protocols rather than large ones
+- Document protocol requirements and guarantees
+- Consider protocol inheritance for layered abstraction