FIX(docs, tests): Fix empty doctests, and add docs

* Adds documentation to the `bst!` macro

* Changes the tree visualizations from `rust` blocks to just `text`, so
that `cargo doc` does not complain

* Runs `cargo fmt`

src/lib.rs

@@ -83,12 +83,36 @@
 //! assert_ne!(recursive_bst, RecursiveBST::new());
 //! ```
 
+use crate::node::{HeapNode, Node};
 use std::fmt::{Debug, Display, Formatter};
 use std::vec::IntoIter;
-use crate::node::{HeapNode, Node};
 
 mod node;
 
+/// Creates a [`IterativeBST`] containing the arguments.
+///
+/// # Important
+///
+/// If given no arguments this will be equivalent to calling
+/// `IterativeBST::new()`
+///
+/// # Example
+/// - Create a [`IterativeBST`] containing a given list of elements:
+///
+/// ```rust
+/// use bst_rs::{BinarySearchTree, IterativeBST, bst};
+///
+/// let t1 = bst![1, 2, 3];
+/// // Which is functionally equivalent to
+/// let t2 = IterativeBST::from_iter(vec![1,2,3]);
+/// // and produces the following tree
+/// //    2
+/// //   / \
+/// //  1   3
+/// assert_eq!(t1, t2);
+/// ```
+///
+/// [`IterativeBST`]: crate::IterativeBST
 #[macro_export]
 macro_rules! bst {
     () => (
@@ -219,12 +243,12 @@ pub trait BinarySearchTree<T: Ord> {
     ///
     /// Given a tree that looks like:
     ///
-    /// ```rust
-    ///  //         4
-    ///  //       /  \
-    ///  //      2    6
-    ///  //     / \  / \
-    ///  //    1  3 5   7
+    /// ```text
+    ///           4
+    ///         /  \
+    ///        2    6
+    ///       / \  / \
+    ///      1  3 5   7
     /// ```
     ///
     /// The height is: **2**
@@ -255,12 +279,12 @@ pub trait BinarySearchTree<T: Ord> {
     /// # Example
     ///
     /// Given a tree that looks like:
-    /// ```rust
-    ///  //         4
-    ///  //       /  \
-    ///  //      2    6
-    ///  //     / \  / \
-    ///  //    1  3 5   7
+    /// ```text
+    ///           4
+    ///         /  \
+    ///        2    6
+    ///       / \  / \
+    ///      1  3 5   7
     /// ```
     /// The pre_order_vec is: **[&4, &2, &1, &3, &6, &5, &7].**
     fn pre_order_vec(&self) -> Vec<&T>;
@@ -275,12 +299,12 @@ pub trait BinarySearchTree<T: Ord> {
     /// # Example
     ///
     /// Given a tree that looks like:
-    /// ```rust
-    ///  //         4
-    ///  //       /  \
-    ///  //      2    6
-    ///  //     / \  / \
-    ///  //    1  3 5   7
+    /// ```text
+    ///           4
+    ///         /  \
+    ///        2    6
+    ///       / \  / \
+    ///      1  3 5   7
     /// ```
     /// The in_order_vec is: **[&1, &2, &3, &4, &5, &6, &7].**
     fn in_order_vec(&self) -> Vec<&T>;
@@ -290,12 +314,12 @@ pub trait BinarySearchTree<T: Ord> {
     /// # Example
     ///
     /// Given a tree that looks like:
-    /// ```rust
-    ///  //         4
-    ///  //       /  \
-    ///  //      2    6
-    ///  //     / \  / \
-    ///  //    1  3 5   7
+    /// ```text
+    ///           4
+    ///         /  \
+    ///        2    6
+    ///       / \  / \
+    ///      1  3 5   7
     /// ```
     /// The post_order_vec is: **[&1, &3, &2, &5, &7, &6, &4].**
     fn post_order_vec(&self) -> Vec<&T>;
@@ -305,12 +329,12 @@ pub trait BinarySearchTree<T: Ord> {
     /// # Example
     ///
     /// Given a tree that looks like:
-    /// ```rust
-    ///  //         4
-    ///  //       /  \
-    ///  //      2    6
-    ///  //     / \  / \
-    ///  //    1  3 5   7
+    /// ```text
+    ///           4
+    ///         /  \
+    ///        2    6
+    ///       / \  / \
+    ///      1  3 5   7
     /// ```
     /// The post_order_vec is: **[&4, &2, &6, &1, &3, &5, &7].**
     fn level_order_vec(&self) -> Vec<&T>;

tests/macro.rs

@@ -1,17 +1,17 @@
-use bst_rs::bst;
+use bst_rs::{bst, BinarySearchTree, IterativeBST};
 
 #[test]
 fn successfully_construct_bst_from_macro() {
     let mut actual_bst = IterativeBST::new();
     actual_bst.insert(3);
     actual_bst.insert(2);
-    let expected_bst = bst![3,2];
+    let expected_bst = bst![3, 2];
     assert_eq!(actual_bst, expected_bst);
 }
 
 #[test]
 fn verify_permutations_produce_same_tree() {
-    let expected_bst = bst![2,3];
-    let expected_bst = bst![3,2];
+    let actual_bst = bst![2, 3];
+    let expected_bst = bst![3, 2];
     assert_eq!(actual_bst, expected_bst);
 }