Using @Shared state with BindableAction

[maximkrouk]

Both @Shared and BindingAction are powerful tools in TCA, and they used to work fine together. However, today I reopened one of my projects that had been on hold for about 3 months and was surprised to see a bunch of compilation errors related to this interaction.

Here is a previous example that would compile some time ago, which is a bit confusing (because Shared.value setter has been marked @unavailable for quite a while 🌚)

import ComposableArchitecture
import SwiftUI

@Reducer
struct Example {
	@ObservableState
	struct State: Equatable {
		@Shared(.inMemory("value"))
		var value: String = "Hello, World!"
	}

	@CasePathable
	enum Action: BindableAction, Equatable {
		case binding(BindingAction<State>)
	}

	var body: some ReducerOf<Self> {
		BindingReducer()
		Reduce { state, action in
			switch action {
			case .binding(\.value): // ❌ Cannot assign to value: immutable key path
				return .none
			}
		}
	}
}

struct ExampleView: View {
	@Bindable
	private var store: StoreOf<Example> = .init(
		initialState: Example.State(),
		reducer: Example.init
	)

	var body: some View {
		TextField("Greeting", text: $store.value) // ❌ Cannot assign to property: '$store' is immutable
	}
}

The following workaround fixes the compilation errors:

import ComposableArchitecture
import SwiftUI

@Reducer
struct Example {
	@ObservableState
	struct State: Equatable {
		@Shared(.inMemory("value"))
		var value: String = "Hello, World!"
	}

	@CasePathable
	enum Action: BindableAction, Equatable {
		case binding(BindingAction<State>)
	}

	var body: some ReducerOf<Self> {
		BindingReducer()
		Reduce { state, action in
			switch action {
			case .binding(\.$value.mutableValue):
				return .none
			}
		}
	}
}

struct ExampleView: View {
	@Bindable
	private var store: StoreOf<Example> = .init(
		initialState: Example.State(),
		reducer: Example.init
	)

	var body: some View {
		TextField("Greeting", text: $store.$value.mutableValue)
	}
}

extension Shared {
	public var mutableValue: Value {
		get { self.wrappedValue }
		set { withLock { $0 = newValue } }
	}
}

---

Questions about this approach

Could you please elaborate on potential problems with this solution?

From my current understanding:

BindableAction concerns:

