Блог*

Все эти способы объединяет один недостаток: они толком не позволяют отловить ситуацию, когда мы по каким-то причинам ошиблись в подсчёте размера итогового буфера и предоставили его меньшего размера, чем надо. Так что я в итоге выбрал способ, отличный, от всех этих: прокидываемый индекс является индексом, на единицу бо‌льшим места, куда нужно писать очередной байт. Безусловно, это означает - 1 на всех операциях индексации, но нам не нужно делать последнюю итерацию особым случаем, мы получим ошибку при использовании слишком маленького буфера, а убедиться в том, что буфер не слишком большой, мы можем пост-фактум, проверив, что индекс места для записи равен нулю.

Итак, с этим определились. Теперь нам нужны операции для записи нужных значений в нужное место в переданном массиве байт. Так как нам нужно записывать перевод строки и после чисел, и после fizz/buzz, логично вынести операцию записи строки отдельно (а ещё это даст нам возможность забесплатно поменять используемый разделитель, просто поменяв определение именованной константы):

const fn write_str_at<const N: usize>(
    s: &str,
    mut bytes: [u8; N],
    mut at: usize,
) -> ([u8; N], usize) {
    let mut i = s.len();
    let s = s.as_bytes();

    while i > 0 {
        bytes[at - 1] = s[i - 1];
        at -= 1;
        i -= 1;
    }

    (bytes, at)
}

Ничего сложного, просто побайтовое копирование строки в нужное место (с конца). Конечно, тот факт, что мы не можем использовать богатый инструментарий std в const fn, делает этот код менее красивым, чем он мог бы быть, но и без этого код довольно понятен. Отмечу, что мы можем передать строку длиннее переданного буфера, но в этом случае код завалится на декременте at и в const-контексте прервёт компиляцию.

С использованием этой вспомогательной функции запись строки с переводом строки становится совсем простой:

const DELIMITER: &str = "\n";

const fn write_str_with_delimiter_at<const N: usize>(
    s: &str,
    mut bytes: [u8; N],
    mut at: usize,
) -> ([u8; N], usize) {
    (bytes, at) = write_str_at(DELIMITER, bytes, at);
    write_str_at(s, bytes, at)
}

Запись же числа концептуально схожа с записью строки, с той лишь разницей, что нужные значения мы вычисляем на лету вместо того, чтобы индексироваться в строку. Нужно только обработать специальный случай, когда переданное число равно нулю, потому что без этого мы вообще ничего для нуля писать не будем (на самом деле в этой программе этот путь исполнения никогда не затрагивается, потому что создаваемый нами fizzbuzz-список не содержит нуля, но... Давайте не будем писать код со слишком большими допущениями по умолчанию):

const fn write_num_with_delimiter_at<const N: usize>(
    mut n: usize,
    mut bytes: [u8; N],
    mut at: usize,
) -> ([u8; N], usize) {
    (bytes, at) = write_str_at(DELIMITER, bytes, at);

    if n == 0 {
        bytes[at - 1] = b'0';
        at -= 1;
        return (bytes, at);
    }

    while n != 0 {
        bytes[at - 1] = (n % 10) as u8 + b'0';
        at -= 1;
        n /= 10;
    }

    (bytes, at)
}

(я не стал писать не-_delimiter вариант, потому что он и так использовался бы в одном месте)

Хорошо, нужные строительные блоки есть. Теперь нужно собрать их них что-то полезное. Для того, чтобы собрать массив байтиков для гетерогенного списка, нам нужно на шаге индукции получить заполненный массив для хвоста (вместе с местом, куда надо писать дальше) и дописать порцию, соответствующую голове. Базой индукции в этом случае (для Nil) будет чистый массив и at, равный его длине.

618 viewsedited 21:55