import Foundation

@propertyWrapper
struct UserDefault<Value> {
    private let key: String
    private let defaultValue: Value
    private let defaults: UserDefaults

    init(key: String, defaultValue: Value, defaults: UserDefaults = .standard) {
        self.key = key
        self.defaultValue = defaultValue
        self.defaults = defaults
    }

    var wrappedValue: Value {
        get {
            (defaults.object(forKey: key) as? Value) ?? defaultValue
        }
        set {
            defaults.set(newValue, forKey: key)
        }
    }
}

final class Playground {
    @UserDefault(key: "foo", defaultValue: nil, defaults: .standard)
    var foo: String?

    @UserDefault(key: "bar", defaultValue: nil, defaults: .standard)
    var bar: String

   func printFooType() {
        print(type(of: self.foo))   // Optional<String>
    }

   func printBarType() {
        print(type(of: self.bar))   // Optional<String>
    }
}

import Foundation

var value: Any = "value"

@propertyWrapper
struct Wrapper<Value> {
    private let defaultValue: Value

    init(defaultValue: Value) {
        self.defaultValue = defaultValue
    }    var wrappedValue: Value {
        get {
            (value as? Value) ?? defaultValue
        }
        set {
            value = newValue
        }
    }
}

final class Playground {
    @Wrapper(defaultValue: nil)
    var explicitlyOptional: String?

    @Wrapper(defaultValue: nil)
    var implicitlyOptional: String

    @Wrapper(defaultValue: "NonOptional")
    var nonOptional: String

    func printExplicitlyOptionalType() {
        print(type(of: self.explicitlyOptional))
    }

    func printImplicitlyOptionalType() {
        print(type(of: self.implicitlyOptional))
    }

    func printNonOptionalType() {
        print(type(of: self.nonOptional))
    }
}

let playground = Playground()
playground.printExplicitlyOptionalType()   // Optional<String>
playground.printImplicitlyOptionalType()   // Optional<String>
playground.printNonOptionalType()  // String