         switch self {
         case .v1(let x): return x.hashValue
         case .v2(let x): return x.hashValue
+        }
+    }
+}
+
+public extension OneOf2 {
+    /// Enables reading & writing multiple different keyPaths that lead to the same type
+    public subscript<T>(traversing keys: (kp1: WritableKeyPath<T1, T>, kp2: WritableKeyPath<T2, T>)) -> T {
+        get {
+            switch self {
+            case .v1(let x1): return x1[keyPath: keys.kp1]
+            case .v2(let x2): return x2[keyPath: keys.kp2]
+            }
+        }
+
+        set {
+            switch self {
+            case .v1(var x1): x1[keyPath: keys.kp1] = newValue; self = .init(x1)
+            case .v2(var x2): x2[keyPath: keys.kp2] = newValue; self = .init(x2)
+            }
         }
     }
 }

        case .v2(let x): return x.hashValue
        case .v3(let x): return x.hashValue
        case .v4(let x): return x.hashValue
        }
    }
}


extension OneOf2 : ExpressibleByNilLiteral where T2 == ExplicitNull {
    public init(nilLiteral: ()) { self = .v2(nil) }
}

public extension OneOf2Type where T2 == ExplicitNull /* i.e., Nullable */ {
    public var isExplicitNull: Bool { return self.v2 == ExplicitNull.null }
}

/// An Object Bric type that cannot contain anything
