Version 2.0.0

- Version 2.0.0 Release Commit
- Removed the `<TKey: Hashable>` Generics from all implementations of `KeyedObservable`
- `KeyedObservable` now has `<TKey: Hashable>` applied to applicable respective `func`s
- `KeyedObservable` Implementations now use `AnyHashable` for internal members related to Keys.
- `for:` Parameter of `KeyedObservable` `func`s has become `key:` for individual Keys, and `keys: ` for `Array`s of Keys. This is because an `Array` is itself a `Hashable` type, and causes ambiguity with `func` overloading.
- Keyed Unit Tests updated accordingly
- README.MD updated to reflect all of the above

Author: LK-Simon

README.md

@@ -17,7 +17,7 @@
 </p>
 
 Collection of carefully-prepared Classes and Protocols designed to imbue your inheriting Object Types with efficient, protocol-driven Observer Pattern Behaviour.
-As of version 1.1.0, this includes support for *Keyed Observers* (see usage examples below for details)
+As of version 2.0.0, this includes support for *Keyed Observers* (see usage examples below for details)
 
 ## Installation
 ### Xcode Projects
@@ -31,7 +31,7 @@ let package = Package(
     dependencies: [
         .package(
             url: "https://github.com/Flowduino/Observable.git",
-            .upToNextMajor(from: "1.1.0")
+            .upToNextMajor(from: "2.0.0")
         ),
     ],
     //...
@@ -196,11 +196,12 @@ You can adopt this approach for any Observation-Based Thread Behaviour you requi
 
 ### Keyed Observation Pattern
 As of version 1.1.0, you can now register and notify *Keyed Observers*.
+**Note**: Version 2.0.0 modified the Interface significantly to eliminate the need for Generic Typing of the Key. Key Types are now inferred for you.
 
 This functionality is an extension of the standard Observer Pattern, and is implemented in the following classes from which you can extend:
-- `KeyedObservableClass<TKey: Hashable>` instead of `ObservableClass`
-- `KeyedObservableThread<TKey: Hashable>` instead of `ObservableThread`
-- `KeyedObservableThreadSafeClass<TKey: Hashable>` instead of `ObservableThreadSafeClass`
+- `KeyedObservableClass` instead of `ObservableClass`
+- `KeyedObservableThread` instead of `ObservableThread`
+- `KeyedObservableThreadSafeClass` instead of `ObservableThreadSafeClass`
 
 *Remember, Keyed Observation is an **extension** of the basic Observation Pattern, so any Keyed Observable is also inherently able to register and notify non-Keyed Observers*
 
@@ -227,7 +228,7 @@ class TestKeyedObservableClass: KeyedObservableClass<String> {
     private var keyValues: [String:String] = ["A":"Hello", "B":"Foo", "C":"Ping"]
 
     func setValue(key: String, value: String) {
-        withKeyedObservers(for: key) { (key, observer: TestKeyedObservable) in
+        withKeyedObservers(key: key) { (key, observer: TestKeyedObservable) in
             observer.onValueChanged(key: key, oldValue: self.keyValues[key]!, newValue: value)
         }
         self.keyValues[key] = value
@@ -265,29 +266,29 @@ At this point, we need to consider what Key or Keys our `observer` is going to O
 
 For example, we can Observe just one key:
 ```swift
-observable.addKeyedObserver(for: "A", observer)
+observable.addKeyedObserver(key: "A", observer)
 ```
 The above means that `observer` would only have its `onValueChanged` method invoked when the value of key *A* is modified in `observable`.
 
 Likewise, if we only care about key *B*, we can do:
 ```swift
-observable.addKeyedObserver(for: "B", observer)
+observable.addKeyedObserver(key: "B", observer)
 ```
 
 If we care about *both* known keys, we can simply register them both:
 ```swift
-observable.addKeyedObserver(for: ["A", "B"], observer)
+observable.addKeyedObserver(keys: ["A", "B"], observer)
 ```
 
 Also, we can do something particularly clever and basically register the Observer for every Key known to its own Dictionary:
 ```swift
-observable.addKeyedObserver(for: Array(observer.keyValues.keys), observer)
+observable.addKeyedObserver(keys: Array(observer.keyValues.keys), observer)
 ```
 The above would register `observer` with `observable` for every *key* contained in `observer`'s `keyValues` dictionary.
 
 Ultimately, you can register the `observer` with the `observable` for any keys you want:
 ```swift
-observable.addKeyedObserver(for: "Foo", observer)
+observable.addKeyedObserver(key: "Foo", observer)
 ```
 
 Let's output the initial values of all of our keys before we invoke any code that would modify their values:

Sources/Observable/Keyed/KeyedObservable.swift

@@ -9,120 +9,113 @@
 /**
  Describes any Type (Class or Thread) to which Observers can Subscribe.
  - Author: Simon J. Stuart
- - Version: 1.1.0
+ - Version: 2.0.0
  - Important: This Protocol can only be applied to Class and Thread types.
 
  See the Base Implementations `ObservableClass` and `ObservableThread`
  */
 @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
 public protocol KeyedObservable: Observable {
-    /**
-     Keyed Observables must declare a `TKey` type which must conform to `Hashable`
-     - Author: Simon J. Stuart
-     - Version: 1.1.0
-     */
-    associatedtype TKey: Hashable
-    
     /**
      Registers an Observer against this Observable Type for the given Key
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - key: The Key for which this Observer is subscribed
         - observer: A reference to a Class (or Thread) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this every time you need to register an Observer with your Observable.
     */
-    func addKeyedObserver<TObservationProtocol: AnyObject>(for key: TKey, _ observer: TObservationProtocol)
+    func addKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(key: TKey, _ observer: TObservationProtocol)
 
     /**
      Registers the Observers against this Observable Type for the given Key
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - key: The Key for which this Observer is subscribed
         - observers: A reference to a Classes (or Threads) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this every time you need to register an Observer with your Observable.
     */
-    func addKeyedObserver<TObservationProtocol: AnyObject>(for key: TKey, _ observers: [TObservationProtocol])
+    func addKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(key: TKey, _ observers: [TObservationProtocol])
 
     /**
      Registers an Observer against this Observable Type for the given Keys
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - keys: The Keys for which this Observer is subscribed
         - observer: A reference to a Class (or Thread) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this every time you need to register an Observer with your Observable.
     */
-    func addKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observer: TObservationProtocol)
+    func addKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observer: TObservationProtocol)
 
     /**
      Registers the given Observers against this Observable Type for the given Keys
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - keys: The Keys for which this Observer is subscribed
         - observers: A reference to a Classes (or Threads) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this every time you need to register an Observer with your Observable.
     */
-    func addKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observers: [TObservationProtocol])
+    func addKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observers: [TObservationProtocol])
 
     /**
      Removes an Observer from this Observable Type for the given Key
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - key: The Key for which this Observer was subscribed
         - observer: A reference to a Class (or Thread) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this if you need to explicitly unregister an Observer from your Observable.
     */
-    func removeKeyedObserver<TObservationProtocol: AnyObject>(for key: TKey, _ observer: TObservationProtocol)
+    func removeKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(key: TKey, _ observer: TObservationProtocol)
 
     /**
      Removes all given Observers from this Observable Type for the given Key
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - key: The Key for which this Observer was subscribed
         - observers: A reference to a Classes (or Threads) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this if you need to explicitly unregister an Observer from your Observable.
     */
-    func removeKeyedObserver<TObservationProtocol: AnyObject>(for key: TKey, _ observers: [TObservationProtocol])
+    func removeKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(key: TKey, _ observers: [TObservationProtocol])
 
     /**
      Removes an Observer from this Observable Type for the given Keys
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - keys: The Keys for which this Observer was subscribed
         - observer: A reference to a Class (or Thread) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this if you need to explicitly unregister an Observer from your Observable.
     */
-    func removeKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observer: TObservationProtocol)
+    func removeKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observer: TObservationProtocol)
 
     /**
      Removes an Observer from this Observable Type for the given Keys
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      - Parameters:
         - keys: The Keys for which this Observer was subscribed
         - observers: A reference to a Classes (or Threads) conforming to the desired Observer Protocol, inferred from Generics as `TObservationProtocol`
 
       Call this if you need to explicitly unregister an Observer from your Observable.
     */
