В преддверии выхода Rust 1.75.0, наполненным async trait-ами и return-position impl Trait in trait, надо разобраться, что такое impl Trait и с чем его едят.

После прочтения статьи вы сможете битбоксить с помощью новых акронимов понимать, что за наборы символов RPIT, RPITIT и т.д. используют в Rust сообществе.

Статья основывается на видео от Jon Gjengset

Содержание

• fn() → impl Trait

• fn(impl Trait)

• trait { type = impl Trait }

• type = impl Trait

• trait { fn() → impl Trait }

fn() → impl Trait

Feature: Return Position Impl Trait (RPIT)

Мотивация

Есть такой код:

fn only_true<I>(iter: I) -> /* ??? */ where I: Iterator<Item = bool> {
	iter.map(|x| foo(x)).filter(|&x| x)
}

Какой тип возвращает наша функция? Напишем полный тип std::iter::Filter<std::iter::Map<I, ???>, ???>. Что написать вместо вопросительных знаков? Ладно пропустим этот способ. Допустим мы хотим абстрагировать возвращаемый тип, чтобы метод возвращал тип, который реализует Iterator<Item = bool>. Вспоминаем, что можно сделать Box<dyn Iterator<Item=bool>>. Но тут не нужная аллокация памяти + динамическая диспетчеризация.

На помощь приходят экзистенциальные типы (Existential types). И теперь код выглядит следующим образом:

fn only_true<I>(iter: I) -> impl Iterator<Item = bool> /* Opaque type */
where I: Iterator<Item = bool> 
{
	iter.filter(|&x| x) /* Hidden type */
}

Тут появляются 2 новых термина:

Hidden Type - конкретный/настоящий тип объекта, который возвращается из функции.

Opaque type - интерфейс для работы с Hidden Type.

В итоге получаем следующие преимущества от impl Traits:

• абстрагирование;

• упрощение именования возвращаемого типа;

• избавления от типов, которые нельзя наименовать;

• избавление от аллокаций.

Особенности impl Traits

1. Вложенность

Типы могут быть вложенными (правда возвращаемый тип выглядит громоздким):

fn only_true<I>(iter: I) -> 
  impl Future<Output=impl Iterator<Item = bool>> /* Opaque type */
where I: Iterator<Item = bool> 
{
	async move {
		iter.filter(|&x| x) /* Hidden type */
	}
}

2. Авто-трейты

Для авто-трейтов компилятор может посмотреть Hidden Type из-за чего происходит "утечка" (leakage):

fn bar() -> impl Sized {
    ()
}

fn foo() -> impl Sized + Send + Unpin {
    bar()
}

3. Отличие от Generic

fn f1<R: Trait>() -> R {}

fn f2() -> impl Trait {}

В f1 вызывающая сторона выбирает тип.

В f2 тело метода выбирает тип.

Возвращаясь к Return Position Impl Trait (RPIT), стоит упомянуть времена жизни. В настоящий момент нельзя абстрагироваться от времен жизни в RPIT. Пример:

// Ошибка компиляции
fn foo(t: &()) -> impl Sized {
    t
}

// Ok
fn foo<'a>(t: &'a ()) -> impl Sized + 'a {
    t
}

Также возникает проблема при использовании дженерик типов:

// Ошибка компиляции
fn bar<T>(t: T) -> impl Sized {
    ()
}

fn foo() -> impl Sized + 'static {
    let s = String::new();
    
    bar(&s)
}

В настоящий момент для 2021 редакции разработчики предлагают использовать такой трюк:

trait Captures<U> {}
impl<T: ?Sized, U> Captures<U> for T {}

// Для одного лайфтайма
fn foo<'a>(t: &'a ()) -> impl Sized + Captures<&'a ()> { t }

// Для нескольких
fn foo<'a, 'b>(x: &'a (), y: &'b ()) -> impl Sized + Captures<(&'a (), &'b ())> {
    (x, y)
}

К счастью, данную проблему пофиксили и можно будет абстрагировать от времен жизни в 2024 редакции.

Почитать про времена жизни в impl Traits можно здесь.

fn(impl Trait)

Feature: Argument Position Impl Trait (APIT)

Самый простой случай, который является полу-сахаром для <T: Trait>(t: T):

fn f1<D>(display: D) where D: std::fmt::Display { /* … */ }

fn f2(display: impl std::fmt::Display) { /* … */ }

Отличия только при вызове, нельзя выбирать дженерик типы:

f1::<u32>(1); // Ok
f2(1) // Ok
f2::<u32>(1); // Ошибка

trait { type = impl Trait }

Feature: Assoc. Type Position Impl Trait (ATPIT) (Пока что в nightly)

Мотивация такая же как и у RPIT. Пример:

struct Odd;
impl IntoIterator for Odd {
    type IntoIter = impl Iterator<Item = u32>;
    fn into_iter(self) -> Self::IntoIter {
        (0u32..).filter(|x| x % 2 != 0)
    } 
}

Используются новые правила для захвата времен жизни и дженерик типов, поэтому всё захватывается автоматически:

impl<'a, T> Trait1 for Type {
    type Assoc<'b, U> = impl Trait2; // Ok
}

type = impl Trait

Feature: Type Alias Impl Trait (TAIT) (Пока что в nightly)

Позволяет использовать псевдоним impl Trait-а в различных местах, кроме структур. Пример:

type Ready<T> = impl std::future::Future<Output = T>;

fn ready<T>(t: T) -> Ready<T> {
    async move { t }
}

Времена жизни также захватываются автоматически.

trait { fn() → impl Trait }

Feature: Return position impl Trait in Trait (RPITIT)

То, что появится в версии 1.75.0. С помощью ATPIT мы можем определить возвращаемый тип для каждой функции, которая возвращает impl Trait, но это не практично, поэтому появилась эта фича. С помощью этой фичи как раз и возможны асинхронные функции в трейтах, так как async fn () -> ret равносильна fn () -> impl Future<Output = ret>. Пример:

impl MyAsyncTrait for MyStruct {
    fn foo(&mut self) -> impl Future<Output = u32> {
        async { 1 }
    } 
}

Но возникает потребность добавлять ограничения на возвращаемые типы.

trait It {
    fn iter(&self) -> impl Iterator<Item = u32>;
}

fn twice<I: It>(i: I) where ???: Clone
{
    let it = i.iter();
    it.clone().chain(it);
}

Одним из решений является Return Type Notation (в разработке). Примерный код выглядит так:

fn twice<I: It<iter(): Clone>>(i: I) {
    let it = i.iter();
    it.clone().chain(it);
}

Времена жизни захватываются автоматически.

Заключение

На самом деле impl Trait полезная вещь для абстрагирования и для уменьшения оверхеда в некоторых случаях. Асинхронные функции и RPITIT разрабатывались долго, но они появились, а значит в будущем появятся стабильные ATPIT и TAIT.

Ссылки

• Opaque types

• Impl Trait aka Look ma’, no generics! by Jon Gjengset

• Lifetime capture rules 2024

• Assoc. Type Position Impl Trait

• Type Alias Impl Trait

• Async fn in Traits and Trait { fn() → impl Trait }

• Return Type Notation