trait Trait {}
impl<T> Trait for T {}
impl<T> Trait for &T {} // ошибка компиляции
impl<T> Trait for &mut T {} // ошибка компиляции

error[E0119]: conflicting implementations of trait `Trait` for type `&_`:
--> src/lib.rs:5:1
  |
3 | impl<T> Trait for T {}
  | ------------------- first implementation here
4 |
5 | impl<T> Trait for &T {}
  | ^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`
error[E0119]: conflicting implementations of trait `Trait` for type `&mut _`:
--> src/lib.rs:7:1
  |
3 | impl<T> Trait for T {}
  | ------------------- first implementation here
...
7 | impl<T> Trait for &mut T {}
  | ^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `&mut _`

trait Trait {}
impl<T> Trait for &T {} // компилируется
impl<T> Trait for &mut T {} // компилируется

fn main() {
    let str_literal: &'static str = "str literal";
}

static BYTES: [u8; 3] = [1, 2, 3];
static mut MUT_BYTES: [u8; 3] = [1, 2, 3];
fn main() {
   MUT_BYTES[0] = 99; // ошибка компиляции, изменение статической переменной является небезопасной операцией
    unsafe {
        MUT_BYTES[0] = 99;
        assert_eq!(99, MUT_BYTES[0]);
    }
}

use rand;
// генерирует во время исполнения случайные 'static str ссылки
fn rand_str_generator() -> &'static str {
    let rand_string = rand::random::<u64>().to_string();
    Box::leak(rand_string.into_boxed_str())
}

use rand;
fn drop_static<T: 'static>(t: T) {
    std::mem::drop(t);
}
fn main() {
    let mut strings: Vec<String> = Vec::new();
    for _ in 0..10 {
        if rand::random() {
            // все строки сгенерированны случайным образом
            // и динамически созданы в куче во время исполнения
            let string = rand::random::<u64>().to_string();
            strings.push(string);
        }
    }
    // строки являются владеющими типами,
    // поэтому они удовлетворяют ограничению 'static
    for mut string in strings {
        // все строки изменяемы
        string.push_str("a mutation");
        // все строки динамически уничтожаемы
        drop_static(string); // компилируется
    }
    // все строки были инвалидированы до окончания работы программы
    println!("i am the end of the program");
}

// принимает только ссылки, ограниченные 'a
fn t_ref<'a, T: 'a>(t: &'a T) {}
// принимает любые типы, ограниченные 'a
fn t_bound<'a, T: 'a>(t: T) {}
// владеющий тип, содержащий ссылку
struct Ref<'a, T: 'a>(&'a T);
fn main() {
    let string = String::from("string");
    t_bound(&string); // компилируется
    t_bound(Ref(&string)); // компилируется
    t_bound(&Ref(&string)); // компилируется
    t_ref(&string); // компилируется
    t_ref(Ref(&string)); // ошибка компиляции, ожидалась ссылка, обнаружена структура
    t_ref(&Ref(&string)); // компилируется
    // строковая переменная ограничена 'static, которое, в свою очередь, ограничено 'a
    t_bound(string); // компилируется
}

// неявно
fn print(s: &str);
// выведено
fn print<'a>(s: &'a str);
// неявно
fn trim(s: &str) -> &str;
// выведено
fn trim<'a>(s: &'a str) -> &'a str;
// правила вывода неприменимы, нельзя вывести время жизни возвращаемого значения,
// т. к. нет входных времён жизни
fn get_str() -> &str;
// возможные варианты явных аннотаций
fn get_str<'a>() -> &'a str; // обобщённая версия
fn get_str() -> &'static str; // 'static версия
// правила вывода неприменимы, нельзя вывести время жизни возвращаемого значения,
// т. к. есть несколько входных времён жизни
fn overlap(s: &str, t: &str) -> &str;
// возможные варианты с явным указанием времён жизни
// (но всё равно с частичным выводом)
fn overlap<'a>(s: &'a str, t: &str) -> &'a str; // возвращаемое значение не может прожить дольше s
fn overlap<'a>(s: &str, t: &'a str) -> &'a str; // возвращаемое значение не может прожить дольше t
fn overlap<'a>(s: &'a str, t: &'a str) -> &'a str; // возвращаемое значение не может прожить дольше s и t
fn overlap(s: &str, t: &str) -> &'static str; // возвращаемое значение может прожить дольше s и t
fn overlap<'a>(s: &str, t: &str) -> &'a str; // никакой связи между входными и выходными временами жизни
// выведено
fn overlap<'a, 'b>(s: &'a str, t: &'b str) -> &'a str;
fn overlap<'a, 'b>(s: &'a str, t: &'b str) -> &'b str;
fn overlap<'a>(s: &'a str, t: &'a str) -> &'a str;
fn overlap<'a, 'b>(s: &'a str, t: &'b str) -> &'static str;
fn overlap<'a, 'b, 'c>(s: &'a str, t: &'b str) -> &'c str;
// неявно
fn compare(&self, s: &str) -> &str;
// выведено
fn compare<'a, 'b>(&'a self, &'b str) -> &'a str;

struct ByteIter<'a> {
    remainder: &'a [u8]
}
impl<'a> ByteIter<'a> {
    fn next(&mut self) -> Option<&u8> {
        if self.remainder.is_empty() {
            None
        } else {
            let byte = &self.remainder[0];
            self.remainder = &self.remainder[1..];
            Some(byte)
        }
    }
}
fn main() {
    let mut bytes = ByteIter { remainder: b"1" };
    assert_eq!(Some(&b'1'), bytes.next());
    assert_eq!(None, bytes.next());
}

fn main() {
    let mut bytes = ByteIter { remainder: b"1123" };
    let byte_1 = bytes.next();
    let byte_2 = bytes.next();
    if byte_1 == byte_2 {
        // что-то делаем
    }
}

error[E0499]: cannot borrow `bytes` as mutable more than once at a time
  --> src/main.rs:20:18
   |
19 |     let byte_1 = bytes.next();
   |                  ----- first mutable borrow occurs here
20 |     let byte_2 = bytes.next();
   |                  ^^^^^ second mutable borrow occurs here
21 |     if byte_1 == byte_2 {
   |        ------ first borrow later used here

struct ByteIter<'a> {
    remainder: &'a [u8]
}
impl<'a> ByteIter<'a> {
    fn next<'b>(&'b mut self) -> Option<&'b u8> {
        if self.remainder.is_empty() {
            None
        } else {
            let byte = &self.remainder[0];
            self.remainder = &self.remainder[1..];
            Some(byte)
        }
    }
}

struct ByteIter<'remainder> {
    remainder: &'remainder [u8]
}
impl<'remainder> ByteIter<'remainder> {
    fn next<'mut_self>(&'mut_self mut self) -> Option<&'mut_self u8> {
        if self.remainder.is_empty() {
            None
        } else {
            let byte = &self.remainder[0];
            self.remainder = &self.remainder[1..];
            Some(byte)
        }
    }
}

struct ByteIter<'remainder> {
    remainder: &'remainder [u8]
}
impl<'remainder> ByteIter<'remainder> {
    fn next(&mut self) -> Option<&'remainder u8> {
        if self.remainder.is_empty() {
            None
        } else {
            let byte = &self.remainder[0];
            self.remainder = &self.remainder[1..];
            Some(byte)
        }
    }
}
fn main() {
    let mut bytes = ByteIter { remainder: b"1123" };
    let byte_1 = bytes.next();
    let byte_2 = bytes.next();
    std::mem::drop(bytes); // теперь мы даже можем удалить итератор!
    if byte_1 == byte_2 { // компилируется
        // что-то делаем
    }
}

#[derive(Debug)]
struct NumRef<'a>(&'a i32);
impl<'a> NumRef<'a> {
    // моя структура параметризована 'a, так что мне нужно
    // также аннотировать self 'a, верно? (ответ: нет, не верно)
    fn some_method(&'a mut self) {}
}
fn main() {
    let mut num_ref = NumRef(&5);
    num_ref.some_method(); // изменяемо заимствует num_ref до конца её времени жизни
    num_ref.some_method(); // ошибка компиляции
    println!("{:?}", num_ref); // также ошибка компиляции
}

#[derive(Debug)]
struct NumRef<'a>(&'a i32);
impl<'a> NumRef<'a> {
    // на mut self больше нет 'a
    fn some_method(&mut self) {}
    // строчка выше рассахаривается таким образом
    fn some_method_desugared<'b>(&'b mut self){}
}
fn main() {
    let mut num_ref = NumRef(&5);
    num_ref.some_method();
    num_ref.some_method(); // компилируется
    println!("{:?}", num_ref); // компилируется
}

use std::cell::Ref;
trait Trait {}
// неявно
type T1 = Box<dyn Trait>;
// выведено, Box<T> не налагает ограничений времён жизни на T,
// поэтому выводится 'static
type T2 = Box<dyn Trait + 'static>;
// неявно
impl dyn Trait {}
// выведено
impl dyn Trait + 'static {}
// неявно
type T3<'a> = &'a dyn Trait;
// выведено, &'a T требует T: 'a, поэтому выводится 'a
type T4<'a> = &'a (dyn Trait + 'a);
// неявно
type T5<'a> = Ref<'a, dyn Trait>;
// выведено, Ref<'a, T> требует T: 'a, поэтому выводится 'a
type T6<'a> = Ref<'a, dyn Trait + 'a>;
trait GenericTrait<'a>: 'a {}
// неявно
type T7<'a> = Box<dyn GenericTrait<'a>>;
// выведено
type T8<'a> = Box<dyn GenericTrait<'a> + 'a>;
// неявно
impl<'a> dyn GenericTrait<'a> {}
// выведено
impl<'a> dyn GenericTrait<'a> + 'a {}

trait Trait {}
struct Struct {}
struct Ref<'a, T>(&'a T);
impl Trait for Struct {}
impl Trait for &Struct {} // реализация трейта напрямую на ссылке
impl<'a, T> Trait for Ref<'a, T> {} // реализация трейта для типа, содержащего ссылку

use std::fmt::Display;
fn dynamic_thread_print(t: Box<dyn Display + Send>) {
    std::thread::spawn(move || {
        println!("{}", t);
    }).join();
}
fn static_thread_print<T: Display + Send>(t: T) {
    std::thread::spawn(move || {
        println!("{}", t);
    }).join();
}

error[E0310]: the parameter type `T` may not live long enough
  --> src/lib.rs:10:5
   |
9  | fn static_thread_print<T: Display + Send>(t: T) {
   |                        -- help: consider adding an explicit lifetime bound...: `T: 'static +`
