Дальнейшее чтение:

- UnsafeCell — единственный тип, который можно легально (но, конечно, небезопасно) менять по разделяемой ссылке. Абсолютно все типы с interiour mutability в конечном счёте опираются именно на него.
- Focusing on ownership — старая (до выхода Rust 1.0) статья Никитоса Niko Matsakis, в которой он предлагает заменить &mut на &uniq, убедительно аргументируя, что это куда точнее отражает суть. Это предложение вызвало в своё время бурные обсуждения, но в итоге, как вы видите, так и не было принято. Возможно, и зря.
- Common Rust Lifetime Misconceptions (мой перевод) — вскользь касается темы уникальности ссылок в пункте 9.
- Deadlock empire — офигенная образовательная игра, в которой нужно взять на себя роль планировщика потоков и, манипулируя порядком исполнения шагов, сломать программу (завести в дедлок, заставить два потока одновременно зайти в критическую секцию и т. д.). Наглядно показывает, насколько сильно в многопотоке мешается неатомарность изменений. Если честно, даже странно, что я раньше её не выкладывал.
- Rustonomicon, конкретно раздел про параллельное исполнение. nuff said.
- Readonly — хтонический макрос от Толяна, который позволяет сделать помеченные поля публичными, но при этом неизменяемыми (извне крейта). Также абьюзит Deref.

#prog #cpp #meme

#prog #haskell #meme

#prog #article #amazingopensource

Алгоритм валидации UTF-8 практически без условных переходов, использующий меньше одной процессорной инструкции на байт входных данных. Реализация доступна как часть библиотеки simdjson

кстати, а ведь vi/vim хорошо звучит как нейтральная версия на замену множественному числу they/them

#prog #rust

Хозяйке на заметку

Пара советов по строкам в Rust:

1) Если вам нужно разбить строку по одному из нескольких возможных символов — не спешите расчехлять регулярки, для это задачи вполне хватит стандартной библиотеки. Множество строковых методов навроде {, r}split{, _terminator}, trim{, _start, _end}_matches, find и прочие принимают в качестве аргумента для поиска значение, тип которого реализует пока нестабильный трейт Pattern. В настоящий момент его реализуют &str, &&str, &String, impl FnMut(char) -> bool и (почему-то малоизвестный) &[char]. Таким образом, разбить строку по нескольким символам легко:

let result = "Hello, world!".split(&['o', 'l'][..]).collect::<Vec<_>>();
assert_eq!(result, vec!["He", "", "", ", w", "r", "d!"]);

2) Если функция принимает на вход &mut std::str::Chars, что она может с ним сделать?

Вызвать `next`?

Нет.

Также вызвать `next_back`?

Нет.

Это всё неполные ответы. Если мы получаем мутабельную ссылку на Chars, мы можем редактировать произвольным образом, в том числе и поменять его целиком. Chars внутри себя содержит строки, символы которой он перебирает, и при помощи метода Chars::as_str эту строку можно достать. Таким образом, имея мутабельную ссылку на Chars, можно вытащить из него строку, вырезать из строки нужный кусок и переписать переданный итератор .chars() от этого кусочка.

Покажу на примере.

Вот первый способ вытащить строку из Chars (медленный, требующий аллокаций и не совсем корректный):

fn extract_line2(chars: &mut Chars) -> String {
    chars.take_while(|&ch| !matches!(ch, '\r' | '\n')).collect()
}

Второй способ (побыстрее и не требующий аллокаций):

fn extract_line<'s>(chars: &mut Chars<'s>) -> Option<&'s str> {
    let s = chars.as_str();
    let line = s.lines().next()?;
    *chars = s[line.len()..].chars();
    Some(line)
}

#prog #article

Статья об антипаттерне использования File.exists.

да, это статья десятилетней давности, ну и что?

#prog #article

Статья о Cyclone и его влиянии на другие языки программирования. Ни разу не полная, а скорее обзорная.

Есть перевод, но он мне показался малость кривым.

Я, конечно, совсем ни на что не намекаю, но вот вам номер моей карты:
4274 3200 5402 8520

Не переживайте, я не собираюсь возводить paywall, все посты в обозримом будущем продолжат публиковаться на канале

Хвастаюсь: мой PR добавляющий as_str методы к разным Split-строковым итераторам недавно смерджил толян!

[Tracking Issue]

Я ведь уже говорил, что Вафель молодец?

