aigroup-workflow 2.1.2 → 2.2.0

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

@@ -1,377 +0,0 @@
-# Memory & Performance
-
-## 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

@@ -1,354 +0,0 @@
-# Protocol-Oriented Programming
-
-## 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