10 |     std::thread::spawn(move || {
   |     ^^^^^^^^^^^^^^^^^^
   |
note: ...so that the type `[closure@src/lib.rs:10:24: 12:6 t:T]` will meet its required lifetime bounds
  --> src/lib.rs:10:5
   |
10 |     std::thread::spawn(move || {
   |     ^^^^^^^^^^^^^^^^^^

use std::fmt::Display;
fn dynamic_thread_print(t: Box<dyn Display + Send>) {
    std::thread::spawn(move || {
        println!("{}", t);
    }).join();
}
fn static_thread_print<T: Display + Send + 'static>(t: T) {
    std::thread::spawn(move || {
        println!("{}", t);
    }).join();
}

use std::fmt::Display;
fn dynamic_thread_print(t: Box<dyn Display + Send + 'static>) {
    std::thread::spawn(move || {
        println!("{}", t);
    }).join();
}
fn static_thread_print<T: Display + Send + 'static>(t: T) {
    std::thread::spawn(move || {
        println!("{}", t);
    }).join();
}

use std::fmt::Display;
fn box_displayable<T: Display>(t: T) -> Box<dyn Display> {
    Box::new(t)
}

error[E0310]: the parameter type `T` may not live long enough
--> src/lib.rs:4:5
  |
3 | fn box_displayable<T: Display>(t: T) -> Box<dyn Display> {
  |                    -- help: consider adding an explicit lifetime bound...: `T: 'static +`
4 |     Box::new(t)
  |     ^^^^^^^^^^^
  |
note: ...so that the type `T` will meet its required lifetime bounds
--> src/lib.rs:4:5
  |
4 |     Box::new(t)
  |     ^^^^^^^^^^^

use std::fmt::Display;
fn box_displayable<T: Display + 'static>(t: T) -> Box<dyn Display> {
    Box::new(t)
}

use std::fmt::Display;
fn box_displayable<'a, T: Display + 'a>(t: T) -> Box<dyn Display + 'a> {
    Box::new(t)
}

fn return_first(a: &str, b: &str) -> &str {
    a
}

error[E0106]: missing lifetime specifier
--> src/lib.rs:1:38
  |
1 | fn return_first(a: &str, b: &str) -> &str {
  |                    ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter
  |
1 | fn return_first<'a>(a: &'a str, b: &'a str) -> &'a str {
  |                ^^^^    ^^^^^^^     ^^^^^^^     ^^^

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

struct Has<'lifetime> {
    lifetime: &'lifetime str,
}
fn main() {
    let long = String::from("long");
    let mut has = Has { lifetime: &long };
    assert_eq!(has.lifetime, "long");
    {
        let short = String::from("short");
        // "переключиться" на более короткое время жизни
        has.lifetime = &short;
        assert_eq!(has.lifetime, "short");
        // "переключиться обратно" на более длинное время жизни (на самом деле нет)
        has.lifetime = &long;
        assert_eq!(has.lifetime, "long");
        // здесь `short` удаляется
    }
    // ошибка компиляции, `short` все ещё "заимствовано" после удаления
    assert_eq!(has.lifetime, "long");
}

error[E0597]: `short` does not live long enough
  --> src/main.rs:11:24
   |
11 |         has.lifetime = &short;
   |                        ^^^^^^ borrowed value does not live long enough
...
15 |     }
   |     - `short` dropped here while still borrowed
16 |     assert_eq!(has.lifetime, "long");
   |     --------------------------------- borrow later used here

struct Has<'lifetime> {
    lifetime: &'lifetime str,
}
fn main() {
    let long = String::from("long");
    let mut has = Has { lifetime: &long };
    assert_eq!(has.lifetime, "long");
    // этот блок никогда не будет выполнен
    if false {
        let short = String::from("short");
        // "переключиться" на более короткое время жизни
        has.lifetime = &short;
        assert_eq!(has.lifetime, "short");
        // "переключится обратно" на более длинное время жизни (на самом деле нет)
        has.lifetime = &long;
        assert_eq!(has.lifetime, "long");
        // здесь `short` удаляется
    }
    // все ещё ошибка компиляции, `short` все ещё "заимствовано" после удаления
    assert_eq!(has.lifetime, "long");
}

