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

Что меняется в доступности метода трейта через 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());
}

В функции разные ветви возвращают разные типы итераторов. Какое требование impl Trait нарушено в этом коде?

fn numbers(only_even: bool) -> impl Iterator<Item = u32> {
    if only_even {
        0..10
    } else {
        (0..10).filter(|x| x % 2 == 0)
    }
}

В библиотеке нужно связать внешний трейт с внешним типом: какое правило Rust блокирует такую реализацию и зачем оно нужно?

Представьте обобщённую функцию, принимающую итератор: что даёт ей ограничение Item = u8 по сравнению с одним лишь ограничением Iterator?

В API тип ограничен дочерним трейтом: какие гарантии о базовом трейте следуют из такого bound?

Разберите ошибку компиляции: почему Rust считает реализации пересекающимися, хотя Token сейчас не реализует Copy?

trait Marker {}

impl<T: Copy> Marker for T {}

struct Token;

impl Marker for Token {}

В каком случае обобщённый метод делает трейт непригодным для использования через трейтовый объект?

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

Объясните механизм выбора между статической и динамической диспетчеризацией при вызове метода трейта через обобщённый параметр и через объект трейта.

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

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