vec dequeを実装

Author: tomoikey

README.md

@@ -241,6 +241,26 @@ fn main() -> anyhow::Result<()> {
     Ok(())
 }
 ```
+# Iterator
+### IntoIter
+```rust
+fn main() -> anyhow::Result<()> {
+    let ne_vec = NonEmptyVec::new(vec![1, 2, 3])?;
+    let ne_vec: NonEmptyVec<i32> = ne_vec.into_iter().map(|n| n * 2).map(|n| n * 3).collect();
+    assert_eq!(ne_vec.into_value(), vec![6, 12, 18]);
+    Ok(())
+}
+```
+
+### Iter
+```rust
+fn main() -> anyhow::Result<()> {
+    let ne_vec = NonEmptyVec::new(vec![1, 2, 3])?;
+    let ne_vec: NonEmptyVec<i32> = ne_vec.iter().map(|n| n * 2).map(|n| n * 3).collect();
+    assert_eq!(ne_vec.into_value(), vec![6, 12, 18]);
+    Ok(())
+}
+```
 
 # 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.
@@ -258,8 +278,7 @@ fn main() -> anyhow::Result<()> {
 
 ### NonEmptyVec
 ```rust
-#[test]
-fn test_add_vec() -> anyhow::Result<()> {
+fn main() -> 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
@@ -271,7 +290,7 @@ fn test_add_vec() -> anyhow::Result<()> {
 
 ### Empty
 ```rust
-fn test_add_empty() -> anyhow::Result<()> {
+fn main() -> 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

src/rule/empty.rs

@@ -2,12 +2,11 @@ use crate::result::Error;
 use crate::rule::Rule;
 use crate::Refined;
 
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
 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>>;
 
@@ -61,13 +60,31 @@ impl<T> EmptyDefinition for Vec<T> {
     }
 }
 
+impl<T> EmptyDefinition for std::vec::IntoIter<T> {
+    fn empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
 impl<'a, T> EmptyDefinition for std::slice::Iter<'a, T> {
     fn empty(&self) -> bool {
         self.len() == 0
     }
 }
 
-impl<T> EmptyDefinition for IntoIter<T> {
+impl<T> EmptyDefinition for VecDeque<T> {
+    fn empty(&self) -> bool {
+        self.is_empty()
+    }
+}
+
+impl<T> EmptyDefinition for std::collections::vec_deque::IntoIter<T> {
+    fn empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<'a, T> EmptyDefinition for std::collections::vec_deque::Iter<'a, T> {
     fn empty(&self) -> bool {
         self.len() == 0
     }
@@ -82,16 +99,6 @@ where
     }
 }
 
-// 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.rs

@@ -1,13 +1,12 @@
-mod non_empty_iter;
 mod non_empty_map;
 mod non_empty_string;
 mod non_empty_vec;
+mod non_empty_vec_deque;
 
 use crate::rule::composer::Not;
 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::*;

src/rule/non_empty/non_empty_iter.rs

@@ -1,4 +1,4 @@
-use crate::rule::{EmptyDefinition, NonEmptyIntoIter, NonEmptyIter, NonEmptyRule};
+use crate::rule::{EmptyDefinition, NonEmpty, NonEmptyRule};
 use crate::Refined;
 
 use std::ops::Add;
@@ -11,14 +11,14 @@ where
     T: EmptyDefinition,
 {
     #[allow(clippy::should_implement_trait)]
-    pub fn into_iter(self) -> NonEmptyIntoIter<T> {
+    pub fn into_iter(self) -> NonEmpty<std::vec::IntoIter<T>> {
         Refined::new(self.into_value().into_iter())
             .ok()
             .expect("This error is always unreachable")
     }
 
     #[allow(clippy::should_implement_trait)]
-    pub fn iter(&self) -> NonEmptyIter<T> {
+    pub fn iter(&self) -> NonEmpty<std::slice::Iter<T>> {
         Refined::new(self.value().iter())
             .ok()
             .expect("This error is always unreachable")

src/rule/non_empty/non_empty_vec.rs

@@ -0,0 +1,38 @@
+use crate::rule::{EmptyDefinition, NonEmpty, NonEmptyRule};
+use crate::Refined;
+use std::collections::VecDeque;
+use std::ops::Add;
+
+pub type NonEmptyVecDeque<T> = Refined<NonEmptyVecDequeRule<T>>;
+pub type NonEmptyVecDequeRule<T> = NonEmptyRule<VecDeque<T>>;
+
+impl<T> NonEmptyVecDeque<T>
+where
+    T: EmptyDefinition,
+{
+    #[allow(clippy::should_implement_trait)]
+    pub fn into_iter(self) -> NonEmpty<std::collections::vec_deque::IntoIter<T>> {
+        Refined::new(self.into_value().into_iter())
+            .ok()
+            .expect("This error is always unreachable")
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    pub fn iter(&self) -> NonEmpty<std::collections::vec_deque::Iter<T>> {
+        Refined::new(self.value().iter())
+            .ok()
+            .expect("This error is always unreachable")
+    }
+}
+
+impl<T> Add for NonEmptyVecDeque<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")
+    }
+}