     fileprivate let stringProperty: String
     
     fileprivate static func fromMap(_ value: Any?) throws -> ConvertibleObject {
-        return ConvertibleObject(stringProperty: value as! String)
+        guard let string = value as? String else {
+            throw ConvertibleError(value: value, type: String.self)
+        }
+        
+        return ConvertibleObject(stringProperty: string)
     }
 }
 

                }
            }
        }
    }
}

class KeyedMapper_ConvertibleSpec: QuickSpec {
    override func spec() {
        describe("from<T: Convertible> -> T") {
            context("when the fromMap implementation throws an error") {
                it("should throw an error") {
                    let expectedValue = 2
                    let dict: NSDictionary = ["convertibleProperty" : expectedValue]
                    let mapper = KeyedMapper<Model>(JSON: dict, type: Model.self)
                    
                    do {
                        let _: ConvertibleObject = try mapper.from(.convertibleProperty)
                    } catch let error as ConvertibleError {
                        expect(error) == ConvertibleError(value: expectedValue, type: String.self)
                    } catch {
                        XCTFail("Error thrown from from<T: Convertible> -> T was not a ConvertibleError")
                    }
                }
            }
            
            context("when the fromMap implementation does not throw an error") {
                it("should correctly map") {
                    let dict: NSDictionary = ["convertibleProperty" : ""]
                    let mapper = KeyedMapper<Model>(JSON: dict, type: Model.self)
                    let convertibleThing: ConvertibleObject = try! mapper.from(.convertibleProperty)
                    
                    expect(convertibleThing).toNot(beNil())
                }
            }
        }
        
