match VALUE {
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

let v = Some(0u8);

match v {
    Some(3) => println!("three"),
    _ => println!("others"),
}

// 可使用 if let 改写
if let Some(3) = v {
    println!("three");
} else {
    println!("others");
}

let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
    println!("{}", top);
}

let arr = vec!['a', 'b', 'c'];
for (i, v) in arr.iter().enumerate() {
    println!("{}: {}", i, v);
}

let a = 5; // 这个其实也是一个模式
let (x, y, z) = (1, 2, 3);

fn foo(x: i32) {} // 参数 x 也是一个模式
fn foo2(&(x, y): &(i32, i32)) {}

let point = (3, 5);
foo2(&point);

let x = 1;

match x = {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    _ => println!("anything"),
}

let x = Some(5);
let y = 10;

match x = {
    Some(50) => println!("Got 50"),
    Some(y) => println!("Matched, y = {:?}", y), // 作用域只在子句中
    _ => println!("Default case, x = {:?}", x),
}

println!("at the end: x = {:?}, y = {:?}", x, y);
// "Matched, y = 5"
// "at the end: x = Some(5), y = 10"

let x = 1;

match x {
    1 | 2 => println!("one or two"),
    3 => println!("three"),
    _ => println!("anything"),
}

let x = 5;

match x {
    1..=5 => println!("one through five"), // 1,2,3,4,5
    _ => println!("something else"),
}

// 解构 struct
struct Point { x: i32, y: i32, }

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x, y } = p;
    assert_eq!(0, x);
    assert_eq!(7, y);

    let Point { x: a, y: b } = p;
    assert_eq!(0, a);
    assert_eq!(7, b);

    match p {
        // 子分支会创建 x y 变量
        // 匹配 x = any, y = 0 的 Point
        Point { x, y: 0 } => println!("On the x axis at {}", x),
        // 匹配 x = 0, y = any 的 Point
        Point { x: 0, y } => println!("On the y axis at {}", y), // 匹配到该行
        // 匹配 x = any, y = any 的 Point
        Point { x, y } => println!("On neither axis: ({}, {})", x, y),
    }
}

// 解构 enum
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::ChangeColor(0, 160, 255);

    match msg {
        Message::Quit => {...}
        // 会创建 x y 变量
        Message::Move { x, y } => {...}
        Message::Write(text) => {...},
        Message::ChangeColor(r, g, b) => {...}
    }
}

// 解构嵌套的类型
enum Color {
   Rgb(i32, i32, i32),
   Hsv(i32, i32, i32),
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(Color),
}

fn main() {
    let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));

    match msg {
        Message::ChangeColor(Color::Rgb(r, g, b)) => {...}
        Message::ChangeColor(Color::Hsv(h, s, v)) => {...}
        _ => ()
    }
}

// 解构 tuple
let ((feet, inches), Point {x, y}) = ((3, 10), Point { x: 3, y: -10 });

// 使用 `_` 来作为匹配但不绑定任何值的通配符
fn foo(_: i32, y: i32) {
    println!("This code only uses the y parameter: {}", y);
}

// --------
let mut setting_value = Some(5);
let new_setting_value = Some(10);
match (setting_value, new_setting_value) {
    (Some(_), Some(_)) => {
        println!("Can't overwrite an existing customized value");
    }
    _ => {
        setting_value = new_setting_value;
    }
}
println!("setting is {:?}", setting_value);

// --------
let numbers = (2, 4, 8, 16, 32);
match numbers {
    (first, _, third, _, fifth) => {
        println!("Some numbers: {}, {}, {}", first, third, fifth)
    },
}

// 使用以 `_` 开头的名称: 忽略被使用的变量
let _x = 5; // _x 没被使用也不会有警告

// -------
let s = Some(String::from("Hello!"));
// s 多所有权被移入了 if let 子句了, _s 会发生绑定操作获取所有权
// 如果将 Some(_s) 修改为 Some(_)，_ 不会发生绑定操作，所以 s 的所有权也不会移动了
if let Some(_s) = s {
    println!("found a string");
}

