added collections and string examples

Author: BartMassey

README.md

@@ -34,3 +34,8 @@ in a controlled repository now.
 * `negiter/`: example iterator adapter
 * `stackcoll/`: example fromiterator implementation
 * `shuflr/`: example iterator implementation
+* `seqs.rs`: examples with sequence types
+* `vecdeque.rs`: example of `VecDeque` usage
+* `setimpl.rs`: example implementation of `HashSet` as `HashMap`
+* `rng/`: example use of `rand` crate
+* `charcast.rs`: character / number casting examples

charcast.rs

@@ -0,0 +1,11 @@
+fn main() {
+    println!("{:02x}", 'x' as u8);
+    println!("{:02x}", '🦀' as u8);
+    println!("{:02x}", '🦀' as i8);
+    println!("{:04x}", '🦀' as u16);
+    println!("{:08x}", '🦀' as u32);
+    println!("{:08x}", '🦀' as i32);
+    println!("{:016x}", '🦀' as u64);
+
+    println!("{}", 0x78u8 as char);
+}

histogram.rs

@@ -0,0 +1,92 @@
+// Copyright © 2018 Bart Massey
+// [This program is licensed under the "MIT License"]
+// Please see the file LICENSE in the source
+// distribution of this software for license terms.
+
+use std::collections::HashMap;
+use std::fmt;
+use std::fs::File;
+use std::hash::Hash;
+use std::io::Read;
+use std::iter::FromIterator;
+
+#[derive(Clone, Debug)]
+struct Histogram<T: Hash + Eq>(HashMap<T, usize>);
+
+impl<T: Hash + Eq> Histogram<T> {
+    fn histogram<I>(values: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let mut h = HashMap::new();
+        for k in values {
+            h.entry(k).and_modify(|e| *e += 1).or_insert(1);
+        }
+        Histogram(h)
+    }
+}
+
+impl<T: Hash + Eq + Ord> Histogram<T> {
+    fn graph<'a>(&'a self) -> Vec<(&'a T, usize)> {
+        let Histogram(h) = self;
+        let mut result: Vec<(&T, usize)> =
+            h.iter().map(|(k, v)| (k, *v)).collect();
+        result.sort();
+        result
+    }
+}
+
+impl<T: Hash + Eq> FromIterator<T> for Histogram<T> {
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        Histogram::histogram(iter)
+    }
+}
+
+impl<T> fmt::Display for Histogram<T>
+where
+    T: Hash + Eq + Ord + fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        for (key, count) in self.graph() {
+            writeln!(fmt, "{:?}: {}", key, count)?;
+        }
+        Ok(())
+    }
+}
+
+fn clean_chars(s: &str) -> String {
+    let mut result = String::new();
+    for c in s.chars() {
+        if c.is_alphabetic() || c.is_numeric() || c.is_whitespace() {
+            result.extend(c.to_lowercase());
+        } else {
+            result.push(' ');
+        }
+    }
+    result
+}
+
+fn main() {
+    let h: Histogram<char> = "hello world"
+        .chars()
+        .filter(|c| c.is_alphabetic())
+        .collect();
+    println!("{}", h);
+
+    let words: Histogram<&str> = "a banana is a banana is a banana"
+        .split_whitespace()
+        .collect();
+    println!("{}", words);
+
+    let mut gba = String::new();
+    File::open("gettysburg-address.txt")
+        .expect("file not found")
+        .read_to_string(&mut gba)
+        .expect("file read error");
+    let gba = clean_chars(&gba);
+    let gba: Histogram<&str> = gba.split_whitespace().collect();
+    println!("{}", gba);
+}

rng/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "rng"
+version = "0.1.0"
+authors = ["Bart Massey <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+rand = "0.8"
+
+[[bin]]
+name = "rng"
+path = "rng.rs"

rng/rng.rs

@@ -0,0 +1,7 @@
+use rand::Rng;
+
+fn main() {
+    for _ in 0..10 {
+        println!("{}", rand::thread_rng().gen_range(1..=6));
+    }
+}

seqs.rs

@@ -0,0 +1,20 @@
+fn main() {
+    let mut v: Vec<&'static str> = Vec::new();
+    v.push("hello");
+    v.push("world");
+    println!("{:?}", v);
+    println!("{:?}", &v);
+    let w = vec!["hello", "world"];
+    assert_eq!(v, w);
+
+    let a: [&'static str; 2] = ["hello", "world"];
+    println!("{:?}", a);
+    let b: [&'static str; 2] = ["hello", "world"];
+    assert_eq!(a, b);
+
+    let s: &[&'static str] = &v;
+    let t: &[&'static str] = &a;
+
+    assert_eq!(s, t);
+    assert_eq!(s.len(), t.len());
+}

setimpl.rs

@@ -0,0 +1,13 @@
+use std::collections::HashMap;
+
+pub type MyHashSet<T> = HashMap<T, ()>;
+
+#[test]
+fn test_my_hash_set() {
+    let mut t: MyHashSet<u32> = HashMap::new();
+    t.insert(3, ());
+    t.insert(2, ());
+    t.insert(3, ());
+    let u: MyHashSet<u32> = vec![(2, ()), (3, ())].into_iter().collect();
+    assert_eq!(t, u);
+}

vecdeque.rs

@@ -0,0 +1,10 @@
+use std::collections::VecDeque;
+
+fn main() {
+    let mut q = VecDeque::new();
+    q.push_back(1u32);
+    q.push_back(2);
+    println!("{}", q.pop_front().unwrap());
+    println!("{}", q.pop_front().unwrap());
+    assert_eq!(q.pop_front(), None);
+}