u/YatoRust

Oh man :(

https://lib.rs/crates/smallvec

you could use string.starts_with("your prefix") to check the prefix without worrying about length errors.

On the note of performance, always measure first to see if it's actually a problem. If it is, then you could consider using logos to parse out the prefix. logos compiles down to a DFA, and will only look at each byte once.

logos: https://lib.rs/crates/logos

Changing debug representation is fine. You're not supposed to rely in it.

Sorry i meant Miri

Probably related to the RustBelt project and work done on MIRI.

This one works a lot better and has more colors, I think it's like semantic colors for asm.

Hm, even closures break this. https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=93238488cf7d8cac4c55c1dcb08b39ff

This particular implementation is unsound because of loops :). You can store previous iterations and use those tokens to access the values exclusively twice

But usually not if there's a branch/allocation in the way

Np, unsafe is hard and this was a subtle bug :). In the future, look out for this when you use ptr::read.

Found a double free bug 💥

https://gitlab.com/nebneb0703/bombs/-/issues/4

If you change the trait definitions to something like

trait Reborrow<'a, _Outlives = &'a Self> {...}

It lets you use the trait bound T: for<'a> Reborrow<'a> for example.

I would reccomend using this pattern so that Reborrow[Mut] works well with HRTB

https://users.rust-lang.org/t/lifetime-conflicting-requirements/64070/4

It's not. Its 27% Javascript. They have too similar colors. Asm is a tiny sliver at the top of the circle

That doesn't compile :)

NOTE move and copy lower to the exact same memcpy, the only difference between them is if you are allowed to access the value after you move/copy it. So there isn't really a perf angle to this, unless you have a very large type (in the order of kilobytes) and you want to prevent accidental copies. But then, even moves can be relatively expensive in a hot loop.

Here's a modified version that doesn't require patterns, can take an arbitrary path, and doesn't allow typos.

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=aad5af1a7bb8cdccfe8b9f4c53533628

Every line, are you trying to be fast! We must lock on every character, that is the way.

No, that transmute isn't valid. It's better to keep implementation details hidden until it becomes necessary to expose them. Transmuting repr(Rust) types is unspecified behavior, and will almost certainly run into undefined behaviour for non-trivial types like VecDeque. Unless the type has a well specified layout, you can't use transmute.

This copies a reference which isn't the same as returning a reference to the iterated item. Try converting to array::IntoIter::new(v) instead of v.iter() and you will see errors

It means this student is cheating, even though they said not they wouldn't. Usually schools have a academic honesty "contract" that students need to sign and follow. It usually says they can't ask for answers online (among other things). If they need help they need to go to resources at school such as professors or teaching assistants. But they should have all the knowledge to put this together.

That's a typo, it should be Pin<Box<_>> in the code,

Wtf

Yeah, most of this could be handled with derives.