A SwiftUI toggle to switch on/off a value for an optional state

ValueToggle.swift

struct ValueToggle<Value, Label: View>: View {
    
    @Binding var value: Value?
    let onValue: Value
    let label: () -> Label
    
    @State private var isOn = false
    
    var body: some View {
        Toggle(isOn: $isOn, label: label)
            .onAppear {
                isOn = (value != nil)
            }
            .onChange(of: isOn) {
                value = $0 ? onValue : nil
            }
    }
}

extension ValueToggle where Label == Text {
    internal init(value: Binding<Value?>, onValue: Value, label: String) {
        self._value = value
        self.onValue = onValue
        self.label = { Text(label) }
    }
}

Wouldn't it be easier to write a custom binding like

extension Binding {
    public func withDefault<Wrapped>(_ defaultValue: Wrapped) -> Binding<Bool> where Wrapped? == Value {
        return Binding<Bool> {
            self.wrappedValue != nil
        } set: { newValue in
            self.wrappedValue = newValue ? defaultValue: nil
        }
      }
    }

Toogle("", isOn: myValue.withDefault(defaultValue))

Hey @smic, that is a great idea and totally valid as well!
However I think that ValueToggle reads better and conveys the meaning easier, but that is just me - thanks for your input!

.... though your suggestion did make me think; it could also be an extension on Toggle it self!

extension Toggle where Label == Text {
    public init<Value>(_ titleKey: LocalizedStringKey, for value: Binding<Value?>, default defaultValue: Value) {
        self.init(titleKey, isOn: Self.binding(value, default: defaultValue))
    }
    
    public init<Value, S: StringProtocol>(_ title: S, for value: Binding<Value?>, default defaultValue: Value) {
        self.init(title, isOn: Self.binding(value, default: defaultValue))
    }
}

extension Toggle {
    public init<Value>(for value: Binding<Value?>, default defaultValue: Value, @ViewBuilder label: () -> Label) {
        self.init(isOn: Self.binding(value, default: defaultValue), label: label)
    }
    
    private static func binding<Value>(_ value: Binding<Value?>, default defaultValue: Value) -> Binding<Bool> {
        Binding {
            value.wrappedValue != nil
        } set: { newValue in
            value.wrappedValue = newValue ? defaultValue: nil
        }
    }
}