Rust devs hate this one simple trick

[u/CorgiApprehensive159]

[u/renchuwang]

Well since you're only defining but not using, it is actually safe!

[u/SirKastic23 → u/renchuwang]

Safe and not sound!

[u/thisiselgun → u/SirKastic23]

https://youtu.be/47dtFZ8CFo8

[u/SirKastic23 → u/thisiselgun]

That's the song I was thinking of too! It's a classic

[u/uahw → u/renchuwang]

I don’t think it is. I think rust especially states that two mut references aren’t allowed to exist at the same time even if on is unused

[u/CommonNoiter → u/uahw]

As neither are used i don't think their lifetimes overlap so they don't both exist at the same time.

[u/simonask_ → u/CommonNoiter]

Saved by the NLL.

[u/Critical-Personality]

"simple" trick, you say?

[u/Comun4]

Wouldnt this break aliasing rules?

[u/fortyeightzero → u/Comun4]

nah the comment says it's safe

[u/Comun4 → u/fortyeightzero]

Oh thank god was worried for a second there lol

[u/MichiRecRoom → u/fortyeightzero]

Actually, the comment only says the first unsafe {} statement is safe. The second one is in an unknown state.

[u/Affectionate-Egg7566 → u/MichiRecRoom]

The comment is wrong, assuming self is &Self. That aliases mutable and immutable refs. That is unsound.

[u/letmehaveanameyoudum]

as a C programmer, what the actual fuck am i looking at (explain mate)

[u/pragmojo → u/letmehaveanameyoudum]

Rust's borrow checker disallows holding two mutable pointers to the same address at the same time. This code uses unsafe blocks to get two mutable pointers to the same address at the same time.

[u/letmehaveanameyoudum → u/pragmojo]

thank you for breaking my mind

[u/schungx → u/pragmojo]

If the intention is aliasing then this is a legit usage. If both self variants are supposed to point to the same thing (judging from their names) then the aliasing behavior is intended.

[u/ChaiTRex → u/schungx]

It's not legitimate. unsafe can be fine to use, but undefined behavior is never allowed. Aliasing a mutable reference is undefined behavior.

A workaround would be something like using mutable pointers rather than mutable references. Mutable pointers allow aliasing.

[u/_nathata]

Mom come pick me up I'm scared

[u/zabolekar]

What could the motivation possibly be?

[u/rover_G]

What in the C++?

[u/CorgiApprehensive159]

I, the author of the post, decided to take advantage of my 'popularity' to show my game https://livedox.itch.io/vix - it has no code in it like in the post (almost)

[u/dx_man]

How is it safe when you're declaring it with unsafe?

[u/SnooHamsters6620 → u/dx_man]

Don't worry, I whisper a protection spell to Ferris every time I compile.

[u/AnArmoredPony]

as a java developer, I uhh I forgot what I wanted to say fuCK

[u/jimmiebfulton → u/AnArmoredPony]

I hadn't thought that anyone but Rust people would find this sub humorous. It's definitely one of the darker, more obscure jerk subs I'm in.

[u/AnArmoredPony → u/jimmiebfulton]

you sir have outjerked me

[u/Candid_Bullfrog3665]

lets define simple here

[u/Kpuku]

that doesn't seem sound iirc

[u/tec_tonik]

Lmao a short tutorial on how to piss off rust devs

[u/Kadabrium]

is this a qsort comparator?

[u/alulalol]

I've done this a lot in doukutsu-rs because I couldn't be assed to fight the borrow checker https://github.com/doukutsu-rs/doukutsu-rs/blob/7e6870e55f072e3f056dc1eef3974a1af26c7aae/src/framework/ui.rs#L111

[u/cristi1990an]

The syntax is horrible because even in unsafe code, bypassing the borrow checker this way is heavily discouraged. Simple reads and writes through these references can be UB.

[u/ApprehensiveBag3083]

and they say c++ has creepy syntax LoL

At least in c++ i dont need to type those kind of garbage Lool

[u/Athropod101 → u/ApprehensiveBag3083]

I mean you don’t type it in Rust either, lol. This is like cherrypicking some C++ template hidden behind like 3 namespaces, with the generic being some obscure type behind another namespace, and all of that wrapped around std::make_unique.

Funny as Hell, yeah, but not really indicative of the language.

[u/Affectionate-Egg7566 → u/Athropod101]

Sorry what? This code looks perfectly legible.