this post was submitted on 27 Oct 2024
55 points (96.6% liked)
Rust
5930 readers
32 users here now
Welcome to the Rust community! This is a place to discuss about the Rust programming language.
Wormhole
Credits
- The icon is a modified version of the official rust logo (changing the colors to a gradient and black background)
founded 1 year ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
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:
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. aCow
or anArc
. 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 ofself
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.&Bar
is a reference to something. That something is either a part ofself
, 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 toIndex
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 aCow
, or go for the obvious generalization of returningimpl AsRef<Bar>
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). Just like how mutable statics are considered very bad in Rust ๐
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.