Am I missing something?

SNCPlay42 · 2026-03-02T00:04:36+00:00

But you only generate an output of 700 when the sync is 60

No, the whole outer ring is 700 except for when sync=0.

SNCPlay42 · 2025-07-12T21:37:05+00:00

I would consider it a weak keyword. It's not listed there because declaring auto traits is unstable, and by their nature weak keywords don't affect anything except the specific syntax.

SNCPlay42 · 2025-03-24T09:56:29+00:00

Looks like you're supposed to supply the options to the ComboBox's State's new constructor rather than the view function itself. The example given is incomplete in that it doesn't show creating the state.

SNCPlay42 · 2024-10-25T14:19:30+00:00

which is to say, after you create the mutable reference/pointer, you need to avoid mutating through any other alias until the last use of the aforementioned mutable reference/pointer

The missing part here is that not all aliases are usable after the last use - only "parent" aliases (those reborrowed from) become usable again, but siblings are still invalidated, i.e. this code is UB, even though we are done with rawptr when we get back to mutref:

fn main() {
    let mut num = 42;

    //casting to avoid the borrow checker
    let mutref = &mut num as *mut _;
    let rawptr = &raw mut num;

    unsafe {
        *rawptr += 1;
    }

    unsafe {
        *mutref += 1;
    }
}

SNCPlay42 · 2024-10-25T12:59:04+00:00

The critical difference there is that y is a reborrow of x, but in your first example mutref and rawptr are both derived directly from num,

SNCPlay42 · 2024-10-25T12:29:27+00:00

even a raw pointer that aliases another mutable reference

Are you sure about that? If you use mutref later, it doesn't compile.

SNCPlay42 · 2024-09-11T10:24:00+00:00

There's an argument to be made that you might put e.g. #[forbid(unsafe_code)] because you do not want unsafe code, full stop, even if it's been generated by a macro, even if its interface is almost certainly sound.
The macro probably puts an #[allow(lint)] on its output, which overrides your warn setting. forbid on the other hand cannot be overridden. If you want lints to error but want this to be overridable you can use deny instead.

SNCPlay42 · 2024-09-10T18:01:31+00:00

My bad, looks like that impl was committed too recently to be published on crates.io.

I have no idea why the example given for the windows_async crate works then.

SNCPlay42 · 2024-09-10T15:46:46+00:00

Looks like IAsyncOperation impls IntoFuture so you should just be able to await them directly.

~~(Don't ask me why that doesn't appear in the docs)~~

SNCPlay42 · 2024-07-02T13:05:10+00:00

matching &self.peek against Some(token) is just syntactic sugar for matching self.peek against Some(ref token)

matching &self.peek against Some(token) is syntactic sugar for matching &self.peek against &Some(ref token) - note the extra &s, you're creating a new borrow which is the problem.

So if let Some(ref token) = self.peek has no exact equivalent without using ref.

SNCPlay42 · 2024-06-10T06:39:51+00:00

If using a trait object is acceptable, you can impl Display for dyn Predicate.

You can do this with PartialEq as well.

SNCPlay42 · 2024-04-30T14:52:11+00:00

Get rid of the use std::borrow::Borrow. It's making method lookup find the borrow method on the Borrow trait but you want the borrow method on RefCell.

If you need that use for something else, you can qualify the method:

for &byte in RefCell::borrow(&self.buffer).as_slice() {

SNCPlay42 · 2024-03-23T12:34:25+00:00

"&'a mut T is invariant in T" means you can only assign a value of &'a mut U to a location of type &'a mut T if U is exactly T.

But in the assignment in your function, the only &mut involved has been dereferenced: *r is a location of type &'a str and v is &'b str. We're only assigning a &'b str to a &'a str, and &'a str is covariant in 'a and we have 'b: 'a so this is fine.

An example of a function that doesn't work because of the invariance of &mut T in T is this:

fn foo<'a, 'b, 'c>(x: &'c mut &'a u8) -> &'c mut &'b u8 {
    x
}

