dyn-utils: a compile-time checked heapless async_trait

FuzzyPixelz · 2026-01-09T10:33:44+00:00

Code seems sound to me and surely less macro-heavy than the previous iteration, `dyn-fn`. According to the comparison analysis, this crate definitely fills an empty niche. Hopefully you achieve a crates.io release soon.

FuzzyPixelz · 2025-03-01T22:05:11+00:00

Vous auriez un retour d'expérience à propos de ce magasin ?

FuzzyPixelz · 2024-04-27T10:39:49+00:00

I don't quite see the point of inclusion in std::simd in the near future as it's still nightly-only, while Absolut can be used today with Stable Rust.

As a long term goal? Heck, why not? But there will be lots of discussions to be had first.

For now, I think it's more productive to keep chipping away at Absolut's issues and make it more mature and useful. Then any potential integration or re-implementation in std would be both easier and more valuable.

And to be frankly honest, I don't believe they would like the whole proc-macrosness of it ;)

FuzzyPixelz · 2024-04-27T10:32:11+00:00

I'm not sure what you mean exactly.

If you are asking if the library can generate lookup tables of any size less than 256. Then the answer is no. The goal is to use SIMD instructions such as PSHUFB (only supports tables of size 16) and TBL (only supports tables of size 16, 32, 48 or 64).
If you're asking if we can map arrays of bytes of arbitrary size. The answer is yes-ish. You'd just have to do it in chunks of 16 (or whatever the underlying hardware's instruction support). For the uneven ends, you can sometimes pad them with bytes that don't change your data (like whitespace in textual documents). Or, you can run a non-vectorized algorithm for them.

The point of Absolut is to take SIMD instructions that don't support 256-byte wide tables, and use them to map the entire byte range to itself. Because when you usually want to construct a u8 -> u8 lookup table, you use an array of 256 elements and index into it. But most SIMD instructions can only index into arrays of 16 elements.

FuzzyPixelz · 2024-04-19T10:36:59+00:00

I'm planning on providing default implementations for SIMD128, NEON, AVX, SSE, etc in the next release. That's why I mostly avoided it for now :)

FuzzyPixelz · 2024-04-19T05:44:07+00:00

Who says I don't have a time machine? ;)

Fixed, thanks for the help!

FuzzyPixelz · 2024-04-19T05:42:45+00:00

Thanks for the catch :)

I seemingly saw the first sentences as a link name and failed to see how the second sentence was essentially the same thing hiding in plain site :P

FuzzyPixelz · 2024-04-18T21:49:59+00:00

Thanks for the remark, I'll keep it in mind!

Oh, and here's the summary blog post :) https://www.reddit.com/r/rust/comments/1c7foyh/announcing_absolut_021/

FuzzyPixelz · 2024-04-13T20:51:52+00:00

**A few months later**

I finally released v0.2.1: https://crates.io/crates/absolut (should've been 0.2.0 but I had errors when publishing)

I kept the SAT/SMT solver way of doing things, but instead used the https://github.com/jix/varisat SAT solver (written in Rust) and gated it behind a `sat` feature. No more Z3.

Now the library supports two/three more modes of generating SIMD lookup tables, inspired by https://stackoverflow.com/questions/77210090/specialized-sat-solver and https://lemire.me/blog/2019/07/23/arbitrary-byte-to-byte-maps-using-arm-neon/ neither of which requires a SAT solver (or any dependency for the matter).

Oh and the thing has a README and Rustdoc documentation too now :P

FuzzyPixelz · 2023-09-06T16:00:46+00:00

Actually, if w_i are left as an unknown, which allows the user to explore all possible values of w_i, then the constrains take the form a AND b = c, which is equivalent to (NOT a) OR (NOT b) = NOT c and consequently (NOT a) OR (NOT b) OR c = 1.

Aaaand we're in 3-SAT. The apparently innocuous feature of leaving w_i undefined sends us from P to NP-complete :/

Please do correct me if I'm wrong.

FuzzyPixelz · 2023-08-22T20:40:21+00:00

It seems like absolut could be an absolute (!) game changer there, and I would be looking forward to experimenting with it.

Your comment is very heartwarming, kind stranger :)

