refactoring

Author: tomoikey

src/rule/non_empty.rs

@@ -1,10 +1,12 @@
+mod non_empty_iter;
 mod non_empty_string;
 mod non_empty_vec;
 
 use crate::rule::composer::Not;
 use crate::rule::EmptyRule;
 use crate::Refined;
 
+pub use non_empty_iter::*;
 pub use non_empty_string::*;
 pub use non_empty_vec::*;
 

src/rule/non_empty/non_empty_iter.rs

@@ -0,0 +1,6 @@
+use crate::rule::NonEmptyRule;
+use crate::Refined;
+use std::vec::IntoIter;
+
+pub type NonEmptyIntoIter<T> = Refined<NonEmptyIntoIterRule<T>>;
+pub type NonEmptyIntoIterRule<T> = NonEmptyRule<IntoIter<T>>;

src/rule/non_empty/non_empty_vec.rs

@@ -1,9 +1,8 @@
-use crate::rule::{EmptyDefinition, NonEmptyRule};
+use crate::rule::{EmptyDefinition, NonEmptyIntoIter, NonEmptyRule};
 use crate::Refined;
-use std::iter::Map;
 
+use std::iter::Map;
 use std::ops::Add;
-use std::vec::IntoIter;
 
 impl<I: ExactSizeIterator + EmptyDefinition> Refined<NonEmptyRule<I>> {
     pub fn map<B, F>(self, f: F) -> Refined<NonEmptyRule<Map<I, F>>>
@@ -21,30 +20,12 @@ impl<I: ExactSizeIterator + EmptyDefinition> Refined<NonEmptyRule<I>> {
     where
         Self: Sized,
     {
-        let a: B = FromIterator::from_iter(self.into_value());
-        Refined::new(a).ok().expect("")
+        Refined::new(FromIterator::from_iter(self.into_value()))
+            .ok()
+            .expect("This error is always unreachable")
     }
 }
 
-pub type NonEmptyIntoIter<T> = Refined<NonEmptyIntoIterRule<T>>;
-pub type NonEmptyIntoIterRule<T> = NonEmptyRule<IntoIter<T>>;
-
-pub type NonEmptyMap<I, F> = Refined<NonEmptyMapRule<I, F>>;
-pub type NonEmptyMapRule<I, F> = NonEmptyRule<Map<I, F>>;
-
-// impl<T> NonEmptyIntoIter<T> {
-//     pub fn map<B, F>(self, f: F) -> Refined<NonEmptyRule<Map<IntoIter<T>, F>>>
-//     where
-//         Self: Sized,
-//         F: FnMut(T) -> B,
-//     {
-//         let map_into_iter = self.into_value().map(f);
-//         Refined::new(map_into_iter)
-//             .ok()
-//             .expect("This error is always unreachable")
-//     }
-// }
-
 pub type NonEmptyVec<T> = Refined<NonEmptyVecRule<T>>;
 
 impl<T> NonEmptyVec<T>