updated shuflr example, added negiter and stackoll examples

Author: BartMassey

README.md

@@ -31,4 +31,6 @@ in a controlled repository now.
 * `deref.rs`: deref trait example
 * `from.rs`: from / try_from trait example
 * `prog.rs`, `prog2.rs`: state machine examples using closures
-* `shuflr/`: iterator implementation example
+* `negiter/`: example iterator adapter
+* `stackcoll/`: example fromiterator implementation
+* `shuflr/`: example iterator implementation

clean.sh

@@ -5,5 +5,5 @@ do
 done
 for i in */Cargo.toml
 do
-    ( cd `dirname $i` && cargo clean -q )
+    ( cd `dirname $i` && cargo clean -q && rm -rf .git )
 done

negiter/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "negiter"
+version = "0.1.0"
+authors = ["Bart Massey <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+[lib]
+name = "negiter"
+path = "negiter.rs"

negiter/negiter.rs

@@ -0,0 +1,57 @@
+pub struct IterNegate<I, T>
+where
+    I: Iterator<Item = T>,
+    T: std::ops::Neg<Output = T>,
+{
+    iter: I,
+}
+
+impl<I, T> Iterator for IterNegate<I, T>
+where
+    I: Iterator<Item = T>,
+    T: std::ops::Neg<Output = T>,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|v| -v)
+    }
+}
+
+impl<I, T> IterNegate<I, T>
+where
+    I: Iterator<Item = T>,
+    T: std::ops::Neg<Output = T>,
+{
+    pub fn negated(iter: I) -> Self {
+        Self { iter }
+    }
+}
+
+pub trait IterNegateExt<I, T>
+where
+    I: Iterator<Item = T>,
+    T: std::ops::Neg<Output = T>,
+{
+    fn negated(self) -> IterNegate<I, T>;
+}
+
+impl<I, T> IterNegateExt<I, T> for I
+where
+    I: Iterator<Item = T>,
+    T: std::ops::Neg<Output = T>,
+{
+    fn negated(self) -> IterNegate<I, T> {
+        IterNegate::negated(self)
+    }
+}
+
+#[test]
+fn test_negated_example() {
+    let numbers: Vec<i32> = (0..=5).collect();
+    let negs: Vec<i32> = numbers.iter().cloned().negated().collect();
+    assert_eq!(numbers.len(), negs.len());
+    for (i, &v) in numbers.iter().enumerate() {
+        assert_eq!(-v, negs[i]);
+    }
+}

shuflr/shuflr.rs

@@ -7,7 +7,7 @@ pub struct IterShuffled<'a, T> {
 }
 
 impl<'a, T> IterShuffled<'a, T> {
-    pub fn new<R>(values: &'a [T], rng: &mut R) -> Self
+    pub fn shuffled<R>(values: &'a [T], rng: &mut R) -> Self
     where
         R: Rng + ?Sized,
     {
@@ -25,29 +25,68 @@ impl<'a, T> Iterator for IterShuffled<'a, T> {
     }
 }
 
-pub trait Shuffled<T> {
+pub trait ShuffledExt<T> {
     fn shuffled<R>(&self, rng: &mut R) -> IterShuffled<T>
     where
         R: Rng + ?Sized;
 }
 
-impl<T> Shuffled<T> for [T] {
+impl<T> ShuffledExt<T> for [T] {
     fn shuffled<R>(&self, rng: &mut R) -> IterShuffled<T>
     where
         R: Rng + ?Sized,
     {
-        IterShuffled::new(self, rng)
+        IterShuffled::shuffled(self, rng)
     }
 }
 
-#[test]
-pub fn test_shuffled() {
-    let mut rng = rand::thread_rng();
-    let vals = &['a', 'b', 'c'];
-    let mut v = Vec::new();
-    for &c in vals.shuffled(&mut rng) {
-        v.push(c);
+#[cfg(test)]
+mod tests {
+    use rand::RngCore;
+
+    use super::*;
+
+    #[test]
+    pub fn test_shuffled_works() {
+        let mut rng = rand::thread_rng();
+        let vals = &['a', 'b', 'c'];
+        let mut v = Vec::new();
+        for &c in vals.shuffled(&mut rng) {
+            v.push(c);
+        }
+        v.sort();
+        assert_eq!(&v, vals);
+    }
+
+    struct FakeRng(u64);
+
+    impl RngCore for FakeRng {
+        fn next_u32(&mut self) -> u32 {
+            let result = self.0 as u32;
+            self.0 += 1;
+            result
+        }
+        fn next_u64(&mut self) -> u64 {
+            let result = self.0;
+            self.0 += 1;
+            result
+        }
+        fn fill_bytes(&mut self, _dest: &mut [u8]) {
+            panic!("fill_bytes")
+        }
+        fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), rand::Error> {
+            panic!("try_fill_bytes")
+        }
+    }
+
+    #[test]
+    pub fn test_shuffled_shuffles() {
+        let mut rng = FakeRng(0);
+        let vals = &['a', 'b', 'c'];
+        let mut v = Vec::new();
+        for &c in vals.shuffled(&mut rng) {
+            v.push(c);
+        }
+        assert_eq!(&v, &['a', 'c', 'b']);
     }
-    v.sort();
-    assert_eq!(&v, vals);
 }

stackcoll/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "stackcoll"
+version = "0.1.0"
+authors = ["Bart Massey <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+
+[lib]
+name = "stackcoll"
+path = "stackcoll.rs"

stackcoll/stackcoll.rs

@@ -0,0 +1,22 @@
+pub struct Stack<T>(Vec<T>);
+
+impl<T> std::iter::FromIterator<T> for Stack<T> {
+    fn from_iter<I>(ii: I) -> Self
+    where
+        I: IntoIterator<Item = T>
+    {
+        let iter = ii.into_iter();
+        let mut stack = Vec::with_capacity(iter.size_hint().1.unwrap_or(0));
+        for v in iter {
+            stack.push(v);
+        }
+        Stack(stack)
+    }
+}
+
+#[test]
+fn test_stack_collect() {
+    let s: Stack<u8> = (0..7).collect();
+    let v: Vec<u8> = (0..7).collect();
+    assert_eq!(&s.0, &v);
+}