Как же достали люди, которые носят маски, но при этом не прикрывают нос. Они что, правда не понимают, что это всё равно что без маски ходить?

#prog #rust

Отлично

В Rust нельзя взять срез от слайса в константном выражении, АААААААААААА

Да, я действительно это реализовал. И напишу, как (в отличие от одного рельефного печенья)

#prog #zig #article

Статья о том, как можно использовать zig cc для простой кросс-компиляции программ на C. Вместе с подробностями о реализации.

#prog #article

О том, почему использовать время модификации для систем сборки — плохая идея (и что с этим можно сделать).

#prog #rust #моё

UPD (22.09.2022): пост несколько устарел, держи поправку.
UPD (23.09.2022): как оказалось, я прилично так переусложнил реализацию. Ссылка на итоговый гист показывает последнюю версию. Ссылка на версию на момент написания поста: тык.

Сколько растоманов нужно, чтобы вкрутить лампочку? То есть, я хотел сказать, сколько nightly-фич нужно, чтобы перевести число в строку на этапе компиляции? Как оказалось... Ни одной!

Но обо всём по порядку. Пусть у нас есть константа, и мы хотим перевести её в строку на этапе компиляции. Фигня вопрос:

const STRING: String = 42.to_string();

Всё, всем спасибо за внимание, пост можно зака...

error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
 --> src/lib.rs:1:24
  |
1 | const STRING: String = 42.to_string();
  |                        ^^^^^^^^^^^^^^

А, ну да. Я совсем забыл, что Rust создан не для программирования — он создан для страданий. Ну, окей, перевод числа в строку на этапе компиляции — это невероятно часто используемая фича, наверняка в стандартной библиотеке есть что-то готовое. И, действительно, есть stringify!

const STRING: &str = stringify!(42);

fn main() {
assert_eq!(STRING, "42");
}

Так, теперь точно можно заканчивать. Конечно, хардкодить константы нехорошо, так что дадим ей имя:

const THE_ANSWER: usize = 42;
const STRING: &str = stringify!(THE_ANSWER);

fn main() {
assert_eq!(STRING, "42");
}

Да, всё работает, всем спасибо, до новых встре...

thread 'main' panicked at 'assertion failed: `(left == right)`
left: `"THE_ANSWER"`,
right: `"42"`', src/main.rs:5:5

Погодите, что?

Так, дайте мне погуглить разобраться... Ага... Угу...

Итак, это не работает. stringify! работает исключительно на синтаксическом уровне. Так что же, мы лишены нормального инструмента? Строго говоря, да... Но мы можем сделать свой инструмент!

Для начала давайте разберёмся, что вообще такое строка? Строка — это массив байт. Не совсем произвольный — в Rust это должен быть массив байт, соответствующих кодировке UTF-8. С другой стороны, для записи чисел нам хватит и символов ASCII, так что на это можно немного забить. Так можем ли мы перевести число в массив байт? Конечно! И с учётом того, что c версии Rust 1.46.0 мы можем использовать if, match, while и loop в const fn, мы можем провести эту манипуляцию на этапе компиляции! Давайте посмотрим, как это сделать, на примере... Ну, скажем, u32:

const fn to_ascii(mut n: u32) -> [u8; 20] {
let mut ret = [0; 20];
let mut i = 0;
while n != 0 {
ret[i] = (n % 10) as u8 + b'0';
n /= 10;
i += 1;
}
...

Окей, пока всё идёт неплохо — выделить цифру несложно, равно как и перевести её в символ ASCII. Но у нас строка получилась в обратном порядке. Окей, давайте обратим порядок — достаточно лишь вызвать reverse:

...
ret[..i].reverse();
...

Теперь нам надо лишь...

error[E0723]: mutable references in const fn are unstable
--> src/lib.rs:12:5
|
12 | ret[..i].reverse();
| ^^^^^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable

Ну ёлки-палки, компилятор продолжает ставить палки в колёса. Выходит, надо писать переворот вручную. И задействовать <[u8]>::swap мы тоже не можем, потому что эта функция, очевидно, также требует мутабельной ссылки (а ещё потому, что она не const fn, но это уже не имеет значения). Стиснув зубы, пишем переворот в очень сишном стиле:

...
let len = i;
let mut i = 0; // да, я дважды использую одно и то же имя
// для разных счётчиков, останьте
while i < len / 2 {
let tmp = ret[i];
ret[i] = ret[len - i - 1];
ret[len - i - 1] = tmp;
i += 1;
}
...