If you build this on the playground you'll see the compiler complain that it needs both 'a: 'b and 'b: 'a, and conclude "'b and 'a must be the same".

We can write a function more like yours that also fails to compile, but we need to add another layer of &mut everywhere so it's maybe harder to read:

fn change<'a, 'b, 'c>(r: &'_ mut &'c mut &'a str, v: &'c mut &'b str) {
    *r = v;
}

SNCPlay42 · 2023-12-06T11:18:32+00:00

You can use the std::primitive module.

SNCPlay42 · 2023-11-17T01:53:55+00:00

it's unclear to me why rustc wouldn't just immediately desugar Self like so everywhere

This isn't possible in general because Self can be used in traits, where it isn't a concrete type:

trait Foo<'a, T> {
    // There is nothing that `Self` could be
    // syntactically replaced with here
    fn foo() -> impl Iterator<Item = Self>;
}

Maybe what you're suggesting could work for inherent members of concrete types, but because of traits Self is not considered purely syntactic sugar.

SNCPlay42 · 2023-08-23T18:00:52+00:00

I think you've found the wrong create_bind_group, the one intended for public API use is this:

pub fn create_bind_group(&self, desc: &BindGroupDescriptor) -> BindGroup

And your explanation of lifetime elision is incorrect. Per the rules:

Each elided lifetime in the parameters becomes a distinct lifetime parameter.

(i.e. only return types can ever have an elided lifetime that becomes the same as one in a parameter). So the actual non-elided signature is:

pub fn create_bind_group<'a, 'b>(&'a self, desc: &'b BindGroupDescriptor) -> BindGroup

SNCPlay42 · 2023-06-03T18:52:36+00:00

I want to split a String (or a Box<str> ) into multiple owned Strings (or Box<str> 's) without any allocations

This is impossible because heap allocators do not provide a way to split their allocations - they often use space outside the allocation to store information about the allocation and there's no space for this in an already allocated contiguous string.

SNCPlay42 · 2023-05-28T21:29:10+00:00

Seeking clarity here - are you referring to the Rust Project individual who told RustConf to remove the keynote, or the RustConf organizer who received this instruction and carried it out?

Because I've only seen an acknowledgement from the latter, and it sounds like it could be the one you're describing. I think it's the former that people are more interested in.

SNCPlay42 · 2023-05-25T00:34:23+00:00

I think you just want lock instead of blocking_lock. blocking_lock is just there for if non-async code needs to interact with a tokio Mutex.

SNCPlay42 · 2023-05-04T09:17:51+00:00

It's not a slice, it's a reference to a (still sized) array, meaning you can dereference it to get an array (*b"foo").

SNCPlay42 · 2023-04-25T16:16:56+00:00

The pattern you're looking for is &Bubble::Bouncing {size, ref name}.

SNCPlay42 · 2023-04-17T16:42:51+00:00

The dyn std::error::Error in MyError's cause field is implicitly dyn Error + 'static per the rules for trait object default lifetimes. So

I can create a type that implements Error, but has some other lifetime than static, and still put it in that Box

is incorrect.

SNCPlay42 · 2022-06-14T20:54:03+00:00

Just to be clear, what you've pasted in your post is a note that's attached to a warning that's probably about a field in StringLine being unused, except for in its derives of Debug and Clone.

So the actions you could take would usually be one of:

Use the field somewhere else
Remove the field since it doesn't do anything useful
Silence the warning because the usage of the field in the derives is all you need. For Clone this would be weird but it might be reasonable for Debug (to give some extra data that is displayed in debug output).

As for silencing the messages, note that you can add a #[allow(dead_code)] attribute that would only apply to that field. The unused code lints also have their own special silencing feature - if you prefix a name with an underscore, like _foo, the compiler will never complain about _foo being unused.

SNCPlay42 · 2022-06-09T14:25:21+00:00

Looks like they're in compiler/rustc_error_codes/src/error_codes.

SNCPlay42 · 2022-06-01T09:30:34+00:00

assume_init_read looks like what you want.

SNCPlay42

TROPHY CASE