Rust 生命周期、子类型与型变：引用关系如何传播

fn first_word(text: &str) -> &str {
    text.split_whitespace().next().unwrap_or("")
}

fn first_word<'a>(text: &'a str) -> &'a str {
    text.split_whitespace().next().unwrap_or("")
}

let word;

{
    let text = String::from("lifetime relation");
    word = first_word(&text);
    println!("{word}");
}

// println!("{word}"); // text 已析构，借用不能继续使用

fn longest<'a>(left: &'a str, right: &'a str) -> &'a str {
    if left.len() >= right.len() { left } else { right }
}

let outer = String::from("outer value");

{
    let inner = String::from("inner");
    let result = longest(&outer, &inner);
    println!("{result}");
}

fn choose_left<'a, 'b>(left: &'a str, _right: &'b str) -> &'a str {
    left
}

fn invalid() -> &str {
    let text = String::from("local");
    // &text // E0106 / E0515：返回值引用了局部数据
    todo!()
}

fn owned_text() -> String {
    String::from("owned")
}

fn write_text(buffer: &mut String) -> &str {
    buffer.clear();
    buffer.push_str("borrowed from caller");
    buffer.as_str()
}

fn compare(left: &str, right: &str) -> bool

fn compare<'a, 'b>(left: &'a str, right: &'b str) -> bool

fn head(bytes: &[u8]) -> &[u8]

fn head<'a>(bytes: &'a [u8]) -> &'a [u8]

struct Frame<'a> {
    payload: &'a [u8],
}

impl<'a> Frame<'a> {
    fn payload(&self) -> &[u8] {
        self.payload
    }
}

// fn select(left: &str, right: &str) -> &str
// 无法判断输出来自 left 还是 right

#[derive(Debug)]
struct Header<'a> {
    name: &'a str,
    value: &'a str,
}

fn parse_header(line: &str) -> Option<Header<'_>> {
    let (name, value) = line.split_once(':')?;
    Some(Header {
        name: name.trim(),
        value: value.trim(),
    })
}

let line = String::from("Content-Type: text/plain");
let header = parse_header(&line).unwrap();

assert_eq!(header.name, "Content-Type");
assert_eq!(header.value, "text/plain");

let mut buffer = String::from("Key: Value");
let header = parse_header(&buffer).unwrap();

// buffer.clear(); // header 仍借用 buffer
println!("{}", header.value);

#[derive(Debug)]
struct OwnedHeader {
    name: String,
    value: String,
}

impl From<Header<'_>> for OwnedHeader {
    fn from(header: Header<'_>) -> Self {
        Self {
            name: header.name.to_owned(),
            value: header.value.to_owned(),
        }
    }
}

fn parse_header(line: &str) -> Option<Header<'_>> {
    // ...
    todo!()
}

fn print_header(header: Header<'_>) {
    println!("{}: {}", header.name, header.value);
}

let language: &'static str = "Rust";

fn requires_static<T: 'static>(_value: T) {}

let owned = String::from("owned");
requires_static(owned);

let local = String::from("local");
let borrowed = local.as_str();

// requires_static(borrowed);

fn shorten<'long, 'short>(value: &'long str) -> &'short str
where
    'long: 'short,
{
    value
}

struct Ref<'a, T: 'a> {
    value: &'a T,
}

fn use_for_call<'short>(value: &'short str) {
    println!("{value}");
}

let static_text: &'static str = "available forever";
use_for_call(static_text);

let text = String::from("short");
let short = text.as_str();

// let forever: &'static str = short;

fn shorten_shared<'long, 'short>(value: &'long str) -> &'short str
where
    'long: 'short,
{
    value
}

fn shorter_mut<'long, 'short>(value: &'long mut i32) -> &'short mut i32
where
    'long: 'short,
{
    value
}

fn overwrite<'a>(slot: &mut &'a str, value: &'a str) {
    *slot = value;
}

let static_text: &'static str = "static";
let mut slot = static_text;

{
    let local = String::from("local");

    // 如果 &mut &'static str 能被当作 &mut &'short str，
    // overwrite 就能把 local 的短引用写入 slot。
    // overwrite(&mut slot, &local);
}

println!("{slot}");

fn accepts_any(value: &str) {
    println!("{value}");
}

fn call_with_static(function: fn(&'static str)) {
    function("static input");
}

call_with_static(accepts_any);

struct View<'a> {
    text: &'a str,
}

fn shorten_view<'long, 'short>(view: View<'long>) -> View<'short>
where
    'long: 'short,
{
    view
}

use std::cell::Cell;

struct Slot<'a> {
    text: Cell<&'a str>,
}

fn apply<'a, F>(value: &'a str, function: F) -> &'a str
where
    F: Fn(&'a str) -> &'a str,
{
    function(value)
}

fn call_with_local<F>(function: F)
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    let local = String::from("local");
    let result = function(&local);
    println!("{result}");
}

call_with_local(|text| text.trim());

for<'a> Fn(&'a str) -> &'a str

Fn(&'static str) -> &'static str

type Transformer = for<'a> fn(&'a str) -> &'a str;

fn trim(text: &str) -> &str {
    text.trim()
}

let transformer: Transformer = trim;

fn identity(text: &str) -> &str {
    text
}

fn identity<'a>(text: &'a str) -> &'a str {
    text
}

// let identity = |text: &str| -> &str { text };

let identity: for<'a> fn(&'a str) -> &'a str = |text| text;

assert_eq!(identity("rust"), "rust");

fn accept_identity<F>(function: F) -> F
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    function
}

let identity = accept_identity(|text| text);
assert_eq!(identity("lifetime"), "lifetime");

fn call_now<F>(function: F)
where
    F: FnOnce(),
{
    function();
}

let text = String::from("captured");
call_now(|| println!("{text}"));

struct SelfReference<'a> {
    text: String,
    // view: &'a str, // 试图指向 text
}