• ⚠️ In both examples, direct state mutation will not trigger case .binding(\.<#KeyPath#>):
• ✅ In both examples, modifications performed through TextField will trigger case .binding(\.<#KeyPath#>):

@Shared concerns:

• ❌ For complex values, users may attempt in place modifications of derived values, which could potentially lead to state corruption
• ✅ Whole value replacements should be safe, especially when such updates are always performed on the MainThread. In my case such values are usually set in some specific view but can be read from some other stores to retrieve params for running some work (for example AspectRatioPicker sets enum CaptureAspectRatio value to @Shared state, when capture button is pressed CameraFeature reads this value (and a few other ones) and passes it as an argument to CameraClient)
• ⚠️ Strings are collections, so they are complex values, they are provided for simplicity of examples, however from my understanding doing this on the main thread is still safe 🤔

Fundamentally this pattern is unsafe and probably shouldn't be a part of the swift-sharing library, but local use with simple values on the MainThread looks pretty safe to me and smth like this

@Reducer
struct Example {
	@ObservableState
	struct State: Equatable {
		@Shared(.inMemory("greeting"))
		var greeting: String = "Hello, World!"

		@Shared(.inMemory("name"))
		var name: String = "Hello, World!"
	}

	@CasePathable
	enum Action: BindableAction, Equatable {
		case binding(BindingAction<State>)
	}

	var body: some ReducerOf<Self> {
		BindingReducer()
	}
}

struct ExampleView: View {
	@Bindable
	private var store: StoreOf<Example> = .init(
		initialState: Example.State(),
		reducer: Example.init
	)

	var body: some View {
		TextField("Greeting", text: $store.$greeting.mutableValue)
		TextField("Name", text: $store.$name.mutableValue)
	}
}

Has much better ergonomics than this:

import ComposableArchitecture
import SwiftUI

@Reducer
struct Example {
	@ObservableState
	struct State: Equatable {
		@Shared(.inMemory("greeting"))
		var greeting: String = "Hello, World!"
		
		@Shared(.inMemory("name"))
		var name: String = "TCA"
	}

	@CasePathable
	enum Action: Equatable {
		case setGreeting(String)
		case setName(String)
	}

	var body: some ReducerOf<Self> {
		Reduce { state, action in
			switch action {
			case let .setGreeting(value):
				state.$greeting.withLock { $0 = value }
				return .none
			case let .setName(value):
				state.$name.withLock { $0 = value }
				return .none
			}
		}
	}
}

struct ExampleView: View {
	@Bindable
	private var store: StoreOf<Example> = .init(
		initialState: Example.State(),
		reducer: Example.init
	)

	var body: some View {
		TextField("Greeting", text: $store.greeting.sending(\.setGreeting))
		TextField("Name", text: $store.name.sending(\.setName))
	}
}

Maybe it's with adding @SharedState for TCA only or @UIShared with available value setter? 🤔

[maximkrouk]

UPD:

I just implemented this wrapper by copying Shared sources

@dynamicMemberLookup
@propertyWrapper
public struct SharedState<Value> {
	let underlying: Shared<Value>

	init(_ underlying: Shared<Value>) {
		self.underlying = underlying
	}
	
	// Reimplement all inits/properties/methods using `underlying` implementation
}

full code available here

The only downside I found (aside the approach being potentially unsafe in some scenarios) is that it's not included in ComposableArchitectureMacros.ObservableState macro as "known attribute" so @ObservationStateIgnored has to be added manually 🤔

However batch-replacing occurrences of <whitespace1>@Shared(.<any1>(<any2>)) with <whitespace>@Shared((.<any1>(<any2>))<newline><whitespace1>@ObservationStateIgnored fixed compilation issues and the app seems to work properly

Note

I'm using swift-sharing-extensions for my keys, so in case someone gets the same issue and wants the same solution, your replacement format might be different

[stephencelis]

@maximkrouk This is due to an availability hole that was plugged in Swift 6.3 that such code was exploiting. It affected the Case Studies app and we PRed a fix here.

var body: some View {
  @Binding(store.$greeting) var greeting
  @Binding(store.$name) var name

  TextField("Greeting", text: $greeting)
  TextField("Name", text: $name)
}

While a little more verbose, it's honest about what's going on. We also think you should never have been able to pattern match on .binding(\.sharedValue) and instead should rely on the shared value's publisher, which more honestly reports when a shared value changes (including all events outside the BindingReducer).

In TCA2 we hope to have the ergonomics much better here, where bindings are built into the system 😄

[maximkrouk]

Thank you for the clarification

Tho explicitly handling not just state changes but ui-events can also be helpful, so I wouldn't say

you should never have been able to pattern match on .binding(.sharedValue)

it's just a different tool, that has to be used with caution

But afaiu it's still possible to use it like this when needed

var body: some View {
  @Binding(store.$greeting) var greeting
  @Binding(store.$name) var name

  TextField("Greeting", text: $greeting.sending(\.didInputGreeting))
  TextField("Name", text: $name.sending(\.didInputName))
}

Note

UPD

• This API requires binding to be derived from Bindable, so nope, it's not available
• UIBinding(Shared<Value>) is also unavailable 😔

I just experimented a bit and figured out that this will work

extension SwiftUI.Bindable {
	@MainActor
	public subscript<Member>(
		dynamicMember keyPath: KeyPath<Value, Shared<Member>>
	) -> Binding<Member> where Value: AnyObject {
		Binding(wrappedValue[keyPath: keyPath])
	}
}

However this version doesn't support .sending(CasePath), such support can roughly be implemented like this outside of the library, however I'm not sure how important are checks and opening existentials in SharedBinding.swift:

// This extension has to be implemented for other _StoreBindable types
extension SwiftUI.Bindable {
	@_disfavoredOverload
	public subscript<State: ObservableState, Action, Member>(
		dynamicMember keyPath: KeyPath<State, Shared<Member>>
	) -> _StoreBindable_SwiftUI<State, Action, Member>
	where Value == Store<State, Action> {
		// ⚠️ Have to use local _mutableValue and not the
		// `Binding(_binding(keyPath))`
		// to preserve `_StoreBindable_SwiftUI` type
		self._binding(keyPath)[dynamicMember: \._mutableValue]
	}

	// Alias for default dynamicMemberLookup to avoid infinite
	// recursion in the subscript above
	private func _binding<State: ObservableState, Action, Member>(
		_ keyPath: KeyPath<State, Member>
	) -> _StoreBindable_SwiftUI<State, Action, Member>
	where Value == Store<State, Action> {
		self[dynamicMember: keyPath]
	}
}

extension Shared {
	fileprivate var _mutableValue: Value {
		get { wrappedValue }
		set { withLock { $0 = newValue } }
	}
}

Fix for pattern-matching:

extension BindingAction {
	public static func ~= <Value>(
		keyPath: _SendableKeyPath<Root, Value>,
		bindingAction: Self
	) -> Bool {
		keyPath == bindingAction.keyPath
	}
}

Usage:

@Bindable
var store: Store<State, Action>

let s: Shared<Value> = store.$value
let b1: Binding<Value> = $store.$value
let b2: _StoreBindable_SwiftUI<Value> = $store.$value 
let b3: Binding<Value> = $store.$value.sending(\.value)

This way:

• usage of shared bindings is explicit enough (uses $-prefixed identifier)
• sending action alongside the mutation is still available
• BindingReducer() should be removed, mutations are performed directly, action is only needed for custom handling

Note

UPD: It's not that simple, BindingReducer seems to be needed for non-shared values and I still need to think about it 🤔

[stephencelis]

I think SwiftNavigation could add a SwiftNavigationSharing trait to implement those UIBinding helpers. Would you be interested in looking into PRing that?

it's just a different tool, that has to be used with caution

It's different now, for sure, but we consider that a subtlety and limitation for the most part and aren't sure the distinction should be meaningful. In TCA 2.0 binding modifications are built into the system and observing changes to state is more universal than the reducer being modified.

[maximkrouk]

Yep, here are PRs

• feat: Expose reference APIs swift-sharing#205
• feat: Sharing trait swift-navigation#331

[maximkrouk]

UPD: I ended up with the following solution

import ComposableArchitecture

public protocol SharedBindableAction<State> {
	associatedtype State
	static func shared(_ action: SharedBindingAction<State>) -> Self
}

public struct SharedBindingAction<State>: Equatable {
	let keyPath: PartialKeyPath<State>

	init<Value>(
		_ keyPath: KeyPath<State, Shared<Value>>
	) {
		self.keyPath = keyPath
	}
}

public func ~=<State, Value>(
	lhs: _SendableKeyPath<State, Shared<Value>>,
	rhs: SharedBindingAction<State>
) -> Bool {
	lhs == rhs.keyPath
}

extension Store where
	Action: SharedBindableAction,
	State: ObservableState,
	Action.State == State
{
	public subscript<Value>(
		shared keyPath: KeyPath<State, Shared<Value>>
	) -> Value {
		get { self[dynamicMember: keyPath].wrappedValue }
		set {
			self[dynamicMember: keyPath].withLock { $0 = newValue }
			self.send(.shared(.init(keyPath)))
		}
	}
}

Usage:

View:

@Bindable
var store: StoreOf<Feature>

Toggle(isOn: $store[shared: \.$isOn])
  .disabled(store[shared: \.isDisabled])
  
Button(action: { store[shared: \.isDisabled].toggle() }) {
  Text(store[shared: \.isDisabled] ? "Enable" : "Disable")
}

Reducer:

enum Action: SharedBindableAction {
  case shared(SharedBindingAction<State>)
  ...
}

switch action {
case .shared(\.$isOn):
  print("Got isOn(\(state.isOn)) from the \(Self.self) feature")
  return .none
...
}

Note

Action is only triggered when sent from current feature's store (as expected)