fn takes_shared_ref(n: &i32) {}
fn main() {
    let mut a = 10;
    takes_shared_ref(&mut a); // компилируется
    takes_shared_ref(&*(&mut a)); // рассахаренная строка выше
}

fn main() {
    let mut a = 10;
    let b: &i32 = &*(&mut a); // перезаимствована как иммутабельная
    let c: &i32 = &a;
    dbg!(b, c); // ошибка компиляции
}

error[E0502]: cannot borrow `a` as immutable because it is also borrowed as mutable
--> src/main.rs:4:19
  |
3 |     let b: &i32 = &*(&mut a);
  |                     -------- mutable borrow occurs here
4 |     let c: &i32 = &a;
  |                   ^^ immutable borrow occurs here
5 |     dbg!(b, c);
  |          - mutable borrow later used here

use std::sync::Mutex;
struct Struct {
    mutex: Mutex<String>
}
impl Struct {
    // ослабляет мутабельную ссылку на self до разделяемой
    fn get_string(&mut self) -> &str {
        self.mutex.get_mut().unwrap()
    }
    fn mutate_string(&self) {
        // если бы Rust разрешал ослабление мутабельных ссылок до разделяемых,
        // то следующая строка делала бы недействительной все
        // разделяемые ссылки, возвращённые get_string
        *self.mutex.lock().unwrap() = "surprise!".to_owned();
    }
}
fn main() {
    let mut s = Struct {
        mutex: Mutex::new("string".to_owned())
    };
    let str_ref = s.get_string(); // мутабельная ссылка ослаблена до разделяемой
    s.mutate_string(); // str_ref инвалидирована, теперь это висячий указатель
    dbg!(str_ref); // ошибка компиляции, как и ожидалось
}

