Блог*

Но прежде, чем выписывать общую операцию, немного подумаем, как именно выразить запись очередного значения. Именно, в нашем type-level Fizzbuzz списке лежат элементы двух разных семейств: числа Пеано и Fizz/Buzz/FizzBuzz. Они будут обрабатываться по разному: для чисел Пеано мы записываем их численное представление, а для *zz-типов — фиксированную строку. Вроде всё норм, ничто не мешает нам написать blanket impl для чисел Пеано и по impl-у на каждый из *zz-типов, но... нам же ведь ещё нужно рассчитать размер итогового массива, верно? А там нам нужны будут размеры записываемых строк... Какое-то неприятное дублирование вылезает, а, как известно, в надёжных системах есть только один источник истины.

Что ж, объединим формы представления в единый тип и будем в дальнейшем оперировать его значением:

enum Repr {
    Direct(&'static str),
    Numeric(usize),
}

Ну и сделаем трейт для представления элементов списка в этом виде:

trait AsRepr {
    const REPR: Repr;
}

Напишем реализации. Для чисел Пеано они будут опираться на NumericValue, ну а для *zz-типов это просто строки:

impl<T: NumericValue> AsRepr for T {
    const REPR: Repr = Repr::Numeric(T::VALUE);
}

impl AsRepr for Fizz {
    const REPR: Repr = Repr::Direct("fizz");
}

// то же самое для `Buzz` и `FizzBuzz` с нужными литералами

Заметим, что Repr даёт нам не только информацию о том, что нужно писать, но и информацию о том, сколько места для этого потребуется. И строки не дублируются. Успех!

(сказанное выше насчёт единого источника истины не относится к числам Пеано, поскольку за счёт NumericValue их числовое значение является их неотъемлемым свойством, а количества места для записи является производным от VALUE значением через n_digits)

Что ж, теперь мы можем написать трейт для представления в виде байтов — и так как мы не хотим затачиваться на конкретный размер, нам нужно обобщить его по размеру итогового буфера:

trait WriteBuf<const N: usize> {
    const BUF: ([u8; N], usize);
}

База индукции — нетронутый массив:

impl<const N: usize> WriteBuf<{ N }> for Nil {
    const BUF: ([u8; N], usize) = ([0; N], N);
}

(кстати, конкретное значение начального массива несущественно — всё равно оно потом перезаписывается целиком)

За счёт реализаций AsRepr реализация шага индукции очень проста и из всех нетривиальных операций требует лишь match по Repr:

impl<Head, Tail, const N: usize> WriteBuf<{ N }> for Cons<Head, Tail>
where
    Head: AsRepr,
    Tail: WriteBuf<{ N }>,
{
    const BUF: ([u8; N], usize) = {
        let (bytes, at) = Tail::BUF;
        match Head::REPR {
            Repr::Direct(s) =>
                write_str_with_delimiter_at(s, bytes, at),
            Repr::Numeric(n) =>
                write_num_with_delimiter_at(n, bytes, at),
        }
    };
}

Прежде, чем воспользоваться полученным инструментом, нам нужно рассчитать требуемое место. Делегируем эту задачу ещё одному трейту:

trait WriteLen {
    const LEN: usize;
}

База индукции — Nil — ничего не пишет:

impl WriteLen for Nil {
    const LEN: usize = 0;
}

Для записи Cons нужно столько же, сколько под хвост, плюс под значение в голове, плюс разделитель:

impl<Head, Tail> WriteLen for Cons<Head, Tail>
where
    Head: AsRepr,
    Tail: WriteLen,
{
    const LEN: usize = Tail::LEN
        + DELIMITER.len()
        + match Head::REPR {
            Repr::Direct(s) => s.len(),
            Repr::Numeric(n) => n_digits(n),
        };
}

Осталось только объединить эти две вещи — и можно прям сразу в константу:

const FIZZ_BUZZ_BYTES: &[u8] = &{
    let (precalculated, at) = {
        const LIST_WRITE_LEN: usize = <List as WriteLen>::LEN;
        <List as WriteBuf<LIST_WRITE_LEN>>::BUF
    };

    // проверим, что буфер перезаписан целиком
    assert!(at == 0);

    precalculated
};

Вывод результата элементарен — нам даже не нужно переводить в строку, потому что используемое API потребляет байты напрямую:

680 viewsedited 21:55