     func nonEmptyTextOrThrow() throws -> String {
         if let text = self.text where text.characters.count > 0 {
             return text
-        } else { throw XMLDeserializationError.EmptyNodeValue }
+        } else { throw XMLDeserializationError.NodeHasNoValue }
     }
 }
 
 public enum XMLDeserializationError: ErrorType, CustomStringConvertible {
-    case InvalidNode(node: XMLIndexer)
-    case InvalidElement(element: XMLElement)
-    case TypeConversion(type: String, element: XMLElement)
-    case EmptyNodeValue
-    case MissingDeserializationMethod(method: String)
+    case ImplementationIsMissing(method: String)
+    case NodeIsInvalid(node: XMLIndexer)
+    case NodeHasNoValue
+    case TypeConversionFailed(type: String, element: XMLElement)
     
     public var description: String {
         switch self {
-        case .InvalidNode(let node):
-            return "Invalid node: \(node)"
-        case .InvalidElement(let element):
-            return "Invalid element: \(element)"
-        case .TypeConversion(let type, let node):
-            return "Can't convert \(node) to \(type)"
-        case .EmptyNodeValue:
-            return "Empty node value"
-        case .MissingDeserializationMethod(let method):
-            return "Missing deserialization method: \(method)"
+        case .ImplementationIsMissing(let method):
+            return "This deserialization method is not implemented: \(method)"
+        case .NodeIsInvalid(let node):
+            return "This node is invalid: \(node)"
+        case .NodeHasNoValue:
+            return "This node is empty"
+        case .TypeConversionFailed(let type, let node):
+            return "Can't convert node \(node) to value of type \(type)"
         }
     }
 }

        case .Element(let element):
            return try [element].map { try T.deserialize( XMLIndexer($0) ) }
        default:
            throw XMLDeserializationError.InvalidNode(node: self)
        }
    }
    

extension Double: XMLElementDeserializable {
    public static func deserialize(element: XMLElement) throws -> Double {
        guard let value = Double(try element.nonEmptyTextOrThrow())
        else { throw XMLDeserializationError.TypeConversionFailed(type: "Double", element: element) }
        return value
    }
}