// 用 .. 忽略剩余值
struct Point {
    x: i32,
    y: i32,
    z: i32,
}

let origin = Point { x: 0, y: 0, z: 0 };

match origin {
    Point { x, .. } => println!("x is {}", x),
}

// ----------
let numbers = (2, 4, 8, 16, 32);

match numbers {
    // (.., second, ..) 这种模糊的匹配会失败
    (first, .., last) => {
        println!("Some numbers: {}, {}", first, last);
    },
}

// 指定于 match 分支模式之后的额外 if 条件，它也必须被满足才能选择此分支
let x = Some(5);
let y = 10;

match x {
    Some(50) => println!("Got 50"),
    // 匹配 Some(n), 然后绑定 n, 如果 n == y, 匹配成功
    // 该例中, 匹配 Some(n) 成功，但是由于 n != y，所以进入 _ 分支
    Some(n) if n == y => println!("Matched, n = {}", n),
    _ => println!("Default case, x = {:?}", x), // 最终匹配到这个分支
}

let x = 4;
let y = false;

match x {
    // 匹配 4, 5, 6; 并且 y == true
    4 | 5 | 6 if y => println!("yes"),
    _ => println!("no"), // 最终匹配到这个分支
}

// @ 符号让我们可以创建一个变量，该变量可以在测试某个值是否与模式匹配的同时保存该值
enum Message {
    Hello { id: i32 },
}

let msg = Message::Hello { id: 5 };

match msg {
    // 要求 id 的值在 3~7 范围内，同时使用 @ 将匹配到的值存储在 id_variable 变量中
    Message::Hello { id: id_variable @ 3..=7 } => {
        println!("Found an id in range: {}", id_variable) // 
    },
    // 这里由于 id 匹配的是一个范围，其可能是 10 11 12, 没有具体的值，所以即使匹配到了也无法绑定
    // 如果匹配到该子句了，想在子句内使用具体匹配到的值，也得 { id: id_variable @ 10..=12 }
    Message::Hello { id: 10..=12 } => {
        println!("Found an id in another range")
    },
    // 该子句指定了一个没有范围的比例，所以如果匹配到这行，id 可以绑定具体的值
    Message::Hello { id } => {
        println!("Found some other id: {}", id)
    },
}
// Found an id in range: 5

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
    // 当主线程结束时，新线程也会结束，而不管子线程是否执行完毕
    // 可以使用 join 等待子线程执行完毕 (会堵塞, 直到线程执行完毕)
    handle.join().unwrap();
}

use std::thread;

fn main() {
    let v = vec![1, 2, 3];
    // 将 v 的所有权移动到了线程中, 这样线程中就可以安全的使用 v 变量了
    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

use std::thread;
use std::sync::mpsc;

fn main() {
    // tx: 发送端
    // rx: 接收端
    let (tx, rx) = mpsc::channel();

    // move: 使新的线程拥有了 tx 发送端的所有权了
    thread::spawn(move || {
        let val = String::from("hi");
        // 这里 send 之后, val 的所有权会被转移给接收者
        tx.send(val).unwrap(); // 发送数据
        // val 不可用了
    });

    // 接收数据 (阻塞主线程执行直到从通道中接收一个值)
    // 当通道发送端关闭，recv 会返回一个错误表明不会再有新的值到来了
    // 还有个方法 try_recv, 其不会堵塞则是立即返回 Result, Ok 表示有值, Err 表示值还没到来
    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

// 发送多个值
use std::thread;
use std::sync::mpsc;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1)); // 暂停 1s
        }
    });

    // 可把接受者 rx 当作迭代器使用, 每过 1s 会接收到一个值
    for received in rx {
        println!("Got: {}", received);
    }
}

// 通过克隆发送者来创建多个生产者

