A comparison of Rust's borrow checker to the one in C#
https://lemmy.world/post/21334791
=> More informations about this toot | More toots from Giooschi@lemmy.world
Cool, that was an informative read!
If we were willing to leak memory, then we could write […] Box::leak(Box::new(0))
In this example, you could have just made a constant with value 0 and returned a reference to that. It would also have a 'static lifetime and there would be no leaking.
Why does nobody seem to be talking about this?
My guess is that the overlap in use cases between Rust and C# isn’t very large. Many places where Rust is making inroads (kernel and low-level libraries) are places where C# would be automatically disqualified because of the requirements for a runtime and garbage collection.
=> More informations about this toot | More toots from arendjr@programming.dev
(Note that I’m not the article author)
In this example, you could have just made a constant with value 0 and returned a reference to that. It would also have a 'static lifetime and there would be no leaking.
I believe the intention was to demonstrate something that works with runtime values too, and a constant 0 does not.
Btw you can just write &0 to do what you proposed, there’s no need for an explicit constant/static.
=> More informations about this toot | More toots from Giooschi@lemmy.world
=> More informations about this toot | More toots from BB_C@programming.dev
I can agree that the example function is not the best usecase. But the point still stand that there’s no realistic escape hatch from lifetimes and memory management in Rust.
Cow does not work when you are actually required to return a reference, e.g. if you’re working with some other crate that requires that. Cow also has some more strict requirements on reborrows (i.e. you can reborrow a &'short &'long T to a &'long T, but you can only reborrow a &'short Cow<'long, T> to a &'short T).
LazyLock can solve very specific issues like static, but is not a general escape hatch. Again, the example is not the best to showcase this, but imagine if you have to perform this operation for an unknown amount of runtime values. LazyLock will only work for the very first one.
=> More informations about this toot | More toots from Giooschi@lemmy.world
Cow does not work when you are actually required to return a reference
What does that even mean? Can you provide a practical example?
(I’m assuming you’re familiar with Deref and autoref/autoderef behaviors in Rust.)
=> More informations about this toot | More toots from BB_C@programming.dev
This is a kind of stupid example, but imagine you have to implement some external trait (e.g. in order to work with some dependency) with the following shape:
fn foo(&self, i: usize) -> &Bar;
}
Which is not too unreasonable, for example it’s very similar to the stdlib’s Index. In order to implement this trait you must return a reference, you can’t return e.g. a Cow or an Arc. The fact that it takes a parameter means there might not even be one single value it has to return, so you can’t even cache that inside of self with e.g. LazyLock.
Of course I’m not saying I would try to reach for an escape hatch if I had to do something like this. I would first try to see if this is an intrinsic problem in my code, or if maybe I can change the crate I’m working with to be more permissible. That is, I would try to look for proper solutions first, though Cow might not always work for that.
=> More informations about this toot | More toots from Giooschi@lemmy.world
&Bar is a reference to something. That something is either a part of self, or a part of the static context. There is no other context because there is no runtime/GC. So there is no logical not-nonsensical scenario where this would be both a valid and a limiting situation in Rust. And this is why your surface analogy to Index is invalid.
If the return value may depend on something other than self or the static context, and still need to be reference-like, then the trait definition is wrong. It should either return a Cow, or go for the obvious generalization of returning impl AsRef values. With that generalization, references, Cow`s, and more can be returned.
There is also the possibility that the trait definition is right, and you (the implementer) are trying to break a (probably) deliberate constraint (e.g. the return value in Index being tied to &self).
I would wager a guess that what you call an escape hatchet is considered a very bad C# style anyway (or will/should be).
=> More informations about this toot | More toots from BB_C@programming.dev
That kind of “escape hatch” also makes reasoning about code a lot harder merely because you have to consider that someone used it somewhere. You literally don’t want “escape hatches” from safety guarantees all over your language.
=> More informations about this toot | More toots from taladar@sh.itjust.works
text/geminiThis content has been proxied by September (3851b).