add into_value

Author: tomoikey

src/refined.rs

@@ -71,7 +71,7 @@ where
 mod test {
     use crate::refined::Refined;
     use crate::result::Error;
-    use crate::rule::NonEmptyStringRule;
+    use crate::rule::{ClosedAlgebraic, NonEmptyStringRule};
 
     #[test]
     fn test_refined_non_empty_string_ok() -> Result<(), Error<String>> {
@@ -93,4 +93,14 @@ mod test {
         assert_eq!(format!("{}", non_empty_string), "Hello");
         Ok(())
     }
+
+    #[test]
+    fn test_refined_plus_non_empty_string() -> Result<(), Error<String>> {
+        let non_empty_string_1 = Refined::<NonEmptyStringRule>::new("Hello".to_string())?;
+        let non_empty_string_2 = Refined::<NonEmptyStringRule>::new("World".to_string())?;
+        let nonempty_string = non_empty_string_1.plus(non_empty_string_2);
+
+        assert_eq!(nonempty_string.into_value(), "HelloWorld");
+        Ok(())
+    }
 }

src/rule.rs

@@ -1,9 +1,11 @@
+mod closed_algebraic;
 pub mod composer;
 mod empty;
 mod non_empty;
 mod string;
 
 use crate::result::Error;
+pub use closed_algebraic::ClosedAlgebraic;
 pub use empty::*;
 pub use non_empty::*;
 pub use string::*;

src/rule/closed_algebraic.rs

@@ -0,0 +1,3 @@
+pub trait ClosedAlgebraic {
+    fn plus(self, that: Self) -> Self;
+}

src/rule/non_empty/non_empty_string.rs

@@ -1,11 +1,20 @@
 use crate::refined::Refined;
+use crate::rule::closed_algebraic::ClosedAlgebraic;
 use crate::rule::NonEmpty;
 
 /// This is a predicate type representing a non-empty string
 pub type NonEmptyString = Refined<NonEmptyStringRule>;
 
 pub type NonEmptyStringRule = NonEmpty<String>;
 
+/// # Math Theory
+/// NonEmpty + NonEmpty = NonEmpty
+impl ClosedAlgebraic for NonEmptyString {
+    fn plus(self, that: NonEmptyString) -> NonEmptyString {
+        Refined::new(format!("{}{}", self.into_value(), that.into_value())).unwrap()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate::rule::{NonEmptyStringRule, Rule};

src/rule/non_empty/non_empty_vec.rs

@@ -1,9 +1,24 @@
+use crate::rule::closed_algebraic::ClosedAlgebraic;
 use crate::rule::NonEmpty;
 use crate::Refined;
+use std::fmt::Debug;
 
 pub type NonEmptyVec<T> = Refined<NonEmptyVecRule<T>>;
 pub type NonEmptyVecRule<T> = NonEmpty<Vec<T>>;
 
+/// # Math Theory
+/// NonEmptyVec + NonEmptyVec = NonEmptyVec
+impl<T> ClosedAlgebraic for NonEmptyVec<T>
+where
+    T: Debug,
+{
+    fn plus(self, that: NonEmptyVec<T>) -> NonEmptyVec<T> {
+        let mut result = self.into_value();
+        result.append(&mut that.into_value());
+        Refined::new(result).unwrap()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate::rule::non_empty::NonEmptyVecRule;