Declaring a lazy-initialized object with `let` in Swift

Lazy.swift

class Lazy <T> {
    
    private var t: T?
    
    private let initializer: () -> T
    
    private let semaphore = DispatchSemaphore(value: 1)
    
    init(_ initializer: @escaping () -> T) {
        self.initializer = initializer
    }
    
    private func initialize() -> T {
        return self.initializer()
    }
    
    var value: T {
        
        self.semaphore.wait()
        defer { self.semaphore.signal() }
        
        switch self.t {
        case .some(let t):
            return t
            
        case .none:
            let t = initialize()
            defer { self.t = t }
            return t
        }
        
    }
    
}

func lazy <T> (_ initializer: @escaping () -> T) -> Lazy<T> {
    return Lazy(initializer)
}

struct A {
    let i: Int
}

class Test {
    
    let a: Lazy<A> = lazy { A(i: 1) }
    
}

let test = Test()
test.a.value.i // 1