Скажите что-то плохое о канале

#prog #rust #meme

Какой же ор. Жаль, что те, кто не пишут на Rust, не поймут.

вафель держит Илью 2021 год, фото в цвете

#prog #rust #cpp

twitter.com/Nekrolm/status/1359152390386180098

#prog #python

**Pattern matching accepted for Python**

Давайте поорём

#prog #cpp

— Mom, can we have pattern matching?
— We already have pattern matching at home.

Meanwhile pattern matching at home:
https://github.com/solodon4/Mach7

#prog #go

Эх...

Никто:
Абсолютно никто:
Мой коллега в час ночи в рабочем чатике:

— Эй, а попробуйте решить на расте вот такую задачу по десериализации YAML!..

#трудовыебудни

#prog #rust #моё

Кое-что я при разработке этого макроса упустил: проверка на недостижимость кода недостаточно точна. Если строка не начинается с префикса, скажем, "java", то пытаться отщипнуть префикс "javascript" уже не имеет смысла, потому что он заведомо отсутствует. Однако мой макрос проверяет строки на (не)равенство и не учитывает их возможных структурных отношений. Сейчас мы это исправим, и пойдём по уж проторенной дорожке: вынесем нужную проверку в const fn и будем генерировать код, который не тайпчекается в случае, если проверка завершилась неудачей.

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

const fn is_prefix(s: &str, maybe_prefix: &str) -> bool {
    if maybe_prefix.len() > s.len() {
        return false;
    }

    let s = s.as_bytes();
    let mp = maybe_prefix.as_bytes();
    let mut i = 0;

    while i < mp.len() {
        if mp[i] != s[i] {
            return false;
        }
        i += 1;
    }

    true
}

Теперь немного подумаем о том, как детектировать недостижимые паттерны. Для этого нам нужно перебрать все пары различных строк из match и проверить, что для каждой такой пары строка из более поздней ветки не является префиксом строки из более ранней ветки. Так? Так, да не совсем: у ветки может быть охранное выражение, и в этом случае выполнение ветки может не произойти по совершенно произвольным причинам. Поэтому в генерируемом коде мы будем хранить не только строки, но и признак того, что охранное выражение есть, и в соответствующей функции будем эти строки пропускать. Сказано — сделано:

const fn has_unreachable_patterns(ss: &[(&str, bool)]) -> bool {
    if ss.is_empty() {
        return false;
    }

    let mut i = 0;
    let mut j;
    while i < ss.len() - 1 {
        // строки, для которых есть охранное выражение, пропускаем
        if ss[i].1 {
            i += 1;
            continue
        }
        j = i + 1;
        while j < ss.len() {
            // А вот вторую строку в паре нужно проверять всегда,
            // вне зависимости от того, есть у него охранное выражение или нет:
            // если охранного выражения нет у первой строки, то исполнение
            // до ветки со второй строкой точно не дойдёт.
            if is_prefix(ss[j].0, ss[i].0) {
                return true;
            }
            j += 1;
        }
        i += 1;
    }

    false
}

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

const _HAS_NO_UNREACHABLE_PATTERNS: [(); 0] = [
    ();
    has_unreachable_patterns(
        &[
            $((
                $prefix,
                false $(|| {stringify!($condition); true})?
            ),)*
        ]
    ) as _
];

Это довольно много, так что разберём по частям:

const _HAS_NO_UNREACHABLE_PATTERNS: [(); 0] = [
    ();
    has_unreachable_patterns(...) as _
];

Это объявление константы. Если has_unreachable_patterns(...) вычисляется в true, то оно при касте в usize становится 1, вызывая ошибку несоответствия типов.

&[
    $((
        $prefix,
        ...
    ),)*
]

Здесь мы формируем ссылку на литерал массива, элементами которого являются пары, первыми элементами которых являются строки-префиксы.

false $(|| {stringify!($condition); true})?

Здесь мы формируем значение true, если охранное выражение имеется. Сделать повтор синтаксического фрагмента без соответствующей синтаксической метапеременной нельзя, но и само выражение нам не требуется, поэтому воспользуемся стандартным трюком: переведём выражение в безвредную строку и отбросим её. На итоговое выражение это не повлияет, а наличие нужной метапеременной обеспечено. И да, это не замыкание, как может показаться, а выражение с оператором "или".

Что ж, с этим разобрались. Проверим теперь, как это работает на практике, и для этого модифицируем use_prefixes:

fn use_prefixes(s: &str) -> String {
    prefixes!(match s {
        "foo".. => s.to_string(),
        "bar".. => [s, s].concat(),
        "foobar".. => [s, "3"].concat(),
        _ => String::new(),
    })
}

Эта функция закономерно вызывает жалобы у компилятора на несоответствие типов. Отлов ошибок работает! Теперь немного поменяем определение:

fn use_prefixes(s: &str) -> String {
    prefixes!(match s {
        "foo".. if true => s.to_string(),
        "bar".. => [s, s].concat(),
        "foobar".. => [s, "3"].concat(),
        _ => String::new(),
    })
}

...И теперь у компилятора нет вопросов.

Есть недостатки у нашего решения? Определённо — помимо тех, о которых я уже писал. Во-первых, теперь это жёсткая ошибка вместо предупреждения компилятора — но да, это спорный недостаток. А во-вторых — и вот это уже недостаток куда как более существенный — ошибка компиляции не говорит о том, какие паттерны перекрываются. И я, к сожалению, не придумал, как их показывать, не выходя за пределы того, что умеет stable Rust.

#prog

Определение понятия "говнокод"

20% запросов к хранилищу файлов «Викисклад» приходятся на одно и то же фото цветка — инженеры выяснили, что трафик идёт от индийского приложения, набравшего популярность в стране после блокировки тиктока.

При этом приложение не отображает картинку, а отправляет к ней запрос во время запуска.

https://tjournal.ru/internet/337806

Вышел Rust 1.50!

Интересные (на мой взгляд) обновления:
— Присваивание полям union'ов типа MaybeUninit<_> теперь safe
— Теперь можно использовать константы в выражениях массива [x; N] (до этого можно было только :Copy типы)

— ops::{Index, IndexMut} теперь реализованы для массивов всех длин
— На unix системах, std::fs::File теперь имеет "нишу" -1, это значит что Option<File> и File могут иметь один размер

Стабилизировали bool::then, {Ord, f32, f64}::clamp, <[_]>::fill. Многие методы чисел стабилизировали как const (например pow).

Так-же метод compare_and_swap у атомиков депрекейтнули в пользу compare_exchange{,_weak} (pr), забавно что планировали это сделать ещё в (!) Rust 1.12, но забыли.

[анонс в блоге]

#prog #quotes