Traits и generics

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

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

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

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

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

trait Marker {}

impl<T: Copy> Marker for T {}

struct Token;

impl Marker for Token {}

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

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

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

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

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

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

use std::fmt::Display;

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

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

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

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

Нужно описать итератор, который возвращает ссылку на данные внутри самого итератора. Какую роль играет параметр '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,
}

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

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

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

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

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

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

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