refactoring

Author: tomoikey

src/rule/non_empty.rs

@@ -1,12 +1,14 @@
 mod non_empty_iter;
+mod non_empty_map;
 mod non_empty_string;
 mod non_empty_vec;
 
 use crate::rule::composer::Not;
-use crate::rule::EmptyRule;
+use crate::rule::{EmptyDefinition, EmptyRule};
 use crate::Refined;
 
 pub use non_empty_iter::*;
+pub use non_empty_map::*;
 pub use non_empty_string::*;
 pub use non_empty_vec::*;
 
@@ -25,3 +27,25 @@ pub type NonEmpty<T> = Refined<NonEmptyRule<T>>;
 /// assert!(NonEmptyRule::<u8>::validate(0).is_err());
 /// ```
 pub type NonEmptyRule<T> = Not<EmptyRule<T>>;
+
+impl<I: ExactSizeIterator + EmptyDefinition> NonEmpty<I> {
+    pub fn map<B, F>(self, f: F) -> NonEmptyMap<I, F>
+    where
+        Self: Sized,
+        F: FnMut(I::Item) -> B,
+    {
+        let map_into_iter = self.into_value().map(f);
+        Refined::new(map_into_iter)
+            .ok()
+            .expect("This error is always unreachable")
+    }
+
+    pub fn collect<B: FromIterator<I::Item> + EmptyDefinition>(self) -> NonEmpty<B>
+    where
+        Self: Sized,
+    {
+        Refined::new(FromIterator::from_iter(self.into_value()))
+            .ok()
+            .expect("This error is always unreachable")
+    }
+}

src/rule/non_empty/non_empty_map.rs

@@ -0,0 +1,6 @@
+use crate::rule::NonEmptyRule;
+use crate::Refined;
+use std::iter::Map;
+
+pub type NonEmptyMap<I, F> = Refined<NonEmptyMapRule<I, F>>;
+pub type NonEmptyMapRule<I, F> = NonEmptyRule<Map<I, F>>;

src/rule/non_empty/non_empty_vec.rs

@@ -1,32 +1,10 @@
 use crate::rule::{EmptyDefinition, NonEmptyIntoIter, NonEmptyRule};
 use crate::Refined;
 
-use std::iter::Map;
 use std::ops::Add;
 
-impl<I: ExactSizeIterator + EmptyDefinition> Refined<NonEmptyRule<I>> {
-    pub fn map<B, F>(self, f: F) -> Refined<NonEmptyRule<Map<I, F>>>
-    where
-        Self: Sized,
-        F: FnMut(I::Item) -> B,
-    {
-        let map_into_iter = self.into_value().map(f);
-        Refined::new(map_into_iter)
-            .ok()
-            .expect("This error is always unreachable")
-    }
-
-    pub fn collect<B: FromIterator<I::Item> + EmptyDefinition>(self) -> Refined<NonEmptyRule<B>>
-    where
-        Self: Sized,
-    {
-        Refined::new(FromIterator::from_iter(self.into_value()))
-            .ok()
-            .expect("This error is always unreachable")
-    }
-}
-
 pub type NonEmptyVec<T> = Refined<NonEmptyVecRule<T>>;
+pub type NonEmptyVecRule<T> = NonEmptyRule<Vec<T>>;
 
 impl<T> NonEmptyVec<T>
 where
@@ -52,8 +30,6 @@ impl<T> Add for NonEmptyVec<T> {
     }
 }
 
-pub type NonEmptyVecRule<T> = NonEmptyRule<Vec<T>>;
-
 #[cfg(test)]
 mod test {
     use crate::rule::non_empty::NonEmptyVecRule;