&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
    }
}