algotrees 0.2.0

This is a VERY early stage project to implement a library of algorithms and data structures in Rust. It has very little features and only supports one data structure (binary trees) at the moment. Documentation will come after each portion of the project is done ie: documentation for the binary tree data structure will come once all of the algorithms and options you can use are implemented.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use crate::binary_trees::types::BinaryTree;

pub enum InsertionType<T> {
    Node(BinaryTree<T>),
    Empty,
}

pub enum DeletionDirection {
    Left,
    Right,
}

// dumb shit I don't understand (I mean, I kinda do):
/// checks for type equality
impl<T: Default + PartialEq> PartialEq for BinaryTree<T> {
    fn eq(&self, other: &BinaryTree<T>) -> bool {
        self.head == other.head && self.left == other.left && self.right == other.right
    }
}

impl<T: Default + PartialEq> BinaryTree<T>
where
    BinaryTree<T>: PartialEq,
{
    /// Inserts a value on the left side of the node. NOTE: the value must be of the same type as the tree.
    ///
    /// Example:
    pub fn insert_left(&mut self, item: InsertionType<T>) {
        match item {
            InsertionType::Node(node) => self.left = Some(Box::new(node)),
            InsertionType::Empty => {
                self.left = Some(Box::new(BinaryTree {
                    head: Default::default(),
                    left: None,
                    right: None,
                }))
            }
        }
    }

    pub fn insert_right(&mut self, item: InsertionType<T>) {
        match item {
            InsertionType::Node(node) => self.right = Some(Box::new(node)),
            InsertionType::Empty => {
                self.right = Some(Box::new(BinaryTree {
                    head: Default::default(),
                    left: None,
                    right: None,
                }))
            }
        }
    }

    pub fn remove(&mut self, direction: DeletionDirection) {
        match direction {
            DeletionDirection::Left => self.left = None,
            DeletionDirection::Right => self.right = None,
        }
    }

    pub fn remove_left(&mut self) {
        self.remove(DeletionDirection::Left);
    }

    pub fn remove_right(&mut self) {
        self.remove(DeletionDirection::Right);
    }

    pub fn get_left_node(&self) -> Option<&BinaryTree<T>> {
        match &self.left {
            Some(node) => Some(node),
            None => None,
        }
    }

    pub fn get_right_node(&self) -> Option<&BinaryTree<T>> {
        match &self.right {
            Some(node) => Some(node),
            None => None,
        }
    }

    pub fn get_left_head_val(&self) -> Option<&T> {
        match &self.left {
            Some(node) => Some(&node.head),
            None => None,
        }
    }

    pub fn get_right_head_val(&self) -> Option<&T> {
        match &self.right {
            Some(node) => Some(&node.head),
            None => None,
        }
    }

    pub fn get_head(&self) -> &T {
        // ;)
        &self.head
    }
}