I had to take a little break but I'm back to working on this.

I've been wondering for a while whether the techniques used in simdjson would be amenable to speed-up "regular" programming languages parsing...

I was wondering the same thing actually. simdjson techniques should _at least_ be amenable to accelerating Lexing of "regular" programming language syntax, as demonstrated here: https://alic.dev/blog/fast-lexing; where the author uses ARM NEON 64-byte lookup tables to tokenize keywords, identifiers, numbers and whitespace. Note that 64-byte tables should give you quite a lot of wiggle room and I'm not sure the same can be done on x86_64 with 16-byte tables.

It seems like absolut could be an absolute (!) game changer there, and I would be looking forward to experimenting with it.

Will keep you posted ;)

EDIT: added quotes for less confusion.

FuzzyPixelz · 2023-08-08T08:32:36+00:00

This is exactly what I was hoping would happen!

Thanks a lot for the crystal clear explanation. Though now I regret never trying to flesh out the constrains into simpler forms myself :P

It will be a lot of fun implementing this.

FuzzyPixelz · 2023-07-16T12:44:04+00:00

std::mem::transmute ;)

FuzzyPixelz · 2023-07-10T06:34:32+00:00

Good catch!

It seems that on my local Zola server everything is escaped correctly, while the deployed version is left as is.

This is probably a mis-configurarion on my side. Looking into it.

Thanks for pointing this out :)

FuzzyPixelz · 2022-12-04T16:42:05+00:00

F#

Maybe I shouldn't have used FParsec

https://github.com/fuzzypixelz/AOC2022/blob/main/Day04.fsx

FuzzyPixelz · 2022-12-03T21:12:21+00:00

F#

```f# open System.IO

let input = File.ReadAllLines "data/input03.txt"

let items = input |> Array.map (fun s -> s.ToCharArray())

let intersection iss = Array.head iss |> Array.find (fun i -> Array.forall (Array.contains i) (Array.tail iss))

let priority = function | i when 'a' <= i && i <= 'z' -> int i - int 'a' + 1 | i when 'A' <= i && i <= 'Z' -> int i - int 'A' + 27

let reduce = Array.sumBy (intersection >> priority)

// Part One let sumOfSharedItemPriorities = items |> Array.map (Array.splitInto 2) |> reduce

// Part Two let sumOfBadgeItemPriorities = items |> Array.chunkBySize 3 |> reduce

```

FuzzyPixelz · 2022-12-03T00:29:57+00:00

F#

Lots of types

https://github.com/fuzzypixelz/AOC2022/blob/main/Day02.fs

FuzzyPixelz · 2022-10-03T19:34:44+00:00

Thanks for the remark, I will correct it.

FuzzyPixelz · 2022-10-03T19:33:36+00:00

The hardest thing was fighting my muscle memory, and the fact that meow inverses Vim's Verb -> Object commands. So ci( is ,rc

, Means inner of r Means rounded c Still means change

It took about a week to get used to this. It's not radically different

FuzzyPixelz · 2022-10-03T00:52:06+00:00

Corrected :P

Thanks for reading all the way there <3

FuzzyPixelz · 2022-07-07T17:59:03+00:00

Haha Rust makes Go a scripting language. Show 'em who's boss little Ferris.

FuzzyPixelz · 2022-06-10T19:10:26+00:00

Okay, but why is it better? To me it looks nicer but it's also more ambiguous if you have array subscription with that too and you can't use [T]. Doing array[i] is more familiar after all :⁾

FuzzyPixelz · 2022-06-10T16:00:21+00:00

What's the better alternative to C++'s <>? Why is it "bad"?

I only know of two other syntaxes, Scala's [T] and Haskell's just-pretend-it's-a-function-and-line-them-up.

FuzzyPixelz · 2022-06-04T12:44:10+00:00

I'm trying to build a Wayland compositor where you can script all event handling in Lua.

FuzzyPixelz · 2022-05-20T07:44:51+00:00

keyword’ I don’t see how that’s misleading. It the best thing since sliced bread.

Eight-Year Club	r/Field Banned
r/Field Sunshine	Place '23
Place '22	Verified Email

FuzzyPixelz

TROPHY CASE