struct lifetime

Author: friendbear

Cargo.lock

@@ -6,5 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-num = "0.4.3"
-image = "0.25.2"
+num = "0.4"
+image = "0.23"

chapter2/mandelbrot/Cargo.toml

@@ -128,6 +128,8 @@ fn print(n: &[f64]) {
     }
 }
 
+use regex::Regex;
+
 #[test]
 fn test_string() {
     let _speech = "Ouch! said the well.\n";

chapter3/rust-type/src/main.rs

@@ -53,3 +53,7 @@ mod error_test {
         assert!(true)
     }
 }
+
+fn main() {
+    // Add your main function code here
+}

chapter7/errors/src/main.rs

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

chapter9/implimentation/Cargo.toml

@@ -0,0 +1,80 @@
+/// First in First out data structure
+#[derive(Default, Debug)]
+pub struct Queue<T> {
+    older: Vec<T>,
+    younger: Vec<T>,
+}
+
+impl<T> Queue<T> {
+    /// 所有権の取得 (selfを消費する)
+    pub fn split(self) -> (Vec<T>, Vec<T>) {
+        (self.older, self.younger)
+    }
+    /// 参照の取得 (selfを消費しない)
+    pub fn len(&self) -> usize {
+        self.older.len() + self.younger.len()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.older.is_empty() && self.younger.is_empty()
+    }
+    /// &mut Queue<T> に対するメソッド
+    pub fn push(&mut self, v: T) {
+        self.younger.push(v);
+    }
+    ///
+    /// # Returns
+    /// - `Some(T)` if the queue is not empty
+    /// - `None` if the queue is empty
+    ///
+    /// ```
+    /// use implimentation::Queue;
+    /// let mut q = Queue::<u32>::default();
+    /// assert!(q.len() == 0);
+    /// assert!(q.is_empty());
+    /// q.push(42);
+    /// assert!(q.len() == 1);
+    /// assert!(!q.is_empty());
+    ///
+    /// assert_eq!(q.pop(), Some(42));
+    /// assert!(q.len() == 0);
+    /// assert!(q.is_empty());
+    /// ```
+    pub fn pop(&mut self) -> Option<T> {
+        if self.older.is_empty() {
+            if self.younger.is_empty() {
+                return None;
+            } else {
+                std::mem::swap(&mut self.older, &mut self.younger);
+                self.older.reverse();
+            }
+        }
+        self.older.pop()
+    }
+}
+
+pub fn add(left: u64, right: u64) -> u64 {
+    left + right
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+
+    #[test]
+    fn it_works_queue() {
+        let mut q = Queue::<u32>::default();
+        assert!(q.len() == 0);
+        assert!(q.is_empty());
+        q.push(1);
+        q.push(2);
+        assert_eq!(q.pop(), Some(1));
+        assert_eq!(q.pop(), Some(2));
+        assert_eq!(q.pop(), None);
+    }
+}

chapter9/implimentation/src/lib.rs

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

chapter9/lifetime-param/Cargo.toml

@@ -0,0 +1,46 @@
+/// LifeTime as struct member
+///
+/// 任意の生存期間'eltに対して、生存期間があ;eltの参照を保持するExtrema<'elt>を作ることができる
+///
+/// # Examples
+struct Extrema<'elt> {
+    greatest: &'elt i32,
+    least: &'elt i32,
+}
+
+fn find_extrema<'s>(slice: &'s [i32]) -> Extrema {
+    let mut greatest = &slice[0];
+    let mut least = &slice[0];
+
+    for i in 1..slice.len() {
+        if slice[i] < *least {
+            least = &slice[i];
+        }
+        if slice[i] > *greatest {
+            greatest = &slice[i]
+        }
+    }
+    Extrema { greatest, least }
+}
+
+pub fn add(left: u64, right: u64) -> u64 {
+    left + right
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+    #[test]
+    fn it_work_find_extreama() {
+        let a = [0, -3, 0, 15, 48];
+        let e = find_extrema(&a);
+        assert_eq!(*e.least, -3);
+        assert_eq!(*e.greatest, 48);
+    }
+}