         case .nothing:
             return nil
         }
-    }
-    
-    func decode<P: Primitive>(asType type: P.Type, path: [String]) throws -> P {
-        guard
-            case .primitive(_, let p) = self,
-            let primitive = p as? P
-        else {
-            throw BSONValueNotFound(type: P.self, path: path)
-        }
-        
-        return primitive
     }
     
     func unwrap<P: Primitive, K: CodingKey>(asType type: P.Type, atKey key: K, path: [String]) throws -> P {

        }
    }
    
    public enum IntegerDecodingStrategy<I: Integer> {
        case string
        case int32
        case int64
        case anyInteger
        case roundingAnyNumber
        case custom(DecodingStrategy<I>)
    }
    
    public enum DoubleDecodingStrategy {

        fileprivate func decode(from value: DecoderValue, path: [String]) throws -> Float {
            switch self {
            case .double:
                let double = try value.unwrap(asType: Double.self, path: path)
                return Float(double)
            case .string:
                let string = try value.unwrap(asType: String.self, path: path)
                
                guard let float = Float(string) else {
                    throw BSONValueNotFound(type: Float.self, path: path)