// ослабляет изменяемый T до разделяемого T
fn some_function<T>(some_arg: &mut T) -> &T;
struct Struct;
impl Struct {
    // ослабляет мутабельную ссылку на self до разделяемой
    fn some_method(&mut self) -> &Self;
    // ослабляет мутабельную ссылку на self до разделяемой ссылки на T
    fn other_method(&mut self) -> &T;
}

use std::collections::HashMap;
type PlayerID = i32;
#[derive(Debug, Default)]
struct Player {
    score: i32,
}
fn start_game(player_a: PlayerID, player_b: PlayerID, server: &mut HashMap<PlayerID, Player>) {
    // получить от сервера игроков или создать и сохранить новых, если их ещё нет
    let player_a: &Player = server.entry(player_a).or_default();
    let player_b: &Player = server.entry(player_b).or_default();
    // делаем что-то с игроками
    dbg!(player_a, player_b); // ошибка компиляции
}

use std::collections::HashMap;
type PlayerID = i32;
#[derive(Debug, Default)]
struct Player {
    score: i32,
}
fn start_game(player_a: PlayerID, player_b: PlayerID, server: &mut HashMap<PlayerID, Player>) {
    // избавляемся от изменяемых ссылок на Player, так как мы всё равно не можем использовать их вместе
    server.entry(player_a).or_default();
    server.entry(player_b).or_default();
    // снова получаем доступ к игрокам, на этот раз по неизменяемым ссылкам, без неявных перезаимствований
    let player_a = server.get(&player_a);
    let player_b = server.get(&player_b);
    // что-то делаем с игроками
    dbg!(player_a, player_b); // компилируется
}