-    func removeKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observers: [TObservationProtocol])
+    func removeKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observers: [TObservationProtocol])
 
     /**
      Iterates all of the registered Observers for this Observable and invokes against them your defined Closure Method for the given Key.
       - Author: Simon J. Stuart
-      - Version: 1.1.0
+      - Version: 2.0.0
       - Parameters:
         - key: The Key to which the Observation relates.
         - code: The Closure you wish to invoke for each Observer
@@ -140,12 +133,12 @@ public protocol KeyedObservable: Observable {
          }
          ````
      */
-    func withKeyedObservers<TObservationProtocol>(for key: TKey, _ code: @escaping (_ key: TKey, _ observer: TObservationProtocol) -> ())
+    func withKeyedObservers<TObservationProtocol, TKey: Hashable>(key: TKey, _ code: @escaping (_ key: TKey, _ observer: TObservationProtocol) -> ())
 
     /**
      Iterates all of the registered Observers for this Observable and invokes against them your defined Closure Method for the given Keys.
       - Author: Simon J. Stuart
-      - Version: 1.1.0
+      - Version: 2.0.0
       - Parameters:
         - keys: The Keys to which the Observation relates.
         - code: The Closure you wish to invoke for each Observer
@@ -163,93 +156,93 @@ public protocol KeyedObservable: Observable {
          }
          ````
      */