// ...
let (tx, rx) = mpsc::channel();

let tx1 = tx.clone();
thread::spawn(move || {
    let vals = vec![
        String::from("hi"),
        String::from("from"),
    ];

    for val in vals {
        tx1.send(val).unwrap();
        thread::sleep(Duration::from_secs(1));
    }
});

thread::spawn(move || {
    let vals = vec![
        String::from("more"),
        String::from("messages"),
    ];

    for val in vals {
        tx.send(val).unwrap();
        thread::sleep(Duration::from_secs(1));
    }
});

// 会接收到 tx1 和 tx 两个发送端发送的数据
for received in rx {
    println!("Got: {}", received);
}
// ...

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(5);

    {
        let mut num = m.lock().unwrap();
        *num = 6;
    } // mutex 使用了 Drop trait, 所以这里会自动 unlock

    println!("m = {:?}", m);
}

// 多线程共享 mutex
use std::sync::{Mutex, Arc};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        // 利用 Arc 实现多线程之间共享所有权
        // 不使用 Arc 的话, 在第一次循环时, counter 的所有权就会被移动到线程中, 第二次循环就会报错 (不能将 counter 锁的所有权移动到多个线程中)
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // 线程中获取 lock, 并修改值
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    // 等所有线程都执行完毕后再往下执行
    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}

fn main() {
    let a = Box::new(5); // 整数 5 存储在 heap 上了
    println("a = {}", a); // "a = 5"
} // a 被释放了 (会释放其存储在 stack 上的指针，以及存储在 heap 上的数据)

// 使用 Rust 实现 Cons List
use crate::List::{Cons, Nil};

enum List {
    Cons(i32, Box<List>),
    Nil,
}

fn main() {
    // Box<T> 提供了 "间接" 存储和 heap 内存分配的方式
    let list = Cons(1,
        Box::new(Cons(2,
            Box::new(Cons(3,
                Box::new(Nil))))));

    println!("{:?}", list); // Cons(1, Cons(2, Cons(3, Nil)))
}

let x = 5;
let y = &x;

assert_eq!(5, x); // ok
assert_eq!(5, *y); // ok

// 使用 Box<T> 替代上面的引用
let y = Box::new(x);
assert_eq!(5, *y); // ok

// 自定义智能指针
struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

impl <T>std::ops::Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

fn main() {
    let x = 5;
    let y = MyBox::new(x);
    assert_eq!(5, *y); // ok 
    // *y 相当于 *(y.deref())
}

fn hello(name: &str) {
    println!("Hello, {}", name);
}

fn main() {
    let m = MyBox::new(String::from("world"));
    // &m: &MyBox<String>
    // - 由于 MyBox 实现了 deref trait，所以编译器可以把 &MyBox<String> 转化为 &String
    // - 由于标准库中 String 也实现了 deref trait，调用 deref 方法返回一个 &str 类型
    // - 所以 &m 可以作为参数传入，满足 &str 的参数类型要求
    hello(&m);
    // 如果没有实现 deref trait，则这里得这样调用: hello(&(*m)[..])
}

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("drop");
    }
}

fn main() {
    let a = CustomSmartPointer { data: String::from("hello") };
} // "drop"

use std::rc::Rc;

fn main() {
    let a = Rc::new(1);
    // 对一个 Rc 结构进行 clone()，不会将其内部的数据复制，只会增加引用计数
    let b = a.clone();
    let c = a.clone();

    // 作用域有三个 Rc(a, b, c), 它们共同指向堆上相同的数据, 即堆上的数据有 3 个共享的所有者
    // 而当一个 Rc 结构离开作用域被 drop() 时，也只会减少其引用计数，直到引用计数为零，才会真正清除对应的内存
}

