Fix the API error "can't mutate self is immutable" for BindKeyed in SwiftUI view (#31)

Since `KeyedValueBinding` was a variable on the wrapper and wrapper was
a variable on view that is structure — semantically we were mutating
self.

I moved it to the wrapper itself, and projectedValue now returns the
wrapper, and added a subscript that is non mutating semantically.

Author: MaximBazarov

Decide-Tests/Container/KeyedState_Tests.swift

@@ -93,7 +93,7 @@ import DecideTesting
         XCTAssertEqual(sut.updatesCount, 3)
         XCTAssertEqual(sut.str[id], newValue)
         XCTAssertEqual(sut.strMutableObserve[id], newValue)
-        XCTAssertEqual(sut.strMutable[id].wrappedValue, newValue)
+        XCTAssertEqual(sut.strMutable[id], newValue)
     }
 
     func test_Observation_BindSet() async {
@@ -107,12 +107,12 @@ import DecideTesting
 
         let newValue = "\(#function)-modified"
 
-        sut2.strMutable[id].wrappedValue = newValue
+        sut2.strMutable[id] = newValue
         env.setValue(newValue, \State.$str, at: id)
 
 
         XCTAssertEqual(sut.updatesCount, 2)
-        XCTAssertEqual(sut.strMutable[id].wrappedValue, newValue)
+        XCTAssertEqual(sut.strMutable[id], newValue)
         XCTAssertEqual(sut.str[id], newValue)
         XCTAssertEqual(sut.strMutableObserve[id], newValue)
     }

Decide-Tests/SwiftUI_Tests.swift

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Decide package open source project
+//
+// Copyright (c) 2020-2023 Maxim Bazarov and the Decide package
+// open source project authors
+// Licensed under MIT
+//
+// See LICENSE.txt for license information
+//
+// SPDX-License-Identifier: MIT
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftUI
+import Decide
+import XCTest
+import DecideTesting
+
+@MainActor final class SwiftUI_Tests: XCTestCase {
+
+    final class State: KeyedState<Int> {
+        @Property var str = "str-default"
+        @Mutable @Property var strMutable = "strMutable-default"
+    }
+
+    struct ViewUnderTest: View {
+        @BindKeyed(\State.$strMutable) var strMutable
+        @ObserveKeyed(\State.$str) var str
+        @ObserveKeyed(\State.$strMutable) var strMutableObserved
+
+        var body: some View {
+            TextField("", text: strMutable[1])
+            Text(str[1])
+            Text(strMutableObserved[1])
+        }
+    }
+
+}
+

Decide/Accessor/Default/DefaultBindKeyed.swift

@@ -59,3 +59,30 @@ import Foundation
         set { fatalError() }
     }
 }
+
+@MainActor public struct KeyedValueBinding<I: Hashable, S: KeyedState<I>, Value> {
+    unowned var environment: ApplicationEnvironment
+
+    let observer: Observer
+    let propertyKeyPath: KeyPath<S, Property<Value>>
+
+    init(
+        bind propertyKeyPath: KeyPath<S, Property<Value>>,
+        observer: Observer,
+        environment: ApplicationEnvironment
+    ) {
+        self.propertyKeyPath = propertyKeyPath
+        self.observer = observer
+        self.environment = environment
+    }
+
+    public subscript(_ identifier: I) -> Value {
+        get {
+            environment.subscribe(observer, on: propertyKeyPath, at: identifier)
+            return environment.getValue(propertyKeyPath, at: identifier)
+        }
+        set {
+            environment.setValue(newValue, propertyKeyPath, at: identifier)
+        }
+    }
+}

Decide/Accessor/Default/DefaultObserveKeyed.swift

@@ -69,3 +69,27 @@ import Foundation
         set { fatalError() }
     }
 }
+
+@MainActor public struct KeyedValueObserve<I: Hashable, S: KeyedState<I>, Value> {
+    unowned var environment: ApplicationEnvironment
+
+    let observer: Observer
+    let propertyKeyPath: KeyPath<S, Property<Value>>
+
+    init(
+        bind propertyKeyPath: KeyPath<S, Property<Value>>,
+        observer: Observer,
+        environment: ApplicationEnvironment
+    ) {
+        self.propertyKeyPath = propertyKeyPath
+        self.observer = observer
+        self.environment = environment
+    }
+
+    public subscript(_ identifier: I) -> Value {
+        get {
+            environment.subscribe(observer, on: propertyKeyPath, at: identifier)
+            return environment.getValue(propertyKeyPath, at: identifier)
+        }
+    }
+}

Decide/Accessor/KeyValueBinding.swift

@@ -27,19 +27,29 @@ import SwiftUI
         self.propertyKeyPath = propertyKeyPath.appending(path: \.wrappedValue)
     }
 
-    public lazy var wrappedValue: KeyedValueObserve<I, S, Value> = {
-        return KeyedValueObserve(
-            bind: propertyKeyPath,
-            observer: Observer(observer),
-            environment: environment
+    public subscript(_ identifier: I) -> Binding<Value> {
+        Binding<Value>(
+            get: {
+                environment.subscribe(
+                    Observer(observer),
+                    on: propertyKeyPath,
+                    at: identifier)
+                return environment.getValue(propertyKeyPath, at: identifier)
+            },
+            set: {
+                return environment.setValue($0, propertyKeyPath, at: identifier)
+            }
         )
-    }()
+    }
 
-    public lazy var projectedValue: KeyedValueBinding<I, S, Value> = {
-        return KeyedValueBinding(
-            bind: propertyKeyPath,
-            observer: Observer(observer),
-            environment: environment
-        )
-    }()
+    public subscript(_ identifier: I) -> Value {
+        get {
+            environment.subscribe(Observer(observer), on: propertyKeyPath, at: identifier)
+            return environment.getValue(propertyKeyPath, at: identifier)
+        }
+    }
+
+    public var wrappedValue: Self {
+        self
+    }
 }

Decide/Accessor/KeyValueObserve.swift

@@ -37,11 +37,14 @@ import SwiftUI
         self.propertyKeyPath = propertyKeyPath.appending(path: \.wrappedValue)
     }
 
-    public lazy var wrappedValue: KeyedValueObserve<I, S, Value> = {
-        return KeyedValueObserve(
-            bind: propertyKeyPath,
-            observer: Observer(observer),
-            environment: environment
-        )
-    }()
+    public subscript(_ identifier: I) -> Value {
+        get {
+            environment.subscribe(Observer(observer), on: propertyKeyPath, at: identifier)
+            return environment.getValue(propertyKeyPath, at: identifier)
+        }
+    }
+
+    public var wrappedValue: Self {
+        self
+    }
 }