eBay — 16.53 €

大量の値を普段は u32 として処理し、一部分だけ複数スレッドからatomicに更新したい。このためだけに、最初から Vec を持つ必要はありません。 Rust 1.98.0では AtomicU32::from_mut_slice がstableにな...

Today, we're looking at a rewrite that rarely differs for matching, but can mean quite a lot for understanding the code. Say that you have a signed variable and the compiler has suddenly decided to make an unsigned comparison: if ((u32) (x - 4) < 2) { What's happening is that it uses a controlled overflow to do two signed comparisons using one unsigned comparison. How does this work? Since the comparison is unsigned, this is trivially equivalent to the first expression: if ((u32) (x - 4) >= 0 && (u32) (x - 4) < 2) { and since negative numbers compare larger than 6 in unsigned comparisons, nothing prevents us from adding 4 on each side of the inequality signs: if ((u32) (x) >= 4 && (u32) (x) < 6) { which is, for the same reason, equivalent to: if (x >= 4 && x < 6) { which is what you probably should be writing.

YouTube video by Maciej Nowicki

fuji-184: > All of these fire on perfectly valid, compiling code, and nudge you toward a better practice. The massive difference is if there's something that's _always_ better. It's not "suppress the lint if your transmute is correct"; it's "`u32::from_ne_bytes` is literally always better than using a transmute for that, so just change it".

fuji-184: > All of these fire on perfectly valid, compiling code, and nudge you toward a better practice. The massive difference is if there's something that's _always_ better. It's not "suppress the lint if your transmute is correct"; it's "`u32::from_ne_bytes` is literally always better than using a transmute for that, so just change it".

Hey there, I was just talking briefly in the Rust discord about ideas for an anonymous trait impl concept, here's what we have so far. Sample syntax: fn create_trait(id: u32) -> impl Trait { return impl Trait { fn id(&self) -> u32 { id } } } It'd work pretty similarly to closures capturing variables, ex: let x = 1; // create the closure let my_closure = move || { println!("{}", x); }; // call the closure my_closure(); equivalent to: struct Anonymous { x: i32, } impl Anonymous { fn call_the_thing(&self) { println!("{}", self.x); } } let x = 1; // create the closure let my_closure = Anonymous { x: x }; // call the closure my_closure.call_the_thing(); So far in the Rust discord we've discussed: 1. Instantiation Syntax `let x = impl Trait { ... };` No `let x = impl Trait for struct { var1, var2 } { ... };` or anything similar. This anonymous impl Trait syntax is meant to be a shorter & simpler version of a regular trait impl with reduced complexity. If any further complexity is needed the user can always just convert it into a conventional item with trait impl. 2. How to create `Self` As the field specifics are left unspecified to the compiler, there wouldn't be a way to construct `Self { ... }` within the anonymous trait impl. I am aware that this is a restriction; however I'd like to highlight that 1. Closures cannot be constructed in the body of themselves. 2. If you **need** to construct the anonymous trait impl; you can always make a wrapper function to instantiate the anonymous trait, ex: fn create_trait(id: u32) -> impl Trait { let x = impl Trait { fn id(&self) -> u32 { id } fn recreate(&self) -> Self { create_trait(id) } }; x } fn do_something(user: User) { let x = create_trait(user.id); } I am very aware that my markdown isn't fancy-looking or anything and I haven't structured this professionally, I can always edit this as we get more refined on what is actually needed and how we'd structure this for an RFC. (Luckily this is a RFC on a RFC lol)

Since Rust is principled about type inference stopping at function boundaries, and the anonymous trait is created _inside_ said boundaries, I say we crank type inference up to the max: fn create_trait(id: u32) -> impl Trait { move impl { fn id() { id } fn recreate(new_id) { create_trait(new_id) } } } * `impl` instead of `impl Trait` because we can infer it from the return type. This means that we no longer need to bind it to a variable before returning it. * No type annotations for the trait methods' arguments and return types. These are determined by the trait definition - no need to repeat them. * No `self`. There is no "self" access, because the data is obtained closure-style. `self` is for accessing the "parent" value (like `self` inside a closure) * `move` is needed for the same reasons it's needed in closures. If we are uncomfortable with having `fn`s without all the annotations, we can also use struct-like syntax: fn create_trait(id: u32) -> impl Trait { move impl { id: || { id }, recreate: |new_id| { create_trait(new_id) }, } } Where the main difference from a struct is that the closures share access to the data.

A suggestion which sidesteps most of @nrc’s concerns (except parsing) would be to treat {a: i8, b: u32} as a ‘struct literal’ similar to ‘integer literals’ whose specific type gets resolved by inferen...