// 两个 List 共享另一个 List 的所有权
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    // b, c 共享 a 的所有权
    let b = Cons(3, Rc::clone(&a)); // 引用计数+1
    {
        let c = Cons(4, Rc::clone(&a)); // 引用计数+1
    } // c 离开作用域了, 引用计数自动 -1
    // a.clone() 该方法会进行深度的 copy; Rc::clone 只会增加引用计数, 不会执行数据的深度 copy
    // a 在引用计数清零的时候才会被回收
}

fn main() {
    let x = 5;
    let y = &mut x; // 报错, 无法可变的借用一个不可变的值
    // 有时会需要有这一种场景, 值在外部是不可变的, 但是在方法内部需要可以修改这个值
    // 可以使用 RefCell 来实现这种内部可变性
}

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(1);
    // 在同一个作用域下，我们不能同时有活跃的可变借用和不可变借用
    // 通过这对花括号，我们明确地缩小了可变借用的生命周期，不至于和后续的不可变借用冲突
    {
        // 获得 RefCell 内部数据的可变借用
        let mut v = data.borrow_mut();
        *v += 1;
    }
    println!("data: {:?}", data.borrow()); // data: 2
}

#[derive(Debug)]
enum List {
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    let value = Rc::new(RefCell::new(5));

    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));

    let b = Cons(Rc::new(RefCell::new(6)), Rc::clone(&a));
    let c = Cons(Rc::new(RefCell::new(10)), Rc::clone(&a));

    *value.borrow_mut() += 10;

    println!("a after = {:?}", a);
    println!("b after = {:?}", b);
    println!("c after = {:?}", c);
}

# 并行运行所有测试函数
# - 测试成功时: 不显示所有输出(如 println!)，使读取与测试结果相关的输出更容易
# - 测试失败时会显示如 println! 这样的输出
cargo test

# 命令行参数分为以下两大类
# 1. 针对 cargo test 的参数: 紧跟 cargo test 之后
cargo test --help # 输出 cargo test 的可用的参数

# 2. 针对测试可执行程序: 放在 -- 之后
cargo test -- --help # 输出 -- 之后的所有可用参数

# --test-threads 参数
# - 传递给二进制文件
# - 🙅以并行方式运行测试，或向对线程数进行细粒度控制
# - 可使用该参数，后面跟线程的数量
cargo test -- --test-threads=1 # 单线程运行测试

# 即使测试通过，也显示标准输出
cargo test -- --show-output

# 根据测试函数的名称指定运行的测试
cargo test test_one_fn # 运行单个测试
# 可指定测试名的一部分 (模块名也可以) 来匹配并运行多个测试
cargo test test_ # 会运行测试函数名字中带有 test_ 的测试

#[test]
fn test_fn() {}

#[derive(Debug)]
pub struct Rectangle {
    length: u32,
    width: u32,
}

impl Rectangle {
    pub fn can_hold(&self, other: &Rectangle) -> bool {
        self.length > other.length && self.width > other.width
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn larger_can_hold_smaller() {
        let larger = Rectangle { length: 8, width: 7 };
        let smaller = Rectangle {
            length: 5,
            width: 1,
        };

        assert!(larger.can_hold(&smaller)); // 二参可传自定义信息
        // assert!(something, "{} {}", formart_param1, formart_param2);
    }
}

// 函数 panic: 测试通过，否则失败
#[cfg(test)]
mod tests {
    use super::*;

    // should_panic 修饰的函数 panic 了测试才会通过
    // 可 should_panic(expected = "xxxx")，验证 panic 时，错误信息是否包含了 expected 注明的字符串
    #[test]
    #[should_panic]
    fn test_fn() {...}
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() -> Result<(), String> {
        if 2 + 2 == 4 {
            Ok(())
        } else {
            Err(panic!(String::from("two plus two does not equal four")))
        }
    }
}

// 运行 cargo test，只会运行 fn1 这个测试
// "cargo test -- --ignored": 只运行被标记 ignore 的测试
#[cfg(test)]
mod tests {
    #[test]
    fn fn1() {...}

