--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/error.rs	Sun Jan 29 13:53:45 2017 +0100
@@ -0,0 +1,87 @@
+use std::convert::From;
+use std::error::Error;
+use std::fmt::{self, Display, Formatter};
+use std::io;
+use std::result;
+
+#[derive(Clone, Debug)]
+#[allow(dead_code)]
+pub enum StatusCode {
+    OK,
+
+    AlreadyExists,
+    Corruption,
+    IOError,
+    InvalidArgument,
+    InvalidData,
+    NotFound,
+    NotSupported,
+    PermissionDenied,
+    Unknown,
+}
+
+#[derive(Clone, Debug)]
+pub struct Status {
+    code: StatusCode,
+    err: String,
+}
+
+impl Default for Status {
+    fn default() -> Status {
+        Status {
+            code: StatusCode::OK,
+            err: String::new(),
+        }
+    }
+}
+
+impl Display for Status {
+    fn fmt(&self, fmt: &mut Formatter) -> result::Result<(), fmt::Error> {
+        fmt.write_str(self.description())
+    }
+}
+
+impl Error for Status {
+    fn description(&self) -> &str {
+        &self.err
+    }
+}
+
+impl Status {
+    pub fn new(code: StatusCode, msg: &str) -> Status {
+        let err;
+        if msg.is_empty() {
+            err = format!("{:?}", code)
+        } else {
+            err = format!("{:?}: {}", code, msg);
+        }
+        return Status {
+            code: code,
+            err: err,
+        };
+    }
+}
+
+impl From<io::Error> for Status {
+    fn from(e: io::Error) -> Status {
+        let c = match e.kind() {
+            io::ErrorKind::NotFound => StatusCode::NotFound,
+            io::ErrorKind::InvalidData => StatusCode::Corruption,
+            io::ErrorKind::InvalidInput => StatusCode::InvalidArgument,
+            io::ErrorKind::PermissionDenied => StatusCode::PermissionDenied,
+            _ => StatusCode::IOError,
+        };
+
+        Status::new(c, e.description())
+    }
+}
+
+/// LevelDB's result type
+pub type Result<T> = result::Result<T, Status>;
+
+pub fn from_io_result<T>(e: io::Result<T>) -> Result<T> {
+    match e {
+        Ok(r) => result::Result::Ok(r),
+        Err(e) => Err(Status::from(e)),
+    }
+}

--- a/src/lib.rs	Sun Jan 29 13:13:34 2017 +0100
+++ b/src/lib.rs	Sun Jan 29 13:53:45 2017 +0100
@@ -11,6 +11,7 @@
 mod cmp;
 mod disk_env;
 mod env;
+mod error;
 mod filter;
 mod filter_block;
 mod key_types;

--- a/src/types.rs	Sun Jan 29 13:13:34 2017 +0100
+++ b/src/types.rs	Sun Jan 29 13:53:45 2017 +0100
@@ -1,10 +1,5 @@
 //! A collection of fundamental and/or simple types used by other modules
 
-use std::error::Error;
-use std::fmt::{self, Display, Formatter};
-use std::io;
-use std::result;
-
 #[derive(Debug, PartialOrd, PartialEq)]
 pub enum ValueType {
     TypeDeletion = 0,
@@ -16,61 +11,6 @@
 
 pub const MAX_SEQUENCE_NUMBER: SequenceNumber = (1 << 56) - 1;
 
-#[derive(Clone, Debug)]
-#[allow(dead_code)]
-pub enum Status {
-    OK,
-    NotFound(String),
-    Corruption(String),
-    NotSupported(String),
-    InvalidArgument(String),
-    PermissionDenied(String),
-    IOError(String),
-    Unknown(String),
-}
-
-impl Display for Status {
-    fn fmt(&self, fmt: &mut Formatter) -> result::Result<(), fmt::Error> {
-        fmt.write_str(self.description())
-    }
-}
-
-impl Error for Status {
-    fn description(&self) -> &str {
-        match *self {
-            Status::OK => "ok",
-            Status::NotFound(ref s) => s,
-            Status::Corruption(ref s) => s,
-            Status::NotSupported(ref s) => s,
-            Status::InvalidArgument(ref s) => s,
-            Status::PermissionDenied(ref s) => s,
-            Status::IOError(ref s) => s,
-            Status::Unknown(ref s) => s,
-        }
-    }
-}
-
-/// LevelDB's result type
-pub type Result<T> = result::Result<T, Status>;
-
-pub fn from_io_result<T>(e: io::Result<T>) -> Result<T> {
-    match e {
-        Ok(r) => result::Result::Ok(r),
-        Err(e) => {
-            let err = e.description().to_string();
-
-            let r = match e.kind() {
-                io::ErrorKind::NotFound => Err(Status::NotFound(err)),
-                io::ErrorKind::InvalidData => Err(Status::Corruption(err)),
-                io::ErrorKind::InvalidInput => Err(Status::InvalidArgument(err)),
-                io::ErrorKind::PermissionDenied => Err(Status::PermissionDenied(err)),
-                _ => Err(Status::IOError(err)),
-            };
-
-            r
-        }
-    }
-}
 
 /// Denotes a key range
 pub struct Range<'a> {