Is it possible to derive a binding using a key-path?

[wltrup]

Hello 👋

Suppose I have a feature state such as

struct State {
   var property1: String
   var property2: String
   var property3: String
}

In the feature's view I can derive a binding to each of the properties by using

$store.property1.sending(\.someAction)

with analogous lines for properties 2 and 3 but can I do this more generically, by referencing those properties and actions through key-paths, something along the lines of one of these?

$store[keyPath: propertyKeyPath].sending(actionCasePath)
$store.state[keyPath: propertyKeyPath].sending(actionCasePath)

I've managed to abstract away the action but not the state. It seems that I can only derive a binding by explicitly specifying the property I want a binding for.

Thanks in advance for any replies.

[mbrandonw]

Hi @wltrup, the syntax $store.property1 is unlocked by @dynamicMemberLook, and technically desugars to:

$store[dynamicMember: \.property1]

So you should be able to do:

$store[dynamicMember: propertyKeyPath].sending(actionCasePath)

Can you let me know if that works?

[larryonoff]

@mbrandonw Indeed! I got your idea. But do you mean swift will compile the line $store.beerBottle.isOpen.sending(\.setBeerBottleOpen)?

[mbrandonw]

Yes, that should compile just fine. Is it not for you?

[larryonoff]

I thought that it was not. But I don't have example yet. I'll create the issue if it will arise again

[mbrandonw]

It should work just fine since the thing you get back from $store.beerBottle has dynamic member lookup itself, allowing you to further chain into sub-properties:

swift-composable-architecture/Sources/ComposableArchitecture/Observation/Binding+Observation.swift

Lines 137 to 149 in 15d2b12

	@dynamicMemberLookup
	public struct _StoreBinding<State: ObservableState, Action, Value> {
	fileprivate let binding: Binding<Store<State, Action>>
	fileprivate let keyPath: KeyPath<State, Value>
	public subscript<Member>(
	dynamicMember keyPath: KeyPath<Value, Member>
	) -> _StoreBinding<State, Action, Member> {
	_StoreBinding<State, Action, Member>(
	binding: self.binding,
	keyPath: self.keyPath.appending(path: keyPath)
	)
	}

[wltrup]

The only time to use [dynamicMember:] is when writing library code that needs to abstractly work with store bindings.

That was exactly the reason I asked the question and the use-case I needed to implement in my current project.