Merge pull request #11 from tomoikey/impl_add_trait

Impl add trait

Author: tomoikey

Cargo.toml

@@ -6,7 +6,7 @@ repository = "https://github.com/tomoikey/refined-type"
 readme = "README.md"
 categories = ["development-tools"]
 license = "MIT"
-version = "0.3.7"
+version = "0.4.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

README.md

@@ -224,7 +224,7 @@ struct Human {
     age: u8,
 }
 
-fn test_refined_deserialize_json_ok_struct() -> anyhow::Result<()> {
+fn main() -> anyhow::Result<()> {
     let json = json! {{
         "name": "john",
         "age": 8
@@ -242,6 +242,45 @@ fn test_refined_deserialize_json_ok_struct() -> anyhow::Result<()> {
 }
 ```
 
+# Add Trait
+I have implemented the `Add` trait for a part of the `Refined` that I provided. Therefore, operations can be performed without downgrading the type level.
+### NonEmptyString
+```rust
+fn main() -> 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; // This is also `NonEmptyString` type
+
+    assert_eq!(non_empty_string.into_value(), "HelloWorld");
+    Ok(())
+}
+```
+
+### NonEmptyVec
+```rust
+#[test]
+fn test_add_vec() -> anyhow::Result<()> {
+    let ne_vec_1 = NonEmptyVec::new(vec![1, 2, 3])?;
+    let ne_vec_2 = NonEmptyVec::new(vec![4, 5, 6])?;
+    let ne_vec = ne_vec_1 + ne_vec_2; // This is also `NonEmptyVec` type
+
+    assert_eq!(ne_vec.into_value(), vec![1, 2, 3, 4, 5, 6]);
+    Ok(())
+}
+```
+
+### Empty
+```rust
+fn test_add_empty() -> anyhow::Result<()> {
+    let empty_1 = Empty::new(0)?;
+    let empty_2 = Empty::new(0)?;
+    let empty = empty_1 + empty_2; // This is also `Empty` type
+
+    assert_eq!(empty.into_value(), 0);
+    Ok(())
+}
+```
+
 # Tips
 Directly writing `And`, `Or`, `Not` or `Refined` can often lead to a decrease in readability. 
 Therefore, using **type aliases** can help make your code clearer.

src/rule/composer/not.rs

@@ -6,9 +6,9 @@ use std::marker::PhantomData;
 /// # Example
 /// ```rust
 /// use refined_type::rule::composer::Not;
-/// use refined_type::rule::{Empty, Rule};
+/// use refined_type::rule::{EmptyRule, Rule};
 ///
-/// type NonEmptyString = Not<Empty<String>>;
+/// type NonEmptyString = Not<EmptyRule<String>>;
 ///
 /// assert!(NonEmptyString::validate("non empty".to_string()).is_ok());
 /// assert!(NonEmptyString::validate("".to_string()).is_err());

src/rule/composer/or.rs

@@ -6,9 +6,9 @@ use std::marker::PhantomData;
 /// # Example
 /// ```rust
 /// use refined_type::rule::composer::Or;
-/// use refined_type::rule::{AlphabetRule, Empty, Rule};
+/// use refined_type::rule::{AlphabetRule, EmptyRule, Rule};
 ///
-/// type EmptyOrAlphabetString = Or<Empty<String>, AlphabetRule>;
+/// type EmptyOrAlphabetString = Or<EmptyRule<String>, AlphabetRule>;
 ///
 /// assert!(EmptyOrAlphabetString::validate("".to_string()).is_ok());
 /// assert!(EmptyOrAlphabetString::validate("alphabet".to_string()).is_ok());

src/rule/empty.rs

@@ -1,26 +1,42 @@
 use crate::result::Error;
 use crate::rule::Rule;
+use crate::Refined;
+
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::fmt::Debug;
 use std::marker::PhantomData;
+use std::ops::Add;
+
+pub type Empty<T> = Refined<EmptyRule<T>>;
+
+impl<T> Add for Empty<T>
+where
+    T: EmptyDefinition,
+{
+    type Output = Self;
+
+    fn add(self, _rhs: Self) -> Self::Output {
+        self
+    }
+}
 
 /// Rule where the data is empty
 /// ```rust
-/// use refined_type::rule::{Empty, Rule};
+/// use refined_type::rule::{EmptyRule, Rule};
 ///
-/// assert!(Empty::<String>::validate("".to_string()).is_ok());
-/// assert!(Empty::<String>::validate("non empty".to_string()).is_err());
+/// assert!(EmptyRule::<String>::validate("".to_string()).is_ok());
+/// assert!(EmptyRule::<String>::validate("non empty".to_string()).is_err());
 ///
-/// assert!(Empty::<Vec<u8>>::validate(Vec::<u8>::new()).is_ok());
-/// assert!(Empty::<Vec<u8>>::validate(vec![1, 2, 3]).is_err());
+/// assert!(EmptyRule::<Vec<u8>>::validate(Vec::<u8>::new()).is_ok());
+/// assert!(EmptyRule::<Vec<u8>>::validate(vec![1, 2, 3]).is_err());
 ///
-/// assert!(Empty::<u8>::validate(0).is_ok());
-/// assert!(Empty::<u8>::validate(1).is_err());
+/// assert!(EmptyRule::<u8>::validate(0).is_ok());
+/// assert!(EmptyRule::<u8>::validate(1).is_err());
 /// ```
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
-pub struct Empty<T> {
+pub struct EmptyRule<T> {
     _phantom_data: PhantomData<T>,
 }
-
 pub trait EmptyDefinition {
     fn empty(&self) -> bool;
 }
@@ -151,7 +167,7 @@ impl EmptyDefinition for f64 {
     }
 }
 
-impl<T> Rule for Empty<T>
+impl<T> Rule for EmptyRule<T>
 where
     T: EmptyDefinition,
 {
@@ -165,3 +181,17 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::rule::Empty;
+
+    #[test]
+    fn test_add_empty() -> anyhow::Result<()> {
+        let empty_1 = Empty::new(0)?;
+        let empty_2 = Empty::new(0)?;
+        let empty = empty_1 + empty_2;
+        assert_eq!(empty.into_value(), 0);
+        Ok(())
+    }
+}

src/rule/non_empty.rs

@@ -2,20 +2,24 @@ mod non_empty_string;
 mod non_empty_vec;
 
 use crate::rule::composer::Not;
-use crate::rule::Empty;
+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<Empty<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,17 +1,41 @@
-use crate::rule::NonEmpty;
+use crate::rule::NonEmptyRule;
 use crate::Refined;
 
+use std::ops::Add;
+
 pub type NonEmptyVec<T> = Refined<NonEmptyVecRule<T>>;
-pub type NonEmptyVecRule<T> = NonEmpty<Vec<T>>;
+
+impl<T> Add for NonEmptyVec<T> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        let mut result = self.into_value();
+        result.append(&mut rhs.into_value());
+        Refined::new(result)
+            .ok()
+            .expect("This error is always unreachable")
+    }
+}
+
+pub type NonEmptyVecRule<T> = NonEmptyRule<Vec<T>>;
 
 #[cfg(test)]
 mod test {
     use crate::rule::non_empty::NonEmptyVecRule;
-    use crate::rule::Rule;
+    use crate::rule::{NonEmptyVec, Rule};
 
     #[test]
     fn test_non_empty_vec() {
         assert!(NonEmptyVecRule::validate(vec![1, 2, 3]).is_ok());
         assert!(NonEmptyVecRule::<u8>::validate(vec![]).is_err());
     }
+
+    #[test]
+    fn test_add_vec() -> anyhow::Result<()> {
+        let ne_vec_1 = NonEmptyVec::new(vec![1, 2, 3])?;
+        let ne_vec_2 = NonEmptyVec::new(vec![4, 5, 6])?;
+        let ne_vec = ne_vec_1 + ne_vec_2;
+        assert_eq!(ne_vec.into_value(), vec![1, 2, 3, 4, 5, 6]);
+        Ok(())
+    }
 }