Let’s decompose it one-by-one. Box Box<T> is a pointer to heap-allocated T. We use it here because trait objects can only exist behind pointers. Trait objects In Box<Fn() + Send + ‘static>, Fn() + Send + ‘static is a trait object type. In future, it will be written Box<dyn (Fn() + Send + ‘static)> to … Read more
Disclaimer: I am not exactly a CS guru, so this answer will focus on practical concepts and I will not even attempt to link it to theoretical concepts lest I make a mess of things. I think that the issue is trying to apply the subtyping concept to something which is not a type. ‘a … Read more
If the static array is automatically freed after completing the execution, then how can we still access the values of the static array correctly? Nope, it’s not like that. static variables are initialized before starting main() and its lifetime is the entire execution of the program. So, they can be returned from functions (in which … Read more
Yes, it is possible to move only one or some variables into a closure (rather than all or none). Yes, this can be used to “circumvent” reference counting. I found an answer in the documentation of rayon::scope that turns out to be exactly about this problem: ‘Accessing the stack data [from within a scoped threads … Read more
You’re not storing a lambda, you’re storing a reference to a std::function. In fact, that std::function is being created as a temporary when the lambda is implicitly converted to std::function. That std::function temporary dies after the line where the constructor is invoked. LambdaStore(const std::function<void(float)>& _fn) // _fn refers to a temporary : fn(_fn) { fn(11.1f); … Read more
Temporary objects are destroyed at the end of the full expression they’re part of. A full expression is an expression that isn’t a sub-expression of some other expression. Usually this means it ends at the ; (or ) for if, while, switch etc.) denoting the end of the statement. In your example, it’s the end … Read more
Despite your best intentions, your hint function may not have the effect you expect. But we have quite a bit of ground to cover before we can understand what’s going on. Let’s begin with this: fn ensure_equal<‘z>(a: &’z (), b: &’z ()) {} fn main() { let a = (); let b = (); ensure_equal(&a, … Read more
Here’s a smaller example that reproduces the problem: struct FontLoader(String); struct Font<‘a>(&’a str); impl FontLoader { fn load(&self) -> Font { Font(&self.0) } } struct Window; struct Phi<‘window> { window: &’window Window, loader: FontLoader, font: Option<Font<‘window>>, } impl<‘window> Phi<‘window> { fn do_the_thing(&mut self) { let font = self.loader.load(); self.font = Some(font); } } fn main() … Read more
‘a is a lifetime parameter in both cases. That’s a kind of generic parameter, so each use of Type or each use of get_text can pick a different “value” for that generic parameter. Actual lifetimes are never picked explicitly by the programmer, except when you use ‘static. The compiler will infer what ‘a should be … Read more
The C++ Standard does not say where string literals should be stored. It does however guarantee that their lifetime is the lifetime of the program. Your code is therefore valid.