#prog #rust #rustlib #article

🦀Building Rust Procedural Macros Without quote!: Introducing zyn

I've been writing proc macros for a while now. Derive macros for internal tools, attribute macros for instrumentation. And every time, the same two problems: quote! doesn't compose (you end up passing TokenStream fragments through five layers of helper functions and writing hundreds of let statements), and debugging generated code means cargo expand and then squinting at unformatted token output hoping something jumps out.

Because of this I ended up writing the same helper methods, composite AST parsing and tokenizing types, extractors etc. I would have to copy these from project to project as needed, and eventually just decided to publish a crate so I never have to do it again.

So I built zyn — a proc macro framework with a template language, composable components, and compile-time diagnostics.

I wrote the debug system after spending two days on a bug where a generated impl block was missing a lifetime bound. cargo expand spat out 400 lines of tokens and I couldn't find it, so I built a debug system.

#prog #rust #rustlib

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

use bnum::prelude::*;
// imports common use items
// including the `Integer` type and the `n!` macro

// say we want to write a polynomial function
// which takes any unsigned or signed integer
// of any bit width and with any overflow behaviour
// for example, the polynomial could be p(x) = 2x^3 + 3x^2 + 5x + 7

fn p<const S: bool, const N: usize, const B: usize, const OM: u8>(x: Integer<S, N, B, OM>) -> Integer<S, N, B, OM> {
    n!(2)*x.pow(3) + n!(3)*x.pow(2) + n!(5)*x + n!(7)
    // type inference means we don't need to specify the width of the integers in the n! macro
}

// 2*10^3 + 3*10^2 + 5*10 + 7 = 2357
assert_eq!(p(n!(10U256)), n!(2357));
// evaluates p(10) as a 256-bit unsigned integer

type U24w = t!(U24w);
// 24-bit unsigned integer with wrapping arithmetic
type I1044s = t!(I1044s);
// 1044-bit signed integer with saturating arithmetic
type U753p = t!(U753p);
// 753-bit unsigned integer that panics on arithmetic overflow

let a = p(U24w::MAX); // result wraps around and doesn't panic
let b = p(I1044s::MAX); // result is too large to be represented by the type, so saturates to I044s::MAX
// let c = p(U753p::MAX); // this would result in panic due to overflow

#prog #rust #article

Rust threads on the GPU

#prog #rust 👀

Source

#prog #rust #php #abnormalprogramming

rustc-php: A Rust compiler written in PHP

A Rust compiler written in PHP that emits x86-64 Linux ELF binaries directly (no LLVM, no assembler, no linker). Implements ownership checking, borrow checking, type checking, move semantics, generics, traits, closures, and iterators. Useful if you need to compile Rust on a shared hosting server from 2008 where the only installed runtime is PHP.

#rust

docs.rs: building fewer targets by default

TL;DR: начиная с первого мая, если у пакета не указаны платформы, под которые он собирается, docs.rs будет собирать документацию только под x86_64-unknown-linux-gnu. Изменение касается только новых пакетов и пересборки старых.

Сейчас, если что, без метаданных документация собирается под пять платформ по умолчанию.

#prog #rust #rustlib #article #amazingopensource

jsongrep is faster than {jq, jmespath, jsonpath-rust, jql}

This article is both an introduction to a tool I have been working on called jsongrep, as well as a technical explanation of the internal search engine it uses. I also discuss the benchmarking strategy used to compare the performance of jsongrep against other JSON path-like query tools and implementations.

In this post I'll first show you the tool, then explain why it's fast (conceptually), then how it's fast (the automata theory), and finally prove it (benchmarks).

Язык запросов (именно запросов, не редактирования) намеренно ограничен, чтобы сделать его регулярным и позволить быструю реализацию поиска поверх стейт-машины.

#prog #rust #rustlib #article

Surelock

Deadlocks are a solved problem in theory — we’ve known how to prevent them since 1971. The challenge is making that prevention ergonomic enough that people actually use it. Surelock is my attempt at that: lean into Rust’s type system to make the correct thing the easy thing, and make the wrong thing a compiler error.

Работает и на no_std, полагается на lock_api для абстрагирования от реализации взаимной блокировки.

#prog #rust #python #article

How uv Works Under the Hood

Разбор архитектурных решений, позволяющих uv быть на пару порядков быстрее традиционного тулинга. Тот факт, что он написан на Rust, играет далеко не первую очередь

#prog #rust #rustreleasenotes

Вышла версия Rust 1.95.0! Как всегда, тут только выдержки, всё остальное в детальных заметках о релизе.

▪️if-гуарды на ветках match теперь могут использовать if let:

match value {
    Some(x) if let Ok(y) = compute(x) => {
        // Both `x` and `y` are available here
        println!("{}, {}", x, y);
    }
    _ => {}
}

▪️Частично примыкающее изменение: компилятор больше не выдаёт предупреждение на безусловные паттерны в if let. Автор изменения мотивирует это распространением кода навроде такого:

fn main() {
    if let x = funx() && x < usize::MAX {
        // use x
    }
}

Эта идиома позволяет привязать значение и что-то сделать/проверить с ним и при этом не пустить имя в окружающую область видимости.

▪️Добавили новый макрос cfg_select!, который позволяет сделать подобие match, но для cfg-предикатов:

cfg_select! {
    unix => {
        fn foo() { /* unix specific functionality */ }
    }
    target_pointer_width = "32" => {
        fn foo() { /* non-unix, 32-bit functionality */ }
    }
    _ => {
        fn foo() { /* fallback implementation */ }
    }
}

let is_windows_str = cfg_select! {
    windows => "windows",
    _ => "not windows",
};

Технически этот макрос не даёт новых возможностей, но без него нужные атрибуты #[cfg] нужно выписывать самостоятельно, дублируя дословно все предикаты. Ровно по этой причине стал распространён и используется cfg-if — собственно, объявление в блоге напрямую на него и ссылается.

▪️Навряд ли кого-то коснётся, но: match по enum теперь всегда ведёт себя так, как будто он читает дискриминант. Это кажется странным, но объясняется #[non_exhaustive]. Без этого изменения то, есть ли в некотором unsafe-коде UB или нет, зависело от того, определён ли enum в текущем крейте или в другом. Также match теперь читает дискриминант, даже если только одна ветка населена — без этого изменения поведение различалось в обобщённом коде и в ручной мономорфизации.

▪️Поддержку части платформ подняли до Tier 2 — в основном встраиваемые ARM-платформы от Apple (и их симуляторные версии).

▪️Стабилизированы несколько API, в частности:

🔸Конверсии по ссылке из MaybeUninit-массивов в массивы и слайсы из MaybeUninit, а также конверсии по значению между ними
🔸Аналогичные конверсии по ссылке между массивами в Cell и массивами из Cell
🔸Модуль core::range, в котором собираются диапазоны, планируемые на замену текущим. Пока что стабилизированы только RangeInclusive и его итератор. В отличие от текущих диапазонов, новый тип не служит одновременно итератором и потому реализует Copy (при Copy-индексах, разумеется) и занимает меньше места: ему не нужно хранить состояние для отслеживания поведения на последней итерации, только два индекса.
🔸Функция core::hint::cold_path для пометки пути исполнения, который не предполагается, что будет часто исполняться. Этакая замена likely/unlikely.

▪️rustdoc теперь предпочитает стабильные определения нестабильным при сортировке результатов поиска.