             }
         }
     }
-
-    public static func custom(_ closure: @escaping Closure) -> ObjectEncoder.DoubleEncodingStrategy {
-        return .init(identifiers: identifiers, closure: closure)
-    }
-
-    private static let identifiers = [Double.self].map(ObjectIdentifier.init)
 }
 
 extension ObjectEncoder.EncodingStrategy where T == Float {

        var strategies = [ObjectIdentifier: Any]()
        public subscript<T>(type: T.Type) -> EncodingStrategy<T>? {
            get { return strategies[ObjectIdentifier(type)] as? EncodingStrategy<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? EncodingStrategy<T> {
                        strategy.identifiers.forEach { strategies[$0] = nil }
                    }
                    strategies[ObjectIdentifier(type)] = nil
                }
            }
        }
        public subscript<T>(types: [Any.Type]) -> EncodingStrategy<T>? {
            get { return types.first.map { strategies[ObjectIdentifier($0)] } as? EncodingStrategy<T> }
            set { types.forEach { strategies[ObjectIdentifier($0)] = newValue } }
        }
    }


    ///
    /// If the closure fails to encode a value into the given encoder,
    /// the encoder will encode an empty automatic container in its place.
    public static func custom(_ closure: @escaping Closure) -> ObjectEncoder.EncodingStrategy<T> {
        return .init(closure: closure)
    }
}

