системность - понятие растяжимое. Вот у был обычный опердень рест сервисик который считал разное. Но на жабке он выжирал десятки гагов памяти и обрабатывал запросы минутами. Переписали на раст - контейнеры с ними перестали оомить, а запросы начали за болеем-еене адекватные секунды считаться.

Это системщина?

#prog #rust #rustlib #amazingopensource
Dtolnay продолжает доставлять
https://github.com/dtolnay/itoa
https://github.com/dtolnay/dtoa

#prog #rust #amazingopensource
Call to action, так сказать

если кому на праздники скучно будет - вот тут замечательный проект на расте нуждается в помощи https://github.com/crlf0710/tectonic/issues - они переписывают движок LaTeX (XeTeX) на Rust, он уже работает, сконвертирован с помощью c2rust, и проходит большинство тестов. Помощь требуется в рефакторинге и переходе на внешние крэйты там, где это возможно

Кажется, надо #github переименовать в #amazingopensource. Точнее изначальный смысл, который я вкладывал, отражает

Мне нужна бронзовая статуя русалки!

Linux: «Вот вам бронзовый куб 1x1x1 м и напильник»

Gentoo: «Вот вам медь, олово, доменная печь»

FreeBSD: «Вот вам кирка и каска с фонариком. Шахта с медью — в той стороне»

Ubuntu: «Вот вам статуя русалки»
Пользователь: «Но здесь же только хвост!»
Ubuntu: «Введите, пожалуйста apt-get install туловище русалки, apt-get install голова русалки, apt-get install руки русалки...»

MacOS: «Вот вам красивые голые парни»
Пользователь: «Ух ты! А можно потрогать?»

MacOS: «Заплатите 200 евро и активируйте функцию „Потрогать голых парней“»

Windows: «Нет. Я думаю — Вам определенно нужна чугунная статуя Чапаева...»

#meme
Не программированием единым

Немного новогоднего настроения

#prog #rust #моё
Во время решения одной из задач Advent of Code мне пришлось решать довольно заковыристую в плане владения задачу: требовалось связать цепочку интерпретаторов так, чтобы данные, выдаваемые одним экземпляром интерпретатора, использовались в качестве входных данных следующего интерпретатора.

Дополнительной сложности придал тот факт, что цепочка замкнута в петлю, поэтому просто пройтись по цепочке один раз было недостаточно. Здесь напрашиваются сопрограммы, но их в Rust нет, поэтому мне пришлось сделать дек очередей в качестве буферов для данных. В итоге в моём решении были строки вида:

buffers.push_back(input_buffer);
input_buffer = output_buffer;
output_buffer = buffers.pop_front().unwrap();

Мало того, что это выглядит уродливо и многословно, так ещё и unwrap здесь совершенно лишний: после того, как в дек положили элемент, в нём обязательно есть как минимум один элемент, поэтому pop_front заведомо вернёт Some(_).

Что же мне нужно было на самом деле? Кольцевой буфер очередей, которой обеспечивают мутабельный доступ к парам идущих подряд элементов. std::collections::VecDeque обеспечивает доступ по индексам, но моей проблемы это бы не решает, так как таким образом можно получить только доступ к отдельным элементам, но не к, скажем, внутреннему слайсу, а взять две мутабельные ссылки одновременно даже по двум заведомо разным индексам мне не дал бы borrow checker.

В тот раз я пошёл по пути наименьшего распределения и оставил тот код, который я показал выше, но потом у меня возникла мысль, что нужного мне поведения можно было бы достичь через обёртку, которая предоставляла бы нужный мне доступ через unsafe-преобразования. Такую я в итоге и написал: https://gist.github.com/AnthonyMikh/bb41179b20938ba329c3d411ddc1c679. Вот как она выглядит:

struct MutPair<T> {
inner: VecDeque<T>,
first: usize,
}

Здесь хранится только один из индексов пары, потому что второй всегда можно подсчитать, зная его и длину inner. Основной метод этого типа - get, который возвращает две мутабельные ссылки, на элемент с текущим индексом и следующим за ним:

pub fn get(&mut self) -> (&mut T, &mut T) {
let first = self.first;
let second = self.incremented();
let (head, tail, head_len) = {
let (head, tail) = self.inner.as_mut_slices();
let len = head.len();
(head.as_mut_ptr(), tail.as_mut_ptr(), len)
};

let first = unsafe { &mut *get_mut(head, tail, head_len, first) };
let second = unsafe { &mut *get_mut(head, tail, head_len, second) };

(first, second)
}

Здесь as_mut_slices возвращает мутабельные ссылки на содержимое дека (слайсов два, потому что логически единая последовательность элементов может начинаться перед концом внутреннего вектора и продолжаться от его конца). Borrow checker не даёт нам в лоб взять две мутабельные ссылки, поэтому мы используем стандартный трюк: кастуем ссылки в сырые указатели, которые компилятором уже не отслеживаются, сдвигаем их и преобразуем обратно в ссылки. Вспомогательная функция get_mut возвращает нужный нам элемента по индексу, учитывая, что последовательность по факту состоит из двух слайсов.

Считаю ли я итоговый код завершённым? Почти: я бы хотел хранить impl BorrowMut<VecDeque<T>>, чтобы MutPair можно было использовать тогда, когда невозможно отдать владение деком.