some progress

Author: ktoso

Package.swift

@@ -10,9 +10,9 @@ let package = Package(
                 "Baggage"
             ]
         ),
-        .library(name: "BaggageHolder",
+        .library(name: "BaggageLogging",
             targets: [
-                "BaggageHolder"
+                "BaggageLogging"
             ]
         ),
     ],
@@ -27,7 +27,7 @@ let package = Package(
         ),
 
         .target(
-            name: "BaggageHolder",
+            name: "BaggageLogging",
             dependencies: [
                 "Baggage",
                 .product(name: "Logging", package: "swift-log"),
@@ -42,10 +42,10 @@ let package = Package(
             ]
         ),
         .testTarget(
-            name: "BaggageHolderTests",
+            name: "BaggageLoggingTests",
             dependencies: [
                 "Baggage",
-                "BaggageHolder"
+                "BaggageLogging"
             ]
         )
     ]

Sources/Baggage/BaggageContext.swift

@@ -22,7 +22,7 @@
 /// Libraries may also want to provide an extension, offering the values that users are expected to reach for
 /// using the following pattern:
 ///
-///     extension BaggageContext {
+///     extension BaggageContextProtocol {
 ///       var testID: TestIDKey.Value {
 ///         get {
 ///           self[TestIDKey.self]
@@ -31,7 +31,7 @@
 ///         }
 ///       }
 ///     }
-public struct BaggageContext {
+public struct BaggageContext: BaggageContextProtocol {
     private var _storage = [AnyBaggageContextKey: ValueContainer]()
 
     /// Create an empty `BaggageContext`.
@@ -64,10 +64,34 @@ public struct BaggageContext {
 
 extension BaggageContext: CustomStringConvertible {
     public var description: String {
-        "\(Self.self)(keys: \(self._storage.map(\.key.name)))"
+        "\(Self.self)(keys: \(self._storage.map { $0.key.name }))"
     }
 }
 
+public protocol BaggageContextProtocol {
+    /// Provides type-safe access to the baggage's values.
+    ///
+    /// Rather than using this subscript directly, users are encouraged to offer a convenience accessor to their values,
+    /// using the following pattern:
+    ///
+    ///     extension BaggageContextProtocol {
+    ///       var testID: TestIDKey.Value {
+    ///         get {
+    ///           self[TestIDKey.self]
+    ///         } set {
+    ///           self[TestIDKey.self] = newValue
+    ///         }
+    ///       }
+    ///     }
+    subscript<Key: BaggageContextKey>(_ key: Key.Type) -> Key.Value? { get set }
+
+    /// Iterates over the baggage context's contents invoking the callback one-by one.
+    func forEach(_ callback: (AnyBaggageContextKey, Any) -> Void)
+}
+
+// ==== ------------------------------------------------------------------------
+// MARK: Baggage keys
+
 /// `BaggageContextKey`s are used as keys in a `BaggageContext`. Their associated type `Value` gurantees type-safety.
 /// To give your `BaggageContextKey` an explicit name you may override the `name` property.
 public protocol BaggageContextKey {
@@ -108,3 +132,36 @@ extension AnyBaggageContextKey: Hashable {
         hasher.combine(ObjectIdentifier(self.keyType))
     }
 }
+
+// ==== ----------------------------------------------------------------------------------------------------------------
+// MARK: Framework Context Protocols
+
+public protocol BaggageContextCarrier: BaggageContextProtocol {
+    var baggage: BaggageContext { get set }
+}
+
+extension BaggageContextCarrier {
+    public subscript<Key: BaggageContextKey>(baggageKey: Key.Type) -> Key.Value? {
+        get {
+            self.baggage[baggageKey]
+        } set {
+            self.baggage[baggageKey] = newValue
+        }
+    }
+
+    public func forEach(_ callback: (AnyBaggageContextKey, Any) -> Void) {
+        self.baggage.forEach(callback)
+    }
+}
+
+/// A baggage itself also is a carrier of "itself".
+extension BaggageContext: BaggageContextCarrier {
+    public var baggage: BaggageContext {
+        get {
+            self
+        }
+        set {
+            self = newValue
+        }
+    }
+}