A modern programming language that makes developers happier.

kotlinlang

It appears that on iOS SwiftUI we can leverage property wrappers so that observing `Value` looks nicer. Details are in the thread.

We can define the following property wrapper:
```@propertyWrapper struct StateValue&lt;T : AnyObject&gt;: DynamicProperty {
    @ObservedObject
    private var obj: ObservableValue&lt;T&gt;

    var wrappedValue: T { obj.value }

    init(_ value: Value&lt;T&gt;) {
        obj = ObservableValue(value)
    }
}```
And then instead of writing like this:
```struct CounterView: View {
    let counter: CounterComponent

    private var observableModel: ObservableValue&lt;CounterComponentModel&gt;
    private var model: CounterComponentModel { observableModel.value }

    init(_ counter: CounterComponent) {
        self.counter = counter
        observableModel = ObservableValue(counter.model)
    }

    var body: some View {
        ...
    }
}```
We can write like this:
```struct CounterView: View {
    let counter: CounterComponent

    @StateValue
    private var model: CounterComponentModel

    init(_ counter: CounterComponent) {
        self.counter = counter
        _model = StateValue(counter.model)
    }

    var body: some View {
        ...
    }
}```
What do you think? Are there any corner cases I'm missing?

not at my computer right now, but on the surface this looks great!