binary-tree: Update.

Author: jimblandy

binary-tree/Cargo.lock

@@ -2,6 +2,7 @@
 name = "binary-tree"
 version = "0.1.0"
 authors = ["You <you@example.com>"]
+edition = "2018"
 
 [dependencies]
-rand = "0.3.14"
+rand = "0.8"

binary-tree/Cargo.toml

@@ -1,18 +1,16 @@
 #![allow(dead_code)]
 
-extern crate rand;
-
 // An ordered collection of `T`s.
 enum BinaryTree<T> {
  Empty,
- NonEmpty(Box<TreeNode<T>>)
+ NonEmpty(Box<TreeNode<T>>),
 }
 
 // A part of a BinaryTree.
 struct TreeNode<T> {
  element: T,
  left: BinaryTree<T>,
- right: BinaryTree<T>
+ right: BinaryTree<T>,
 }
 
 #[test]
@@ -26,37 +24,42 @@ fn binary_tree_size() {
 }
 
 #[test]
-fn test_hand_building_tree_of_planets() {
+fn build_binary_tree() {
  use self::BinaryTree::*;
  let jupiter_tree = NonEmpty(Box::new(TreeNode {
  element: "Jupiter",
  left: Empty,
- right: Empty
+ right: Empty,
  }));
+
  let mercury_tree = NonEmpty(Box::new(TreeNode {
  element: "Mercury",
  left: Empty,
- right: Empty
+ right: Empty,
  }));
+
  let mars_tree = NonEmpty(Box::new(TreeNode {
  element: "Mars",
  left: jupiter_tree,
- right: mercury_tree
+ right: mercury_tree,
  }));
+
  let venus_tree = NonEmpty(Box::new(TreeNode {
  element: "Venus",
  left: Empty,
- right: Empty
+ right: Empty,
  }));
+
  let uranus_tree = NonEmpty(Box::new(TreeNode {
  element: "Uranus",
  left: Empty,
- right: venus_tree
+ right: venus_tree,
  }));
+
  let tree = NonEmpty(Box::new(TreeNode {
  element: "Saturn",
  left: mars_tree,
- right: uranus_tree
+ right: uranus_tree,
  }));
 
  assert_eq!(tree.walk(),
@@ -80,18 +83,20 @@ impl<T: Clone> BinaryTree<T> {
 impl<T: Ord> BinaryTree<T> {
  fn add(&mut self, value: T) {
  match *self {
- BinaryTree::Empty =>
+ BinaryTree::Empty => {
  *self = BinaryTree::NonEmpty(Box::new(TreeNode {
  element: value,
  left: BinaryTree::Empty,
- right: BinaryTree::Empty
- })),
- BinaryTree::NonEmpty(ref mut node) =>
+ right: BinaryTree::Empty,
+ }))
+ }
+ BinaryTree::NonEmpty(ref mut node) => {
  if value <= node.element {
  node.left.add(value);
  } else {
  node.right.add(value);
  }
+ }
  }
  }
 }
@@ -113,18 +118,22 @@ fn test_add_method_2() {
  let mut tree = BinaryTree::Empty;
  tree.add("Mercury");
  tree.add("Venus");
- for planet in vec!["Mars", "Jupiter", "Saturn", "Uranus"]  {
+ for planet in vec!["Mars", "Jupiter", "Saturn", "Uranus"] {
  tree.add(planet);
  }
 
- assert_eq!(tree.walk(),
- vec!["Jupiter", "Mars", "Mercury", "Saturn", "Uranus", "Venus"]);
+ assert_eq!(
+ tree.walk(),
+ vec!["Jupiter", "Mars", "Mercury", "Saturn", "Uranus", "Venus"]
+ );
 }
 
+// From chapter 15: Iterators
+
 use self::BinaryTree::*;
 
 // The state of an in-order traversal of a `BinaryTree`.
-struct TreeIter<'a, T: 'a> {
+struct TreeIter<'a, T> {
  // A stack of references to tree nodes. Since we use `Vec`'s
  // `push` and `pop` methods, the top of the stack is the end of the
  // vector.
@@ -164,14 +173,13 @@ impl<'a, T> Iterator for TreeIter<'a, T> {
  type Item = &'a T;
  fn next(&mut self) -> Option<&'a T> {
  // Find the node this iteration must produce,
- // or finish the iteration.
- let node = match self.unvisited.pop() {
- None => return None,
- Some(n) => n
- };
-
- // The next node after this one is the leftmost child of
- // this node's right child, so push the path from here down.
+ // or finish the iteration. (Use the `?` operator
+ // to return immediately if it's `None`.)
+ let node = self.unvisited.pop()?;
+
+ // After `node`, the next thing we produce must be the leftmost
+ // child in `node`'s right subtree, so push the path from here
+ // down. Our helper method turns out to be just what we need.
  self.push_left_edge(&node.right);
 
  // Produce a reference to this node's value.
@@ -188,24 +196,40 @@ fn external_iterator() {
  }
 
  // Build a small tree.
- let subtree_l = make_node(Empty, "mecha", Empty);
- let subtree_rl = make_node(Empty, "droid", Empty);
- let subtree_r = make_node(subtree_rl, "robot", Empty);
- let tree = make_node(subtree_l, "Jaeger", subtree_r);
+ let mut tree = BinaryTree::Empty;
+ tree.add("jaeger");
+ tree.add("robot");
+ tree.add("droid");
+ tree.add("mecha");
 
  // Iterate over it.
  let mut v = Vec::new();
  for kind in &tree {
  v.push(*kind);
  }
- assert_eq!(v, ["mecha", "Jaeger", "droid", "robot"]);
+ assert_eq!(v, ["droid", "jaeger", "mecha", "robot"]);
 
+ assert_eq!(tree.iter()
+ .map(|name| format!("mega-{}", name))
+ .collect::<Vec<_>>(),
+ vec!["mega-droid", "mega-jaeger",
+ "mega-mecha", "mega-robot"]);
+
+ let mut iterator = (&tree).into_iter();
+ assert_eq!(iterator.next(), Some(&"droid"));
+ assert_eq!(iterator.next(), Some(&"jaeger"));
+ assert_eq!(iterator.next(), Some(&"mecha"));
+ assert_eq!(iterator.next(), Some(&"robot"));
+ assert_eq!(iterator.next(), None);
+
+ // Construct a tree by hand.
  let left_subtree = make_node(Empty, "mecha", Empty);
  let right_subtree = make_node(make_node(Empty, "droid", Empty),
  "robot",
  Empty);
  let tree = make_node(left_subtree, "Jaeger", right_subtree);
 
+ // Try initializing the iterator ourselves and see if it runs.
  let mut v = Vec::new();
  let mut iter = TreeIter { unvisited: vec![] };
  iter.push_left_edge(&tree);
@@ -214,33 +238,23 @@ fn external_iterator() {
  }
  assert_eq!(v, ["mecha", "Jaeger", "droid", "robot"]);
 
+ // Iterate by shared reference.
  let mut v = Vec::new();
  for kind in &tree {
  v.push(*kind);
  }
  assert_eq!(v, ["mecha", "Jaeger", "droid", "robot"]);
 
+ // Iterate, taking ownership.
  let mut v = Vec::new();
  let mut state = tree.into_iter();
  while let Some(kind) = state.next() {
  v.push(*kind);
  }
  assert_eq!(v, ["mecha", "Jaeger", "droid", "robot"]);
-
- assert_eq!(tree.iter()
- .map(|name| format!("mega-{}", name))
- .collect::<Vec<_>>(),
- vec!["mega-mecha", "mega-Jaeger",
- "mega-droid", "mega-robot"]);
-
- let mut iterator = tree.into_iter();
- assert_eq!(iterator.next(), Some(&"mecha"));
- assert_eq!(iterator.next(), Some(&"Jaeger"));
- assert_eq!(iterator.next(), Some(&"droid"));
- assert_eq!(iterator.next(), Some(&"robot"));
- assert_eq!(iterator.next(), None);
 }
 
+
 #[test]
 fn other_cloned() {
  use std::collections::BTreeSet;
@@ -257,13 +271,12 @@ fn other_cloned() {
 #[test]
 fn fuzz() {
  fn make_random_tree(p: f32) -> BinaryTree<i32> {
- use rand::{ThreadRng, thread_rng};
- use rand::distributions::range::Range;
- use rand::distributions::Sample;
+ use rand::prelude::*;
+ use rand::thread_rng;
+ use rand::rngs::ThreadRng;
 
  fn make(p: f32, next: &mut i32, rng: &mut ThreadRng) -> BinaryTree<i32> {
- let mut range = Range::new(0.0, 1.0);
- if range.sample(rng) > p {
+ if rng.gen_range(0.0 .. 1.0) > p {
  Empty
  } else {
  let left = make(p * p, next, rng);