Optional shared value subscript to optional shared nested value

[Pomanks]

Hi there!

Given the following code sample, I just can't seem to get around subscripting Shared<Foo?> into Shared<Bar?> as you can see inside getSharedBar().

struct Foo {

    var bar: Bar
}

struct Bar {

    var id: UUID
}

struct State {

    @Shared
    var foo: Foo?

    func getSharedBar() -> Shared<Bar?> {
        $foo.bar // Value of optional type 'Foo?' must be unwrapped to refer to member 'bar' of wrapped base type 'Foo'
        $foo?.bar // Cannot use optional chaining on non-optional value of type 'Shared<Foo?>'

        _ = Shared($foo)?.bar // Here I get Shared<Bar>?
    }
}

Is this not supported or am I not seeing what's right in front of me…? 😅

[mbrandonw]

Hi @Pomanks, the last line you have is the way to do it, you just need to unwrap the shared:

@Shared var foo: Foo?
if let sharedFoo = Shared($foo) {
  let sharedBar = sharedFoo.bar
}

This is necessary because you have to deal with the optionality of Foo somewhere. You can't just immediately get a Shared<Bar> because what would it hold if the Shared<Foo?> was nil'd out?

This is also how things works in SwiftUI with Binding, which has a Binding.int(_:) for turning Binding<T?> into Binding<T>?.

[Pomanks]

Hi @mbrandonw, I'm not trying to get a Shared<Bar> but a Shared<Bar?>.

What I expect in the end is to keep a Shared reference to the bar inside Foo - like in the following documentation, with an optional Member though - but I can't find a way to do so.

[mbrandonw]

Ah I see, sorry I misread that.

What you are trying to do isn't really possible. Suppose you could get a bar: Shared<Bar?> from a foo: Shared<Foo?>, and suppose that the foo was currently nil. What would happen if you wrote a non-nil value to the bar? It would somehow need to construct a Foo and stick the bar into it, which can't happen generically. So it would have no choice but to discard that value and keep bar as nil.

It's worth mentioning that this is a bit different from the behavior of foo?.bar. Because clearly one can do foo?.bar = Bar() even with foo is nil, and the Bar() is just discarded. But at least at the call site you can plainly see foo? so you know an optional is involved. But I think it would be weird to have a Shared<Bar?>, write a non-nil value to it, but for it to still be nil after that.

The same story also plays out with SwiftUI Binding.

[Pomanks]

No worries!
Thank you for taking the time to give such a detailed answer, I better understand why that's not possible and why it couldn't be.

I guess I'll have to change my implementation then 😅