Deprecate Shared's optional dynamic member lookup overload (#3145)

* Deprecate `Shared`'s optional dynamic member lookup overload

Currently, `Shared`'s dynamic member lookup is overloaded for
convenience:

```swift
$shared                // Shared<Root>
$shared.value          // Shared<Value>
$shared.optionalValue  // Shared<Value>?
```

Unfortunately, this is also perhaps surprising, and goes against the
grain when folks might expect to be handed a `Shared<Value?>`.

Also, there are times when you have a `Shared<Value?>` already, and you
want to unwrap it. Dynamic member lookup doesn't help there (unless you
know you can call `$shared[dynamicMember: \.self]`), and so you need a
totally different operation to handle it:

```swift
if let unwrappedShared = Shared($optional) {
  // Do something with 'Shared<Value>'
}
```

So let's avoid this confusion in the future and focus on a single API
for unwrapping shared values, which is the failable initializer that
mirrors an API on `Binding`.

* wip

* Update SharedReader.swift

* Update Shared.swift

* Update SharedReader.swift

Author: stephencelis

ComposableArchitecture.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -37,8 +37,12 @@ public struct Shared<Value> {
   }
 
   public init?(_ base: Shared<Value?>) {
-    guard let shared = base[dynamicMember: \.self] else { return nil }
-    self = shared
+    guard let initialValue = base.wrappedValue
+    else { return nil }
+    self.init(
+      reference: base.reference,
+      keyPath: base.keyPath.appending(path: \Value?.[default:DefaultSubscript(initialValue)])!
+    )
   }
 
   public var wrappedValue: Value {
@@ -117,17 +121,13 @@ public struct Shared<Value> {
     Shared<Member>(reference: self.reference, keyPath: self.keyPath.appending(path: keyPath)!)
   }
 
+  @available(
+    *, deprecated, message: "Use 'Shared($value.optional)' to unwrap optional shared values"
+  )
   public subscript<Member>(
     dynamicMember keyPath: WritableKeyPath<Value, Member?>
   ) -> Shared<Member>? {
-    guard let initialValue = self.wrappedValue[keyPath: keyPath]
-    else { return nil }
-    return Shared<Member>(
-      reference: self.reference,
-      keyPath: self.keyPath.appending(
-        path: keyPath.appending(path: \.[default:DefaultSubscript(initialValue)])
-      )!
-    )
+    Shared<Member>(self[dynamicMember: keyPath])
   }
 
   public func assert(
@@ -358,16 +358,12 @@ extension Shared {
     SharedReader(reference: self.reference, keyPath: self.keyPath)
   }
 
+  @available(
+    *, deprecated, message: "Use 'SharedReader($value.optional)' to unwrap optional shared values"
+  )
   public subscript<Member>(
     dynamicMember keyPath: KeyPath<Value, Member?>
   ) -> SharedReader<Member>? {
-    guard let initialValue = self.wrappedValue[keyPath: keyPath]
-    else { return nil }
-    return SharedReader<Member>(
-      reference: self.reference,
-      keyPath: self.keyPath.appending(
-        path: keyPath.appending(path: \.[default:DefaultSubscript(initialValue)])
-      )!
-    )
+    SharedReader(self[dynamicMember: keyPath])
   }
 }

Sources/ComposableArchitecture/SharedState/Shared.swift

@@ -26,8 +26,12 @@ public struct SharedReader<Value> {
   }
 
   public init?(_ base: SharedReader<Value?>) {
-    guard let shared = base[dynamicMember: \.self] else { return nil }
-    self = shared
+    guard let initialValue = base.wrappedValue
+    else { return nil }
+    self.init(
+      reference: base.reference,
+      keyPath: base.keyPath.appending(path: \Value?.[default:DefaultSubscript(initialValue)])!
+    )
   }
 
   public init(_ base: Shared<Value>) {
@@ -61,17 +65,13 @@ public struct SharedReader<Value> {
     SharedReader<Member>(reference: self.reference, keyPath: self.keyPath.appending(path: keyPath)!)
   }
 
+  @available(
+    *, deprecated, message: "Use 'SharedReader($value.optional)' to unwrap optional shared values"
+  )
   public subscript<Member>(
     dynamicMember keyPath: KeyPath<Value, Member?>
   ) -> SharedReader<Member>? {
-    guard let initialValue = self.wrappedValue[keyPath: keyPath]
-    else { return nil }
-    return SharedReader<Member>(
-      reference: self.reference,
-      keyPath: self.keyPath.appending(
-        path: keyPath.appending(path: \.[default:DefaultSubscript(initialValue)])
-      )!
-    )
+    SharedReader<Member>(self[dynamicMember: keyPath])
   }
 
   #if canImport(Combine)