Программирование Rust

Почему метод трейта с возвращаемым impl Trait нельзя вызвать через dyn Trait?

Как Rust трактует impl Add for T, если у трейта Add параметр Rhs имеет значение по умолчанию?

Как ограничение Self: Sized на самом трейте влияет на возможность использовать его как dyn Trait?

В библиотечном трейте параметр типа имеет значение по умолчанию: что именно происходит при использовании трейта без явного параметра?

В практическом API объект хранится как Box<dyn Trait>, но реализация трейта содержит ссылку на данные вызывающего кода. Какой lifetime-bound потребуется и почему?

Практическая ситуация: API должен принимать любой тип с трейтом Readable, кроме типов с признаком Encrypted. Почему такой bound нельзя выразить напрямую в Rust?

В библиотечном API проверьте, достаточно ли bound трейта для вызова clone у ассоциированного типа без повторения ограничения:

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

fn duplicate<C: Container>(container: C) -> (C::Item, C::Item) {
    let value = container.item();
    (value.clone(), value)
}

Скомпилируется ли функция duplicate?

Как компилятор трактует параметр типа в реализации трейта, который упомянут только в where-bound, но не связан с Self?

Проверьте, скомпилируется ли вызов обобщённой функции для Box<dyn Describe>, и объясните результат.

trait Describe {
    fn describe(&self) -> &'static str;
}

struct Item;
impl Describe for Item {
    fn describe(&self) -> &'static str { "item" }
}

fn inspect<T: Describe>(value: T) {
    println!("{}", value.describe());
}

fn main() {
    let boxed: Box<dyn Describe> = Box::new(Item);
    inspect(boxed);
}

Какие свойства скрытого типа доступны вызывающему функции с возвращаемым impl Trait, если они не указаны в её bounds?

Определите границу гарантии 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, если его трейт содержит ассоциированный тип?