Swift Language and Memory Management Questions

@propertyWrapper
struct Clamped<Value: Comparable> {
    private var value: Value
    private let range: ClosedRange<Value>
    private(set) var wasClamped = false

    var wrappedValue: Value {
        get { value }
        set {
            if newValue < range.lowerBound {
                value = range.lowerBound
                wasClamped = true
            } else if newValue > range.upperBound {
                value = range.upperBound
                wasClamped = true
            } else {
                value = newValue
                wasClamped = false
            }
        }
    }

    var projectedValue: Bool { wasClamped }

    init(wrappedValue initial: Value, _ range: ClosedRange<Value>) {
        self.range = range
        self.value = min(max(initial, range.lowerBound), range.upperBound)
        self.wasClamped = (self.value != initial)
    }
}

struct Settings {
    @Clamped(0...100) var volume: Int = 50
}

var s = Settings()
s.volume = 150
print(s.volume)        // 100
print(s.$volume)       // true (was clamped)

public protocol Cancellable { func cancel() }
public final class HandlerToken: Cancellable {
  private var onCancel: (() -> Void)?
  init(_ onCancel: @escaping ()->Void) { self.onCancel = onCancel }
  public func cancel() { onCancel?(); onCancel = nil }
}

public func observe<T: AnyObject>(_ target: T, handler: @escaping (T, Event)->Void) -> Cancellable {
  weak var weakTarget = target
  let token = HandlerToken {
    // remove stored closure from internal list
  }
  let storedClosure: (Event)->Void = { [weak weakTarget] event in
    guard let t = weakTarget else { token.cancel(); return }
    handler(t, event)
  }
  store(storedClosure, token) // internal storage
  return token
}

public func weakify<T: AnyObject, A>(_ target: T, _ fn: @escaping (T, A)->Void) -> (A)->Void {
  return { [weak target] a in guard let t = target else { return }; fn(t, a) }
}

import Foundation

class Holder { var obj: NSString = "hello" as NSString }
let h = Holder()

// Slow: each access may retain/release obj or create autoreleased temporaries
func slowLoop() {
  let start = CFAbsoluteTimeGetCurrent()
  var sum = 0
  for _ in 0..<5_000_000 {
    let s = h.obj as String
    sum += s.count
  }
  print("slow:", CFAbsoluteTimeGetCurrent() - start, sum)
}

// Faster: cache strong ref once
func fastLoop() {
  let start = CFAbsoluteTimeGetCurrent()
  var sum = 0
  let local = h.obj // single retain
  for _ in 0..<5_000_000 {
    let s = local as String
    sum += s.count
  }
  print("fast:", CFAbsoluteTimeGetCurrent() - start, sum)
}

slowLoop()
fastLoop()

import Foundation

// Assume C API:
// typedef const struct __CFMyObject *CFMyObjectRef;
// CFMyObjectRef CFMyObjectCreate(...); // returns +1 retained
// void CFMyObjectDoSomething(CFMyObjectRef);

final class MyObject {
    /// Owned retained CF object
    private var cfObj: CFMyObjectRef

    /// Initialize by taking ownership of a retained CFMyObjectRef
    init(takingRetained cfObj: CFMyObjectRef) {
        self.cfObj = cfObj
    }

    /// Initialize from Unmanaged when you have a retained value
    init(unmanagedRetained: Unmanaged<CFMyObjectRef>) {
        // consume the retained ownership without extra retain
        self.cfObj = unmanagedRetained.takeRetainedValue()
    }

    deinit {
        // release ownership when wrapper goes out of scope
        CFRelease(cfObj)
    }

    func doSomething() {
        CFMyObjectDoSomething(cfObj)
    }

    // Factory: create a new wrapper from C factory that returns +1
    static func create(...) -> MyObject {
        let raw: CFMyObjectRef = CFMyObjectCreate(...)
        // CFMyObjectCreate returns a retained object: wrap directly
        return MyObject(takingRetained: raw)
    }

    // Expose for C interop: pass ownership to C (retain before passing if needed)
    func passToCAndTransferOwnership() -> Unmanaged<CFMyObjectRef> {
        // If we want to transfer ownership to C, relinquish our ownership by passing a retained object.
        // Caller is responsible for releasing.
        CFRetain(cfObj)
        return Unmanaged.passRetained(cfObj)
    }

    // Access without transferring ownership
    func withUnretained<T>(_ body: (CFMyObjectRef) throws -> T) rethrows -> T {
        return try body(cfObj)
    }
}