lifetime

Here is a simplified version of what I want to archive: struct Foo<'a> { boo: Option<&'a mut String>, } fn main() { let mut foo = Foo { boo: None }; { let mut string = "Hello".to_string(); foo.boo = Some(&mut string); foo.boo.unwrap().push_str(", I am foo!"); foo.boo = None; } // string goes out of scope. foo does not reference string anymore } // foo goes out of scope This is obviously completely safe as foo.boo is None once string goes out of scope. Is there a way to tell this to the compiler? This is obviously completely safe What is obvious to humans isn't always obvious to the compiler;

While it makes sense intuitively that references passed to spawned threads need to have static lifetimes, I'm unclear about what exactly is making the following code not compile: use std::sync::Arc; use std::sync::Mutex; struct M; fn do_something(m : Arc<Mutex<&M>>) { println!("Ha, do nothing!"); } fn main() { let a = M; { let c : Arc<Mutex<&M>> = Arc::new(Mutex::new(&a)); for i in 0..2 { let c_clone = c.clone(); ::std::thread::spawn(move || do_something(c_clone)); } } } Compiling this small program gives the following error: $ rustc -o test test.rs test.rs:13:55: 13:56 error: `a` does not

I'm trying to return a slice from a vector which is built inside my function. Obviously this doesn't work because v 's lifetime expires too soon. I'm wondering if there's a way to extend v 's lifetime. I want to return a plain slice, not a vector. pub fn find<'a>(&'a self, name: &str) -> &'a[&'a Element] { let v: Vec<&'a Element> = self.iter_elements().filter(|&elem| elem.name.borrow().local_name == name).collect(); v.as_slice() } You can't forcibly extend a value's lifetime; you just have to return the full Vec . If I may ask, why do you want to return the slice itself? It is almost always

I want to implement a generic fibonacci function that works with any type implementing Zero , One , and AddAssign . I first implemented a version that works fine, but is specialized for num::BigUint ( see on play.rust-lang.org ). I than came up with the following generic implementation ( see on play.rust-lang.org ): extern crate num; use num::{One, Zero}; use std::mem::swap; use std::ops::AddAssign; fn fib<T: Zero + One + AddAssign<&T>>(n: usize) -> T { let mut f0 = Zero::zero(); let mut f1 = One::one(); for _ in 0..n { f0 += &f1; swap(&mut f0, &mut f1); } f0 } This doesn't compile: error

Possible Duplicate: Does C++ call destructors for global and class static variables? What is the lifetime of global MyClass myclass; global static MyClass myclass; global const MyClass myclass; global static const MyClass myclass; function local static MyClass myclass; when its initialization actually occured global static constexpr MyClass myclass; in C++11 and especially will they be destroyed on regular program end (i.e. main is left without an error)? Where does the standard states so. I noticed that a private destructor prevents the creation of all those variables. But if I remember

Given the following struct and impl : use std::slice::Iter; use std::cell::RefCell; struct Foo { bar: RefCell<Vec<u32>>, } impl Foo { pub fn iter(&self) -> Iter<u32> { self.bar.borrow().iter() } } fn main() {} I get an error message about a lifetime issue: error: borrowed value does not live long enough --> src/main.rs:9:9 | 9 | self.bar.borrow().iter() | ^^^^^^^^^^^^^^^^^ does not live long enough 10 | } | - temporary value only lives until here | note: borrowed value must be valid for the anonymous lifetime #1 defined on the body at 8:36... --> src/main.rs:8:37 | 8 | pub fn iter(&self) ->