JFC. When will open source projects like @rustlang learn that putting toxic people like this in positions of ANY authority is unacceptable. https://github.com/marshallpierce/rust-base64/issues/213 . He's showing you who he is, and you're not listening.

https://crates.io/crates/syslog-ng-common/0.7.0

The colleague, who added @rustlang support to #syslog\_ng left many years ago. Syslog-ng #Rust support was last touched 7 years ago. Still, there are regular downloads. Just #searchengines or there are real users? Does it actually work?

I recently ran into an issue where I wanted to use Any for slices. However, it only allows 'static types (based on what I read, this is because you get the same TypeId regardless of lifetimes).

I came up with this workaround which I think is safe:

```rust use std::{ any::{Any, TypeId}, marker::PhantomData, };

#[derive(Clone, Debug)] pub struct AnySlice<'a> { tid: TypeId, len: usize, ptr: *const (), marker: PhantomData<&'a ()>, }

impl<'a> AnySlice<'a> { pub fn from_slice(s: &'a [T]) -> Self { Self { len: s.len(), ptr: s.as_ptr() as *const (), tid: TypeId::of::(), marker: PhantomData, } }

pub fn as_slice(&self) -> Option<&'a [T]> { if TypeId::of::() != self.tid { return None; } Some(unsafe { std::slice::from_raw_parts(self.ptr as *const T, self.len) }) }

pub fn is(&self) -> bool { TypeId::of::() == self.tid } } ```

edit: Unfortunately it seems like Lemmy insists on mangling the code block. See the playground link below.

T: Any ensures T is also 'static. The lifetime is preserved with PhantomData. Here's a playground link with some simple tests and a mut version: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3116a404c28317c46dbba6ed6824c8a9

It seems to pass Miri, including the mut version (which requires a bit more care to ensure there can only be one mutable reference). Any problems with doing this?

Ruffle, a Flash Player emulator built in Rust, is being used on archive.org to allow modern browsers access to classics like n, All Your Base, Weebl and Bob, Strong Bag Emails, Happy Tree Friends and many more.

Jason Scott writes:

> Thanks to efforts by volunteers Nosamu and bai0, the Internet Archive's flash emulation just jumped generations ahead.

> Mute/Unmute works. The screen resizes based on the actual animation's information. And for a certain group who will flip their lid:

> We can do multi-swf flash now!

> A pile of previously "broken" flashes will join the collection this week.

If you have a workspace with dependencies you probably noticed that sometimes cargo seemingly unnecessary recompile external dependencies as you switch between different members of your workspace.

This is caused by something called feature unification ([1]). Since features by design should be additive only cargo tries to avoid redundant work by using a superset of all required features. Problem comes when there are multiple crates in the workspace require external dependencies with different set of features. When you are working with the workspace as a whole - unified features include all the dependencies, when you target a single crate - unified features will include only features of that crate's dependencies.

What's worse - if you are using nix with crate2nix to manage dependencies - you'll get no feature unification at all and every dependency with each unique combination of features is considered a separate dependency so the same crate can be compiled (and linked in) multiple times - I've seen 20+ copies of a single crate.

Unless there are special requirements it is better to make sure that all the external dependencies have exact same set of features enabled across the workspace. One option is to do it by hand manually editing Cargo.toml files for individual dependencies or with inherited workspace dependencies. As with anything manual - it would be error prone.

That's where cargo-hackerman comes in. It can check if there are feature unification issues in the workspace so you can run it in CI if you want to do it manually or it can apply the smallest possible hack by itself (and remove it later).

This is not a new crate, we've been using it in production with a large workspace for over a year now.

In addition to feature unification it can help with some other compilation time things giving easy answers to questions like :

• are there any duplicate dependencies in my workspace?
• why is this dependency or feature on dependency is required?
• what are all the dependencies of this crate?
• where is the repository of this crate?

With updated bpaf documentation on https://crates.io/crates/cargo-hackerman should be always up to date and cli - a bit more user friendly

• https://doc.rust-lang.org/cargo/reference/features.html#feature-unification
• https://crates.io/crates/cargo-hackerman
• https://github.com/pacak/hackerman/

> Rust offers advantages in reliability and security over traditional programs written in C/C++. This preview shipped with an early implementation of critical kernel features in safe Rust. Specifically, win32kbase_rs.sys contains a new implementation of GDI region. While this is a small trial, we will continue to increase the usage of Rust in the kernel. Stay tuned!

What do you think about this kind of indication for conflicting or otherwise invalid arguments?

!

With command line arguments being 1D and line length valid up to hundreds of kilobytes only inline indication seems to work.

Would you change anything?

