enum.

Author: friendbear

Cargo.lock

@@ -10,5 +10,5 @@ members = [
     "chapter8/*",
     "chapter9/*",
     "chapter11/*"
-, "chapter12", "chapter13", "chapter7/errors"]
+, "chapter12", "chapter13", "chapter7/errors", "chapter10"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "chapter10"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

chapter10/Cargo.toml

@@ -0,0 +1,12 @@
+# 列挙型とパターン
+
+## 列挙型
+
+* データを保持する列挙型
+* 列挙型のメモリ上での表現
+* 列挙型を用いたリッチなデータ構造
+* ジェネリクスと列挙型
+
+## パターン
+
+* パターンマッチング

chapter10/README.md

@@ -0,0 +1,63 @@
+use std::fmt::Display;
+
+#[derive(PartialEq, Eq)]
+pub enum BinaryTree<T> {
+    Empty,
+    NonEmpty(Box<TreeNode<T>>),
+}
+impl<T: Display + PartialEq + Eq> Display for BinaryTree<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match *self {
+            BinaryTree::Empty => write!(f, "()"),
+            BinaryTree::NonEmpty(ref node) => write!(f, "{}", node.element),
+        }
+    }
+}
+
+#[derive(PartialEq, Eq)]
+pub struct TreeNode<T> {
+    element: T,
+    left: BinaryTree<T>,
+    right: BinaryTree<T>,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_build_btree_left_and_right_5depth_element_string() {
+        let tree = BinaryTree::NonEmpty(Box::new(TreeNode {
+            element: "A",
+            left: BinaryTree::NonEmpty(Box::new(TreeNode {
+                element: "B",
+                left: BinaryTree::NonEmpty(Box::new(TreeNode {
+                    element: "D",
+                    left: BinaryTree::Empty,
+                    right: BinaryTree::Empty,
+                })),
+                right: BinaryTree::NonEmpty(Box::new(TreeNode {
+                    element: "E",
+                    left: BinaryTree::Empty,
+                    right: BinaryTree::Empty,
+                })),
+            })),
+            right: BinaryTree::NonEmpty(Box::new(TreeNode {
+                element: "C",
+                left: BinaryTree::Empty,
+                right: BinaryTree::NonEmpty(Box::new(TreeNode {
+                    element: "F",
+                    left: BinaryTree::Empty,
+                    right: BinaryTree::Empty,
+                })),
+            })),
+        }));
+
+        match tree {
+            BinaryTree::Empty => assert!(BinaryTree::<&str>::Empty == BinaryTree::Empty),
+            BinaryTree::NonEmpty(ref t) => {
+                assert_eq!(t.element, "A")
+            }
+        }
+    }
+}

chapter10/src/btree.rs