    #[test]
    #[ignore]
    fn fn2() {...}
}

// 只在 cargo test 才会把以下代码拉入编译范围
fn fn1() {...}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        fn1(); // 可调用私有函数
        assert_eq!(4, 2 + 2);
    }
}

// adder/tests/integration_test.rs
use adder; // 项目的名字

// 由于 tests 目录只会在执行 cargo test 命令的时候运行，所以不需要使用 #[cfg(test)] 标注
#[test]
fn it_adds_two() {
    assert_eq!(4, adder::add_two(2))
}

&i32        // 一个引用
&'a i32     // 带有显示生命周期的引用
&'a mut i32 // 带有显示生命周期的可变引用

fn test<'a>(x: &'a str, y: &'a str) -> &'a str {...}

fn main() {
    {
        let r;                                      // ----------------+-- 'a
        {                                           //                 /
            let x = 5;                              // -+-- 'b         /
            r = &x;                                 //  /              /
        }                                           // -+--            /
        // 这里使用 r 时，r 所指向的 x 已经由于脱离作用域, //                /
        // 被销毁了，所以会报错                         //                /
        // 这里 Rust 编译器会使用借用检查器发现这种错误.   //                /
        println!("r: {}", r);                       //                 /
    }                                               // ----------------+--
}
// 上例 r 的生命周期为 'a，x 的生命周期为 'b
// 借用检查器在编译时发现 r 指向了生命周期为 'b 的一块内存 x，因为 'b 的生命周期比 'a 短，所以会编译失败
// 解决: 保证 x 的生命周期不小于 r 的生命周期 'a

fn main() {
    {
        let x = 5; // 移动 x 到 r 之前
        let r;
        {
            r = &x;
        }
        println!("r: {}", r); // x 的生命周期覆盖了 r 的生命周期，编译通过
    }
}

// 编译不通过，返回值包含了借用的值，但是**函数签名**没有说明这个借用的值是来自 x 还是 y
// - 编译器不晓得，返回类型的生命周期是和 x 还是和 y 一样
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// 加上泛型生命周期，编译通过
// - 'a 的实际生命周期是: x y 两个生命周期中较小的那一个 (两个生命周期重叠的那一部分)
// - 'a 并不会改变传入的参数的生命周期，只是向借用检查器指出了一些可用于检查非法调用的约束而已
// - 所以 longest 并不需要准确的知道传入的变量 x y 的存活时长
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// 可编译通过
fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";
    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

// 可编译通过
// 因为 string1 string2 在 result 被移出作用域之前都是有效的
fn main() {
    let string1 = String::from("abcd"); // 生命周期在 main 作用域内
    {
        let string2 = "xyz"; // &str 类型，拥有静态生命周期，在整个出现运行期间都存活
        let result = longest(string1.as_str(), string2); // 生命周期在当前这个内部作用域内
        println!("The longest string is {}", result);
    } // result 移出作用域
}

// 编译失败
// string2 存活时间不够长，其借用给了 result，但是生命周期比 result 短
// 这与 longest 函数签名注明的生命周期不一致
fn main() {
    let string1 = String::from("abcd"); // 生命周期在 main 作用域内
    let result; // 生命周期在 main 作用域内
    {
        let string2 = String::from("xyz"); // 生命周期在当前这个内部作用域内
        result = longest(string1.as_str(), string2.as_str());
    } // string2 移出作用域
    println!("The longest string is {}", result);
}

// pub fn strtok<'b, 'a>(s: &'b mut &'a str, delimiter: char) -> &'a str
// &'b mut: 指向字符串引用的可变引用 &mut 的生命周期
// &'a str: 字符串引用 &str 本身的生命周期
// 由于返回值只和 &str 有关, 所以可只需标注他的生命周期, 其他无关的生命周期可省略, 让编译器来自动添加
pub fn strtok<'a>(s: &mut &'a str, delimiter: char) -> &'a str {
    if let Some(i) = s.find(delimiter) {
        let prefix = &s[..i];
        // 由于 delimiter 可以是 utf8，所以我们需要获得其 utf8 长度，
        // 直接使用 len 返回的是字节长度，会有问题
        let suffix = &s[(i + delimiter.len_utf8())..];
        *s = suffix;
        prefix
    } else { // 如果没找到，返回整个字符串，把原字符串指针 s 指向空串
        let prefix = *s;
        *s = "";
        prefix
    }
}

