Прояснить значение привязки двух ссылок к ссылкам с разной областью действия к одному и тому же времени жизни в сигнатуре функции.

Это (2): возвращенная ссылка существует до тех пор, пока время жизни ввода меньше.

Однако с точки зрения функции оба времени жизни ввода фактически одинаковы (оба равны 'a). Итак, учитывая, что переменная a из main() явно живет дольше, чем b, как это работает?

Хитрость в том, что вызывающий сокращает время жизни одной из двух ссылок, чтобы соответствовать сигнатуре функции min()s. Если у вас есть ссылка &'x T, вы можете преобразовать ее в &'y T iff 'x outlives 'y (также написано: 'x: 'y). Это имеет интуитивный смысл (мы можем сократить время жизни ссылки без плохих последствий). Компилятор выполняет это преобразование автоматически. Итак, представьте, что компилятор превращает ваш main() в:

let a = String::from("short");
{
    let b = String::from("a long long long string");

    // NOTE: this syntax is not valid Rust! 
    let a_ref: &'a_in_main str = &a;
    let b_ref: &'b_in_main str = &b;
    println!("{}", min(&a as &'b_in_main str, &b));
    //                    ^^^^^^^^^^^^^^^^^^
}

Это связано с чем-то, что называется подтипом, и вы можете узнать больше об этом в этом отличном ответе .

Подводя итог: вызывающий сокращает одно время жизни, чтобы соответствовать сигнатуре функции, так что функция может просто предполагать, что обе ссылки имеют одинаковое время жизни.

Я собираюсь сделать (3) что-нибудь еще!

С вашей подписью функции:

fn min<'a>(a: &'a str, b: &'a str) -> &'a str { ...}

// ...
min(&a, &b)

'a - это не время жизни заимствованных объектов. Это новое время жизни, созданное компилятором только для этого вызова. a и b будут заимствованы (или, возможно, повторно заимствованы) на время, необходимое для вызова, с расширением области возвращаемого значения (поскольку оно ссылается на тот же 'a).

Некоторые примеры:

let mut a = String::from("short");
{
    let mut b = String::from("a long long long string");
    // a and b borrowed for the duration of the println!()
    println!("{}", min(&a, &b));
    // a and b borrowed for the duration of the expression, but not
    // later (since l is not a reference)
    let l = min(&a, &b).len();

    {
        // borrowed for s's scope
        let s = min(&a, &b);
        // Invalid: b is borrowed until s goes out of scope
        // b += "...";
    }
    b += "...";  // Ok: b is no longer borrowed.
    // Borrow a and b again to print:
    println!("{}", min(&a, &b));
}

Как вы можете видеть, 'a для любого отдельного вызова отличается от времени жизни фактических a и b, которые заимствованы, хотя, конечно, оба должны пережить сгенерированное время жизни каждого вызова.

(площадка)

Помимо того, что @Lukas упомянул в ответе, вы также можете прочитать подпись функции как - Возвращенная ссылка действительна до момента, когда обе переданные ссылки действительны, то есть это соединение (также известное как AND) между временем жизни параметров.

В этом есть кое-что еще. Ниже приведены два примера кода:

    let a = String::from("short");
    {
        let c: &str;
        let b = String::from("a long long long string");
        c = min(&a, &b);

    } 

А ТАКЖЕ

let a = String::from("short");
    {
        let b = String::from("a long long long string");
        let c: &str;
        c = min(&a, &b);

    }

Первый не работает (второй работает). Может показаться, что и b, и c имеют одинаковое время жизни, поскольку они находятся в одной области действия, но порядок в области также имеет значение, поскольку в первом случае время жизни b закончится до c.