One of the digits of your credit card number is not like the rest of them: it's purpose is to check for value correctness, this way any website or form knows what if checksum matches - the value was typed in correctly. Or you are lucky with a typo because it's not a very good checksum - it was designed to be easy to calculate on a mechanical device and been sticking around mostly for historical reasons.

To check if a number is valid according to Luhn checksum you would go from right to left, double every second digit, add all the digits together, if result ends with 0 - checksum matches, if it ends with some other value - it does not.

For example let's check the number 1594: write down the number as a bunch of digits

1 5 9 4

double every second digit from the right

2 5 18 4

add all the digits

2 + 5 + 1 + 8 + 4 = 20

ends with 0, so checksum is valid

Three key optimizations help to calculate it fast:

• You can split longer sums into short ones
• You can skip second splitting into digits by doing multiplication as usual and adding number of digits above 5 to the total
• SWAR can to perform a bunch of operations on individual digits at once

To illustrate first optimization let's calculate 1 5 9 4 sum in two parts

1 5 => 2 5 => 2 + 5 = 7 9 4 => 18 4 => 1 + 8 + 4 = 13 7 + 13 = 20 - checksum is valid

to illustrate the second one

// digits themselves 1 5 9 4 => 2 5 18 4 => 2 + 5 + 18 + 4 = 29 // correction 0 0 1 0 => 0 + 0 + 1 + 0 = 1 total: 29 + 1 = 30 Result is off by 10, but for checksum validity purposes it's good enough.

Last trick comes from doing SWAR and skipping extracting digits in the first place.

User input comes as an ASCII string "1594", which we split into chunks of size 8 to fit into 64 bit register and pad with "0" from the right:

"1594" => "00001594" // subtract 0x3030303030303030 ("00000000") // to get decimal values "00001594" - "00000000" => [0, 0, 0, 0, 1, 5, 9, 4]

At this point it is easy to check if string consists of only decimal digits just by adding 0x4646464646464646 and looking for overflows and underflows in both results - can be done for both at once

Multiplying every other digit by 2 and adding them together is done with a regular multiplication by 0x0201020102010201, and math will do the rest:

``` A B

• 1 2 ---------- 2A 2B A B ```

Top byte of the lower half of the result will contain 2A + B for 2 digit case or the full result for all 8 digits in the actual code. Because all the digits are below 10 - there's no overflow from earlier digits.

Whole code looks like this:

``` fn fold10_swar(mask1: u64, mask2: u64, raw: &[u8]) -> Option<u64> { let mut sum = 0;

for c in raw.rchunks(8) { let mut buf = [b'0'; 8]; copy_from_small_slice(&mut buf, c);

let mut v = u64::from_le_bytes(buf); // try to overflow value up let a = v.wrapping_add(0x4646464646464646); // and down v = v.wrapping_sub(0x3030303030303030); // if either direction overflows - there are non 0..9 digits so // checksum can't possibly be valid, otherwise all the values are digits if (a | v) & 0x8080808080808080 == 0 { // Calculate number of digits above 5 located at positions that would double // Doubling them would result to values above 9 which will necessitate subtracting // 9. But in mod 10 arithmetic -9 and +1 is the same so simply adding // count of such digits is enough sum += u64::from((mask2.wrapping_sub(v) & 0x8080808080808080).count_ones()); sum += v.wrapping_mul(mask1) >> 56; } else { return None; } } Some(sum) } ```

And good news - luhn3 crate can check the correctness or calculate a digit to use as a checksum for you and it works somewhat fast - on a 5 year old processor when compiled with target-cpu=native it can verify a 16 digit credit card checksum in about 3 nanoseconds - in 12 or so CPU cycles, benchmarks included.

[disclaimer: initially posted on Reddit r/rust]

unrar is a library for listing and extracting RAR archives.

Hi lemmyrs!

Almost 8 years ago, I release my first Rust crate. Today, before I leave Reddit at the end of the month due to the recent controversy, after months and years working on and off on this update, as a parting gift, I'm happy to announce the crate's biggest release ever. This really is a milestone release that, among others, allows one to extract files directly into memory -- something people have been asking forever how to do.

I've also completely rewritten major parts of the library and am very proud of the way things are looking right now. Utilizing the typestate pattern, the library enforces correct usage at compile time, only exposing methods when they make sense (depending on a combination of open mode and current cursor position).

