impl map for non empty vec

Author: tomoikey

src/refined.rs

@@ -3,17 +3,15 @@ use crate::rule::Rule;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{Display, Formatter};
 use std::marker::PhantomData;
-use std::ops::Deref;
 
 /// Refined is a versatile type in ensuring that `T` satisfies the conditions of `RULE` (predicate type)
 /// # Example
 /// ```rust
-/// # use std::ops::Deref;
 /// use refined_type::rule::{NonEmptyString, NonEmptyStringRule};
 /// use refined_type::Refined;
 ///
 /// let non_empty_string_result = Refined::<NonEmptyStringRule>::new("Hello World".to_string());
-/// assert_eq!(non_empty_string_result.unwrap().deref(), "Hello World");
+/// assert_eq!(non_empty_string_result.unwrap().into_value(), "Hello World");
 ///
 /// let empty_string_result = Refined::<NonEmptyStringRule>::new("".to_string());
 /// assert!(empty_string_result.is_err())
@@ -76,17 +74,6 @@ where
     }
 }
 
-impl<RULE, T> Deref for Refined<RULE>
-where
-    RULE: Rule<Item = T>,
-{
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
 impl<RULE, T> Display for Refined<RULE>
 where
     RULE: Rule<Item = T>,

src/rule/empty.rs

@@ -4,8 +4,10 @@ use crate::Refined;
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::fmt::Debug;
+use std::iter::Map;
 use std::marker::PhantomData;
 use std::ops::Add;
+use std::vec::IntoIter;
 
 pub type Empty<T> = Refined<EmptyRule<T>>;
 
@@ -59,6 +61,37 @@ impl<T> EmptyDefinition for Vec<T> {
     }
 }
 
+impl<'a, T> EmptyDefinition for std::slice::Iter<'a, T> {
+    fn empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<T> EmptyDefinition for IntoIter<T> {
+    fn empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<F, B, I: ExactSizeIterator> EmptyDefinition for Map<I, F>
+where
+    F: FnMut(I::Item) -> B,
+{
+    fn empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+// impl<I, F> EmptyDefinition for std::iter::Map<I, F>
+// where
+//     Self: Sized,
+//     I: Iterator + EmptyDefinition,
+// {
+//     fn empty(&self) -> bool {
+//         true
+//     }
+// }
+
 impl<T> EmptyDefinition for HashSet<T> {
     fn empty(&self) -> bool {
         self.is_empty()

src/rule/non_empty/non_empty_vec.rs

@@ -1,10 +1,64 @@
-use crate::rule::NonEmptyRule;
+use crate::rule::{EmptyDefinition, NonEmptyRule};
 use crate::Refined;
+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>>>
+    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,
+    {
+        let a: B = FromIterator::from_iter(self.into_value());
+        Refined::new(a).ok().expect("")
+    }
+}
+
+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>
+where
+    T: EmptyDefinition,
+{
+    #[allow(clippy::should_implement_trait)]
+    pub fn into_iter(self) -> NonEmptyIntoIter<T> {
+        Refined::new(self.into_value().into_iter())
+            .ok()
+            .expect("This error is always unreachable")
+    }
+}
+
 impl<T> Add for NonEmptyVec<T> {
     type Output = Self;
 
@@ -38,4 +92,16 @@ mod test {
         assert_eq!(ne_vec.into_value(), vec![1, 2, 3, 4, 5, 6]);
         Ok(())
     }
+
+    #[test]
+    fn test_into_iter() -> anyhow::Result<()> {
+        let ne_vec = NonEmptyVec::new(vec![1, 2, 3])?;
+        let ne_vec = ne_vec
+            .into_iter()
+            .map(|n| n * 2)
+            .map(|n| n * 3)
+            .collect::<Vec<_>>();
+        assert_eq!(ne_vec.into_value(), vec![6, 12, 18]);
+        Ok(())
+    }
 }