 fileprivate struct Model: Mappable {
     fileprivate enum Key: String, JSONKey {
         case convertibleProperty
-        case convertibleArrayProperty
-        case convertibleDictionaryProperty
-    }
-    
+    }
+
     fileprivate let convertibleProperty: ConvertibleObject
-    fileprivate let convertibleArrayProperty: [ConvertibleObject]
-    fileprivate let convertibleDictionaryProperty: [ConvertibleObject : [ConvertibleObject]]
-    
+
     fileprivate init(map: KeyedMapper<Model>) throws {
         try self.convertibleProperty = map.from(.convertibleProperty)
+    }
+}
+
+fileprivate struct ModelWithArrayProperty: Mappable {
+    fileprivate enum Key: String, JSONKey {
+        case convertibleArrayProperty
+    }
+
+    fileprivate let convertibleArrayProperty: [ConvertibleObject]
+
+    fileprivate init(map: KeyedMapper<ModelWithArrayProperty>) throws {
         try self.convertibleArrayProperty = map.from(.convertibleArrayProperty)
+    }
+}
+
+fileprivate struct ModelWithDictionaryProperty: Mappable {
+    fileprivate enum Key: String, JSONKey {
+        case convertibleDictionaryProperty
+    }
+
+    fileprivate let convertibleDictionaryProperty: [ConvertibleObject : [ConvertibleObject]]
+
+    fileprivate init(map: KeyedMapper<ModelWithDictionaryProperty>) throws {
         try self.convertibleDictionaryProperty = map.from(.convertibleDictionaryProperty)
     }
 }

                it("should map correctly") {
                    let expectedValue = [""]
                    let dict: NSDictionary = ["convertibleArrayProperty" : expectedValue]
                    let mapper = KeyedMapper(JSON: dict, type: Model.self)
                    let convertibleArray: [ConvertibleObject]? = mapper.optionalFrom(.convertibleArrayProperty)
                    
                    expect(convertibleArray).toNot(beNil())

                it("should throw a typeMismatch error") {
                    let value: NSDictionary = [:]
                    let dict: NSDictionary = ["convertibleArrayProperty" : value]
                    let mapper = KeyedMapper(JSON: dict, type: ModelWithArrayProperty.self)
                    let field = ModelWithArrayProperty.Key.convertibleArrayProperty
                    
                    do {
                        let _: [ConvertibleObject] = try mapper.from(field)
                    } catch let error as MapperError {
                        expect(error) == MapperError.typeMismatch(field: field.stringValue, forType: ModelWithArrayProperty.self, value: value, expectedType: [Any].self)
                    } catch {
                        XCTFail("Error thrown from from<T: Convertible> -> [T] was not a MapperError")
                    }