fn function(x: &i32) -> &i32 {
    x
}
fn main() {
    let closure = |x: &i32| x;
}

error: lifetime may not live long enough
--> src/main.rs:6:29
  |
6 |     let closure = |x: &i32| x;
  |                       -   - ^ returning this value requires that `'1` must outlive `'2`
  |                       |   |
  |                       |   return type of closure is &'2 i32
  |                       let's call the lifetime of this reference `'1`

// время жизни аргумента применяется к возвращаемому значению
fn function<'a>(x: &'a i32) -> &'a i32 {
    x
}
fn main() {
    // аргумент и возвращаемое значение получают разные времена жизни
    let closure = for<'a, 'b> |x: &'a i32| -> &'b i32 { x };
    // внимание, строка выше не является корректным синтаксисом Rust, но она требуется для пояснения
}

fn main() {
    // кастуем к трейт-объекту, значение становится безразмерным, упс, ошибка компиляции
    let identity: dyn Fn(&i32) -> &i32 = |x: &i32| x;
    // можем выделить в куче, но это как-то неуклюже
    let identity: Box<dyn Fn(&i32) -> &i32> = Box::new(|x: &i32| x);
    // можем не аллоцировать вовсе, а создать статическую ссылку
    let identity: &dyn Fn(&i32) -> &i32 = &|x: &i32| x;
    // рассахаренная строка выше :)
    let identity: &'static (dyn for<'a> Fn(&'a i32) -> &'a i32 + 'static) = &|x: &i32| -> &i32 { x };
    // в идеале нам хотелось бы написать так, но это некорректный синтаксис
    let identity: impl Fn(&i32) -> &i32 = |x: &i32| x;
    // это тоже было бы хорошо, но это также некорректный синтаксис
    let identity = for<'a> |x: &'a i32| -> &'a i32 { x };
    // так как "impl trait" работает в позиции возвращаемого значения
    fn return_identity() -> impl Fn(&i32) -> &i32 {
        |x| x
    }
    let identity = return_identity();
    // более общая версия предыдущего решения
    fn annotate<T, F>(f: F) -> F where F: Fn(&T) -> &T {
        f
    }
    let identity = annotate(|x: &i32| x);
}

fn get_str<'a>() -> &'a str; // обобщённая версия
fn get_str() -> &'static str; // версия со 'static

use rand;
fn generic_str_fn<'a>() -> &'a str {
    "str"
}
fn static_str_fn() -> &'static str {
    "str"
}
fn a_or_b<T>(a: T, b: T) -> T {
    if rand::random() {
        a
    } else {
        b
    }
}
fn main() {
    let some_string = "string".to_owned();
    let some_str = &some_string[..];
    let str_ref = a_or_b(some_str, generic_str_fn()); // компилируется
    let str_ref = a_or_b(some_str, static_str_fn()); // компилируется
}

use rand;
fn generic_str_fn<'a>() -> &'a str {
    "str"
}
fn static_str_fn() -> &'static str {
    "str"
}
fn a_or_b_fn<T, F>(a: T, b_fn: F) -> T
    where F: Fn() -> T
{
    if rand::random() {
        a
    } else {
        b_fn()
    }
}
fn main() {
    let some_string = "string".to_owned();
    let some_str = &some_string[..];
    let str_ref = a_or_b_fn(some_str, generic_str_fn); // компилируется
    let str_ref = a_or_b_fn(some_str, static_str_fn); // ошибка компиляции
}

error[E0597]: `some_string` does not live long enough
  --> src/main.rs:23:21
   |
23 |     let some_str = &some_string[..];
   |                     ^^^^^^^^^^^ borrowed value does not live long enough
...
25 |     let str_ref = a_or_b_fn(some_str, static_str_fn);
   |                   ---------------------------------- argument requires that `some_string` is borrowed for `'static`
26 | }
   | - `some_string` dropped here while still borrowed