-    func withKeyedObservers<TObservationProtocol>(for keys: [TKey], _ code: @escaping (_ key: TKey, _ observer: TObservationProtocol) -> ())
+    func withKeyedObservers<TObservationProtocol, TKey: Hashable>(keys: [TKey], _ code: @escaping (_ key: TKey, _ observer: TObservationProtocol) -> ())
 }
 
 /**
  This extension just implements the simple Macros universally for any implementation of the `KeyedObserverable` protocol
  - Author: Simon J. Stuart
- - Version: 1.1.0
+ - Version: 2.0.0
  */
 extension KeyedObservable {
     /**
      Simply iterates multiple observers, and for each, invokes the `addKeyedObserver` implementation taking just that one observer.
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      */
-    public func addKeyedObserver<TObservationProtocol: AnyObject>(for key: TKey, _ observers: [TObservationProtocol]) {
+    public func addKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(key: TKey, _ observers: [TObservationProtocol]) {
         for observer in observers {
-            addKeyedObserver(for: key, observer)
+            addKeyedObserver(key: key, observer)
         }
     }
 
     /**
      Simply iterates multiple keys, and for each, invokes the `addKeyedObserver` implementation taking just that one key.
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      */
-    public func addKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observer: TObservationProtocol) {
+    public func addKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observer: TObservationProtocol) {
         for key in keys {
-            addKeyedObserver(for: key, observer)
+            addKeyedObserver(key: key, observer)
         }
     }
 
     /**
      Simply iterates multiple keys and observers, and for each, invokes the `addKeyedObserver` implementation taking just that one key and observer.
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      */
-    public func addKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observers: [TObservationProtocol]) {
+    public func addKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observers: [TObservationProtocol]) {
         for key in keys {
             for observer in observers {
-                addKeyedObserver(for: key, observer)
+                addKeyedObserver(key: key, observer)
             }
         }
     }
 
     /**
      Simply iterates multiple observers, and for each, invokes the `removeKeyedObserver` implementation taking just that one observer.
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      */
-    public func removeKeyedObserver<TObservationProtocol: AnyObject>(for key: TKey, _ observers: [TObservationProtocol]) {
+    public func removeKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(key: TKey, _ observers: [TObservationProtocol]) {
         for observer in observers {
-            removeKeyedObserver(for: key, observer)
+            removeKeyedObserver(key: key, observer)
         }
     }
 
     /**
      Simply iterates multiple keys, and for each, invokes the `removeKeyedObserver` implementation taking just that one key.
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      */
-    public func removeKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observer: TObservationProtocol) {
+    public func removeKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observer: TObservationProtocol) {
         for key in keys {
-            removeKeyedObserver(for: key, observer)
+            removeKeyedObserver(key: key, observer)
         }
     }
 
     /**
      Simply iterates multiple keys, and for each, invokes the `removeKeyedObserver` implementation taking just that one key and the one observer.
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      */
-    public func removeKeyedObserver<TObservationProtocol: AnyObject>(for keys: [TKey], _ observers: [TObservationProtocol]) {
+    public func removeKeyedObserver<TObservationProtocol: AnyObject, TKey: Hashable>(keys: [TKey], _ observers: [TObservationProtocol]) {
         for key in keys {
             for observer in observers {
-                removeKeyedObserver(for: key, observer)
+                removeKeyedObserver(key: key, observer)
             }
         }
     }
 
     /**
      Simply iterates multiple keys, and for each, invokes the `withKeyedObservers` implementation taking just that one key.
      - Author: Simon J. Stuart
-     - Version: 1.1.0
+     - Version: 2.0.0
      */
-    public func withKeyedObservers<TObservationProtocol>(for keys: [TKey], _ code: @escaping (_ key: TKey, _ observer: TObservationProtocol) -> ()) {
+    public func withKeyedObservers<TObservationProtocol, TKey: Hashable>(keys: [TKey], _ code: @escaping (_ key: TKey, _ observer: TObservationProtocol) -> ()) {
         for key in keys {
-            withKeyedObservers(for: key, code)
+            withKeyedObservers(key: key, code)
         }
     }
 }