impl Add for NonEmptyString

Author: tomoikey

src/rule/empty.rs

@@ -19,7 +19,7 @@ where
         // `T` implements `EmptyDefinition`. Therefore, this `expect` is safe.
         Refined::new(self.into_value().empty())
             .ok()
-            .expect("unreachable")
+            .expect("This error is always unreachable")
     }
 }
 

src/rule/non_empty.rs

@@ -3,20 +3,23 @@ mod non_empty_vec;
 
 use crate::rule::composer::Not;
 use crate::rule::EmptyRule;
+use crate::Refined;
 
 pub use non_empty_string::*;
 pub use non_empty_vec::*;
 
+pub type NonEmpty<T> = Refined<NonEmptyRule<T>>;
+
 /// Rule where the data is non-empty
 /// ```rust
-/// use refined_type::rule::{NonEmpty, Rule};
-/// assert!(NonEmpty::<String>::validate("non empty".to_string()).is_ok());
-/// assert!(NonEmpty::<String>::validate("".to_string()).is_err());
+/// use refined_type::rule::{NonEmptyRule, Rule};
+/// assert!(NonEmptyRule::<String>::validate("non empty".to_string()).is_ok());
+/// assert!(NonEmptyRule::<String>::validate("".to_string()).is_err());
 ///
-/// assert!(NonEmpty::<Vec<u8>>::validate(vec![1, 2, 3]).is_ok());
-/// assert!(NonEmpty::<Vec<u8>>::validate(Vec::new()).is_err());
+/// assert!(NonEmptyRule::<Vec<u8>>::validate(vec![1, 2, 3]).is_ok());
+/// assert!(NonEmptyRule::<Vec<u8>>::validate(Vec::new()).is_err());
 ///
-/// assert!(NonEmpty::<u8>::validate(1).is_ok());
-/// assert!(NonEmpty::<u8>::validate(0).is_err());
+/// assert!(NonEmptyRule::<u8>::validate(1).is_ok());
+/// assert!(NonEmptyRule::<u8>::validate(0).is_err());
 /// ```
-pub type NonEmpty<T> = Not<EmptyRule<T>>;
+pub type NonEmptyRule<T> = Not<EmptyRule<T>>;

src/rule/non_empty/non_empty_string.rs

@@ -1,18 +1,38 @@
 use crate::refined::Refined;
-use crate::rule::NonEmpty;
+use crate::rule::NonEmptyRule;
+use std::ops::Add;
 
 /// This is a predicate type representing a non-empty string
 pub type NonEmptyString = Refined<NonEmptyStringRule>;
 
-pub type NonEmptyStringRule = NonEmpty<String>;
+impl Add for NonEmptyString {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Refined::new(format!("{}{}", self.into_value(), rhs.into_value()))
+            .expect("This error is always unreachable")
+    }
+}
+
+pub type NonEmptyStringRule = NonEmptyRule<String>;
 
 #[cfg(test)]
 mod test {
-    use crate::rule::{NonEmptyStringRule, Rule};
+    use crate::rule::{NonEmptyString, NonEmptyStringRule, Rule};
 
     #[test]
     fn test_non_empty_string() {
         assert!(NonEmptyStringRule::validate("hello".to_string()).is_ok());
         assert!(NonEmptyStringRule::validate("".to_string()).is_err());
     }
+
+    #[test]
+    fn test_add_string() -> anyhow::Result<()> {
+        let non_empty_string_1 = NonEmptyString::new("Hello".to_string())?;
+        let non_empty_string_2 = NonEmptyString::new("World".to_string())?;
+        let non_empty_string = non_empty_string_1 + non_empty_string_2;
+
+        assert_eq!(non_empty_string.into_value(), "HelloWorld");
+        Ok(())
+    }
 }

src/rule/non_empty/non_empty_vec.rs

@@ -1,8 +1,8 @@
-use crate::rule::NonEmpty;
+use crate::rule::NonEmptyRule;
 use crate::Refined;
 
 pub type NonEmptyVec<T> = Refined<NonEmptyVecRule<T>>;
-pub type NonEmptyVecRule<T> = NonEmpty<Vec<T>>;
+pub type NonEmptyVecRule<T> = NonEmptyRule<Vec<T>>;
 
 #[cfg(test)]
 mod test {