@@ -0,0 +1,158 @@
+mod btree;
+
+/// HTTPステータスコードを表す列挙型
+pub enum HttpStatus {
+    Ok = 200,
+    NotModified = 304,
+    NotFound = 404,
+}
+
+/// 時間単位を表す列挙型
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum TimeUnit {
+    Seconds,
+    Minutes,
+    Hours,
+    Days,
+    Months,
+    Years,
+}
+
+/// 単位に関するメソッドを提供する
+impl TimeUnit {
+    pub fn plural(self) -> &'static str {
+        match self {
+            Self::Seconds => "seconds",
+            Self::Minutes => "minutes",
+            Self::Hours => "hours",
+            Self::Days => "days",
+            Self::Months => "months",
+            Self::Years => "years",
+        }
+    }
+    pub fn singular(self) -> &'static str {
+        self.plural().trim_end_matches('s')
+    }
+}
+
+/// 粗い時間を表す列挙型
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum RoughTime {
+    InThePast(TimeUnit, u32),
+    JustNow,
+    InTheFuture(TimeUnit, u32),
+}
+
+pub struct Point3d {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+/// 構造体型列挙型
+pub enum Shape {
+    Sphere { center: Point3d, radius: f32 },
+    Cuboid { corner1: Point3d, corner2: Point3d },
+}
+
+impl Shape {
+    pub fn volume(&self) -> f32 {
+        match self {
+            Self::Sphere { radius, .. } => 4.0 / 3.0 * std::f32::consts::PI * radius.powi(3),
+            Self::Cuboid { corner1, corner2 } => {
+                let diff = Point3d {
+                    x: (corner1.x - corner2.x).abs(),
+                    y: (corner1.y - corner2.y).abs(),
+                    z: (corner1.z - corner2.z).abs(),
+                };
+                diff.x * diff.y * diff.z
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem;
+    #[test]
+    fn test_http_status_size_of() {
+        let size = mem::size_of::<HttpStatus>();
+        assert_eq!(size, 2);
+        assert_eq!(mem::size_of::<HttpStatus>(), 2);
+        assert_eq!(HttpStatus::NotFound as i32, 404);
+    }
+    #[test]
+    fn test_time_unit() {
+        assert_eq!(TimeUnit::Seconds.plural(), "seconds");
+        assert_eq!(TimeUnit::Seconds.singular(), "second");
+        assert_eq!(TimeUnit::Minutes.plural(), "minutes");
+        assert_eq!(TimeUnit::Minutes.singular(), "minute");
+        assert_eq!(TimeUnit::Hours.plural(), "hours");
+        assert_eq!(TimeUnit::Hours.singular(), "hour");
+        assert_eq!(TimeUnit::Days.plural(), "days");
+        assert_eq!(TimeUnit::Days.singular(), "day");
+        assert_eq!(TimeUnit::Months.plural(), "months");
+        assert_eq!(TimeUnit::Months.singular(), "month");
+        assert_eq!(TimeUnit::Years.plural(), "years");
+        assert_eq!(TimeUnit::Years.singular(), "year");
+    }
+
+    #[test]
+    fn test_rough_time() {
+        let r = RoughTime::InThePast(TimeUnit::Seconds, 7);
+        assert_eq!(r, RoughTime::InThePast(TimeUnit::Seconds, 7));
+        assert_ne!(r, RoughTime::InThePast(TimeUnit::Seconds, 8));
+        assert_ne!(r, RoughTime::InThePast(TimeUnit::Minutes, 7));
+        assert_ne!(r, RoughTime::JustNow);
+        assert_ne!(r, RoughTime::InTheFuture(TimeUnit::Seconds, 7));
+    }
+
+    #[test]
+    fn test_shape() {
+        let c = Point3d {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+        };
+        let s = Shape::Sphere {
+            center: c,
+            radius: 1.0,
+        };
+        match s {
+            Shape::Sphere { center, radius } => {
+                assert_eq!(center.x, 0.0);
+                assert_eq!(center.y, 0.0);
+                assert_eq!(center.z, 0.0);
+                assert_eq!(radius, 1.0);
+            }
+            Shape::Cuboid { .. } => {
+                panic!("Expected a sphere, got a cuboid!");
+            }
+        }
+        let corner1 = Point3d {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+        };
+        let corner2 = Point3d {
+            x: 1.0,
+            y: 1.0,
+            z: 1.0,
+        };
+        let c = Shape::Cuboid { corner1, corner2 };
+        assert_eq!(c.volume(), 1.0);
+        match c {
+            Shape::Cuboid { corner1, corner2 } => {
+                assert_eq!(corner1.x, 0.0);
+                assert_eq!(corner1.y, 0.0);
+                assert_eq!(corner1.z, 0.0);
+                assert_eq!(corner2.x, 1.0);
+                assert_eq!(corner2.y, 1.0);
+                assert_eq!(corner2.z, 1.0);
+            }
+            Shape::Sphere { .. } => {
+                panic!("Expected a cuboid, got a sphere!");
+            }
+        }
+    }
+}

chapter10/src/lib.rs

@@ -0,0 +1 @@
+