Before this release, the library was hard to use and it was not possible to skip some files in the archive while, for instance, extracting others. One operation had to be chosen for all files. That has changed now. However, the drawback is that iterating archives is now a bit harder since the Iterator trait is not implemented for archives that are opened in Process mode (since it's hard to enforce an operation at call-site). I have a few ideas how to improve this going forward but input is also always welcome.

Anyway, this sets the groundwork architecture and paves the way forward for upcoming releases where ergonomics and other improvements like error types can be the focus.

Another major focus of this release was documentation: all API items are documented now except for very few exceptions. The crate docs also features a very extensible introduction as well.

GitHub repository can be found here: https://github.com/muja/unrar.rs

Feel free to discuss / ask questions here or over on Reddit.

Thanks!

cross-posted from: https://programming.dev/post/91261

> Hello everyone, > I recently started working on a Gtk client for Lemmy written in Rust, called Lemoa and the awesome Relm4 crate. > > So far, it supports most of the basic things that do not require a login, like viewing trending posts, browsing communities, viewing profiles, etc... > Login features are planned to become added within the next one or two weeks, so that Lemoa can be used as a replacement for the web UI on a desktop. > > Screenshot of an example community page: > ! > > Id you want to feel free to already try it at "alpha stage" (installation instructions are in the Readme). > > Feedback and any kind of contributions welcome! > > PS: I'm sorry if that's the wrong place to post about it, I didn't know where else to.

cross-posted from: https://lemmy.world/post/339657

> This is from a developer working for the team at Slint. Slint is an alternative GUI library to iced/libcosmic that is also written in Rust. The goal is to make it possible to developers to create COSMIC-themed applications with Slint as a possible alternative to libcosmic.

Powered by #Rust, the video codec stack on ARCVM is now bringing faster and more reliable video decoding on #ChromeOS. Here's how Collabora has been helping shape video virtualization for #Chromebooks, and what it means for end users. https://col.la/rmvvc #OpenSource @rustlang

In my very large Rust-based project of about 100k lines of code, 100 direct dependencies, and 800 total dependencies, I always require version="*" for each dependency, except for specific ones that either I cannot or don't want to upgrade.

Crucially, I also commit my Cargo.lock, as the Cargo manual recommends.

I normally build with cargo --locked. Periodically, I will do a cargo update and run cargo outdated so that I'm able to see if there are specific packages keeping me at older versions.

To upgrade a specific package, I can just remove its record directly from Cargo.lock and then do a regular cargo build.

This works very well!

Advantages

• I minimize my number of dependencies, and therefor build times
• I keep my personal ecosystem from falling too far behind that of crates.io
• I rarely wind up with a situation where I have two dependencies that depend on a different symbol version
• I don't have to change a version in all of my many Cargo.tomls

Disadvantages

• I cannot publish my large repository to a wider audience (but that will never happen for this repository)
• People who see my code start feeling ill and start shifting their eyes nervously.

Anyone knows about #Lemmy/#Kbin instances for #rust/#rustlang ?

Found LemmyRS.org. And I learned I just can follow @rustlang here in mastodon. Isn't that cool. Just love this #fediverse

cross-posted from: https://beehaw.org/post/570507

>After the (temporary) defederation announcement of earlier i checked the Lemmy repo to see if there was already a ticket on the federation limiting option like Mastodon’s that people mentioned Lemmy doesn’t yet have. Not only i didn’t find it, i also saw that there’s about 200+ open tickets of variable importance. Also saw that it’s maintained mostly by the two main devs, the difference in commits between them and even the next contributors is vast. This is normal and in other circumstances it’d grow organically, but considering the huge influx of users lately, which will likely take months to slow down, they just don’t have the same time to invest on this, and many things risk being neglected. I’m a sysadmin, haven’t coded anything big in at least a decade and a half beyond small helper scripts in Bash or Python, and haven’t ever touched Rust, so can’t help there, but maybe some of you Rust aficionados can give some time to help essentially all of Lemmy. The same can be said of Kbin of course, although that’s PHP, and there is exacerbated by it being just the single dev.

Hey LemmyRS,

I decided to try and change the style of the website to make it as accessible and appealing as I could through dev tools (inspect element).

Here are my results

Current:

!

After changing:

!

I thought this would help foster discussion on how we can improve this instance to look both appealing and accessible for supporting the most users for our growing community!

Let me know what you think!

cross-posted from: https://programming.dev/post/24889

> [Disclaimer: Lemmy newb here] > > There are currently 3 Rust communities across 3 instances: programming.dev, lemmyrs.org and this one (lemmy.ml). I know it's still very early for the migration from /r/rust, but it would split the community if there are so many options and nobody knows which is the "right" one. Currently this community has the most subscribers, but it would make sense if the Rust community finds its new home in one of the other instances. > > - lemmyrs.org seems like the logical solution if instance-wide rules are paramount and "non-negotiable" > - personally I would love a programming-centric instance and programming.dev seems like a good way. Rust is not the only language I'm actively using (unfortunately :)). Maybe there can be community-specific rules that "enforce" the Rust CoC and the Rust community can find a home there? > > Either way, the current situation has the most negative impact. > > Thoughts?

I always forgot to check these unless I saw them in /r/rust so let's start posting them here. This is last week's since there's a day or two till the next.