Traits и generics

Определите границу гарантии bound T: Trait: следует ли из него реализация Trait для &T?

Как явно выбрать ассоциированный тип нужного трейта, если один тип реализует несколько трейтов с одинаковым именем ассоциированного типа?

Чем объясняется, что dyn Trait нельзя передать как обычное значение фиксированного размера, но Box<dyn Trait> можно?

Что происходит при вызове обобщённого метода трейта, если его параметр типа не встречается в аргументах?

Определите результат вызовов: какой метод выбирается через точечный синтаксис, если у типа есть одноимённый inherent-метод и реализация трейта?

trait Render {
    fn draw(&self) -> &'static str;
}

struct Button;

impl Button {
    fn draw(&self) -> &'static str { "inherent" }
}

impl Render for Button {
    fn draw(&self) -> &'static str { "trait" }
}

fn main() {
    let button = Button;
    println!("{}", button.draw());
    println!("{}", Render::draw(&button));
}

Предскажите, скомпилируется ли этот код, и объясните причину отказа или успеха:

trait Limits {
    const MAX: usize;
    fn accept(&self, value: usize) -> bool {
        value <= Self::MAX
    }
}

struct Packet;
impl Limits for Packet {
    const MAX: usize = 1024;
}

fn check(item: &dyn Limits, value: usize) -> bool {
    item.accept(value)
}

Объясните механизм: почему метод трейта, возвращающий Self, обычно делает трейт непригодным для использования как trait object?

В реализации трейта метод получил дополнительный bound, которого нет в объявлении трейта. Что произойдёт при компиляции и почему?

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

trait Fast {
    fn run(&self) -> &'static str;
}

trait Safe {
    fn run(&self) -> &'static str;
}

struct Job;

impl Fast for Job {
    fn run(&self) -> &'static str { "fast" }
}

impl Safe for Job {
    fn run(&self) -> &'static str { "safe" }
}

fn main() {
    println!("{}", Job.run());
}

Какое ограничение возникает у trait object, если его трейт содержит ассоциированный тип?

Что меняется в доступности метода трейта через trait object, если этот метод ограничен bound Self: Sized?

Что именно гарантирует ограничение «тип T живёт не меньше времени 'a», если T не является ссылкой?

В многопоточном API нужно передать объект трейта в другой поток. Что меняет добавление bound Send к типу trait object?

Каким образом for<'a> в bound меняет требования к реализации трейта, параметризованного временем жизни?

В API функция принимает объект супер-трейта, а вызывающий располагает объектом субтрейта. Как Rust выполняет такое преобразование?

Сравните параметр impl Trait в аргументе функции с именованным generic-параметром с тем же bound: какое ограничение выразительности теряется?

Нужно описать итератор, который возвращает ссылку на данные внутри самого итератора. Какую роль играет параметр 'a у ассоциированного типа Item?

trait LendingIterator {
    type Item<'a>
    where
        Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}

struct One {
    value: String,
    yielded: bool,
}

Что меняется в обобщённой функции после добавления ограничения ?Sized к параметру типа?

Разбор последствий: почему вызов одной generic-функции для десяти конкретных типов может увеличить размер бинарника?

В коде обобщённая функция печатает ассоциированный тип. Какое ограничение нужно добавить, чтобы вызов println! был корректен для любого S?

use std::fmt::Display;

trait Source {
    type Item;
    fn item(&self) -> Self::Item;
}

fn show<S: Source>(source: S) {
    println!("{}", source.item());
}