Rust на примерах

struct Ref<'a, T: 'a>(&'a T);

// `Ref` содержит ссылки на обобщённый тип `T` который имеет

// неизвестное время жизни `'a`. `T` ограничен так, что любые

// *ссылки* в `T` должны пережить `'a`.

// Кроме того, время жизни `Ref` не может превышать `'a`.

// Обобщённая функция, которая показывает использование типажа `Debug`.

fn print(t: T) where

T: Debug {

println!("`print`: t это {:?}", t);

}

// Здесь приводится ссылка на `T`, где `T` реализует

// `Debug` и все *ссылки* в `T` переживают `'a`.

// К тому же, `'a` должен пережить функцию.

fn print_ref<'a, T>(t: &'a T) where

T: Debug + 'a {

println!("`print_ref`: t это {:?}", t);

}

fn main() {

let x = 7;

let ref_x = Ref(&x);

print_ref(&ref_x);

print(ref_x);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Смотрите также:

Обобщения, ограничения в обобщениях и множественные ограничения в обобщениях

Приведение (coercion)

Длинное время жизни может быть приведено к короткому, благодаря чему всё работает нормально внутри области видимости, хотя кажется, что не должно. Это достигается за счёт того что компилятор Rust выполняет приведение времён жизни и за счёт объявления разницы между ними разницы:

// Здесь Rust выводит наиболее короткое время жизни.

// Затем обе ссылки приводятся к этому времени жизни.

fn multiply<'a>(first: &'a i32, second: &'a i32) -> i32 {

first * second

}

// `<'a: 'b, 'b>` читается как "время жизни `'a` не меньше, чем время жизни `'b`".

// Здесь мы получаем `&'a i32` и в результате приведения возвращаем `&'b i32`.

fn choose_first<'a: 'b, 'b>(first: &'a i32, _: &'b i32) -> &'b i32 {

first

}

fn main() {

let first = 2; // Более длинное время жизни

{

let second = 3; // Более короткое время жизни

println!("Произведение равно {}", multiply(&first, &second));

println!("{} первое", choose_first(&first, &second));

};

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה