Use error feature

Cargo.toml

@@ -23,3 +23,4 @@ serde = { version = "1", features = ["derive"] }
 [features]
 default = []
 serde = ["dep:serde"]
+use_error = []

README.md

@@ -14,11 +14,10 @@ use non_empty_string::NonEmptyString;
 let s = "A string with a length".to_owned();
 assert!(NonEmptyString::new(s).is_ok());
 
-// But constructing it from a non-zero-length String results in an `Err`, where we get the `String` back that we passed in.
+// But constructing it from a zero-length String results in an `Err`.
 let empty = "".to_owned();
 let result = NonEmptyString::new(empty);
 assert!(result.is_err());
-assert_eq!(result.unwrap_err(), "".to_owned())
 
 ```
 

src/lib.rs

@@ -16,6 +16,20 @@ use std::fmt::Display;
 #[cfg(feature = "serde")]
 mod serde_support;
 
+#[cfg(feature = "use_error")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ErrorEmptyString;
+
+#[cfg(feature = "use_error")]
+impl Display for ErrorEmptyString {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Error: zero-value string")
+    }
+}
+
+#[cfg(feature = "use_error")]
+impl std::error::Error for ErrorEmptyString {}
+
 /// A simple String wrapper type, similar to NonZeroUsize and friends.
 /// Guarantees that the String contained inside is not of length 0.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
@@ -24,14 +38,26 @@ pub struct NonEmptyString(String);
 
 #[allow(clippy::len_without_is_empty)] // is_empty would always returns false so it seems a bit silly to have it.
 impl NonEmptyString {
-    /// Attempts to create a new NonEmptyString.
+    #[cfg(not(feature = "use_error"))]
+    // Attempts to create a new NonEmptyString.
     /// If the given `string` is empty, `Err` is returned, containing the original `String`, `Ok` otherwise.
     pub fn new(string: String) -> Result<NonEmptyString, String> {
         if string.is_empty() {
-            Err(string)
-        } else {
-            Ok(NonEmptyString(string))
+            return Err(string);
+        }
+
+        Ok(NonEmptyString(string))
+    }
+
+    #[cfg(feature = "use_error")]
+    /// Attempts to create a new NonEmptyString.
+    /// If the given `string` is empty, `Err` is returned, `Ok` otherwise.
+    pub fn new(string: String) -> Result<NonEmptyString, ErrorEmptyString> {
+        if string.is_empty() {
+            return Err(ErrorEmptyString);
         }
+
+        Ok(NonEmptyString(string))
     }
 
     /// Returns a reference to the contained value.
@@ -128,6 +154,7 @@ impl AsRef<String> for NonEmptyString {
     }
 }
 
+#[cfg(not(feature = "use_error"))]
 impl<'s> TryFrom<&'s str> for NonEmptyString {
     type Error = &'s str;
 
@@ -140,6 +167,7 @@ impl<'s> TryFrom<&'s str> for NonEmptyString {
     }
 }
 
+#[cfg(not(feature = "use_error"))]
 impl TryFrom<String> for NonEmptyString {
     type Error = String;
 
@@ -148,6 +176,28 @@ impl TryFrom<String> for NonEmptyString {
     }
 }
 
+#[cfg(feature = "use_error")]
+impl<'s> TryFrom<&'s str> for NonEmptyString {
+    type Error = ErrorEmptyString;
+
+    fn try_from(value: &'s str) -> Result<Self, Self::Error> {
+        if value.is_empty() {
+            return Err(ErrorEmptyString);
+        }
+
+        Ok(NonEmptyString(value.to_owned()))
+    }
+}
+
+#[cfg(feature = "use_error")]
+impl TryFrom<String> for NonEmptyString {
+    type Error = ErrorEmptyString;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        NonEmptyString::new(value)
+    }
+}
+
 impl Display for NonEmptyString {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Display::fmt(&self.0, f)
@@ -159,11 +209,25 @@ mod tests {
     use super::*;
 
     #[test]
+    #[cfg(not(feature = "use_error"))]
     fn empty_string_returns_err() {
         assert_eq!(NonEmptyString::new("".to_owned()), Err("".to_owned()));
     }
 
     #[test]
+    #[cfg(not(feature = "use_error"))]
+    fn non_empty_string_returns_ok() {
+        assert!(NonEmptyString::new("string".to_owned()).is_ok())
+    }
+
+    #[test]
+    #[cfg(feature = "use_error")]
+    fn empty_string_returns_err() {
+        assert_eq!(NonEmptyString::new("".to_owned()), Err(ErrorEmptyString));
+    }
+
+    #[test]
+    #[cfg(feature = "use_error")]
     fn non_empty_string_returns_ok() {
         assert!(NonEmptyString::new("string".to_owned()).is_ok())
     }

src/serde_support.rs

@@ -45,7 +45,8 @@ impl<'de> Visitor<'de> for NonEmptyStringVisitor {
     where
         E: de::Error,
     {
-        NonEmptyString::new(value).map_err(|e| de::Error::invalid_value(Unexpected::Str(&e), &self))
+        NonEmptyString::new(value)
+            .map_err(|_e| de::Error::invalid_value(Unexpected::Str(""), &self))
     }
 }