fn main() {
    let s = "hello world".to_owned(); // str
    let mut s1 = s.as_str(); // &str
    let hello = strtok(&mut s1, ' '); // 访问 s1 的可变引用 
    println!("hello is: {}, s1: {}, s: {}", hello, s1, s); // 访问 s1 的不可变引用
    // print: "hello is: hello, s1: world, s: hello world"
}
// 注意!, strtok 生命周期标注不能写成如下样子
// 会导致 print s1(访问 s1 的不可变引用) 时报错:
// - cannot borrow `s1` as immutable because it is also borrowed as mutable
// 这是因为这样标注就表示可变借用 &mut 和 返回值的生命周期一样了, 导致这个引用的生命周期在函数结束后还没有结束
// 这样在 print s1 时, 就会发生可变引用和不可变引用同时存在的情况, 导致报错
/*
    let hello = strtok(&mut s1, ' '); // 访问 s1 的可变引用
    // 此时 s1 的生命周期 == hello 的生命周期
    println!("hello is: {}, s1: {}, s: {}", hello, s1, s); // 访问 s1 的不可变引用
*/
pub fn strtok<'a>(s: &'a mut &str, delimiter: char) -> &'a str

// 由于返回值的生命周期只和 x 的生命周期有关，所以 y 不用标注生命周期
// fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
fn longest<'a>(x: &'a str, y: &str) -> &'a str {
    x
}

// 悬垂引用 (编译不通过)
// result 离开作用域了，这块内存就失效了
fn demo1() -> &str {
    let result = String::from("abc");
    result.as_str()
}

// 将所有权返回给调用方 (可编译通过)
fn demo2() -> String {
    let result = String::from("abc");
    result
}

struct ImportantExcerpt<'a> {
    // path 这个引用必须要比 ImportantExcerpt 的实例的存活要长
    part: &'a str,
}

// first_sentence 的生命周期能够覆盖 ie 的生命周期，所以编译通过
fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");

    let first_sentence = novel.split('.')
        .next()
        .expect("Could not found a '.'");

    let ie = ImportantExcerpt {
        part: first_sentence,
    };
}

// 这个函数没有指定生命周期也能编译通过
// - 在 Rust 早期版本时无法编译通过的，当时要求每个引用都必须得有显式的生命周期
//   那时候这个函数得这么声明: fn first_word<'a>(s: &'a str) -> &'a str
// - 由于这类标注生命周期的规则都有相同的特征，所以编译器帮我们做了，不用程序员显式标注
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

fn test(s: &str) -> &str {...}
// 应用第一条规则: fn test<'a>(s: &'a str) -> &str
// 应用第二条规则: fn test<'a>(s: &'a str) -> &'a str
// 可以确定生命周期了，不用程序员显式标注

fn test2(x: &str, y: &str) -> &str {...}
// 应用第一条规则: fn test2<'a, 'b>(x: &'a str, y: &'b str) -> &str
// 由于有多个参数，无法应用第二条规则
// 由于不是方法，无法应用第三条规则
// 无法确定生命周期，需要程序员自己显式标注

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    // 由于第一条规则: &self 可不用标注生命周期
    fn level(&self) -> i32 {
        3
    }

    // 由于第一条规则和第三条规则，可不用标注生命周期
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        self.part
    }
}

fn longest_with_an_announcement<'a, T>
    (x: &'a str, y: &'a str, ann: T) -> &'a str
where
    T: Display
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}