 
 extension ObjectDecoder.DecodingStrategy {
     /// Decode the `T` as a custom value decoded by the given closure.
-    public static func custom(_ types: [Any.Type] = [T.self],
-                              _ closure: @escaping Closure) -> ObjectDecoder.DecodingStrategy<T> {
-        return .init(identifiers: types.map(ObjectIdentifier.init), closure: closure)
+    public static func custom(_ closure: @escaping Closure) -> ObjectDecoder.DecodingStrategy<T> {
+        return .init(closure: closure)
     }
 }
 

        var strategies = [ObjectIdentifier: Any]()
        public subscript<T>(type: T.Type) -> DecodingStrategy<T>? {
            get { return strategies[ObjectIdentifier(type)] as? DecodingStrategy<T> }
            set {
                if let newValue = newValue {
                    precondition(newValue.identifiers.contains(ObjectIdentifier(type)))
                    newValue.identifiers.forEach { strategies[$0] = newValue }
                } else {
                    if let strategy = strategies[ObjectIdentifier(type)] as? DecodingStrategy<T> {
                        strategy.identifiers.forEach { strategies[$0] = nil }
                    }
                    strategies[ObjectIdentifier(type)] = nil
                }
            }
        }
        public subscript<T>(types: [Any.Type]) -> DecodingStrategy<T>? {
            get { return types.first.map { strategies[ObjectIdentifier($0)] } as? DecodingStrategy<T> }
            set { types.forEach { strategies[ObjectIdentifier($0)] = newValue } }
        }
    }


            return Decimal(try Double(from: decoder))
        }
    }
}

extension ObjectDecoder.DecodingStrategy where T == Double {
