Temporary value created when unwrap() - rust

Question

I'm trying to create a thread-safe version of a stack based on a vector.
The unsafe version (just a simplified example to focus in) is
fn top<'a, T>( v: &'a Vec<T> ) -> &'a T {
return & v[0];
} // ()
// --------------------------------------------
fn main() {
let mut v = Vec::<i32>::new();
v.push( 1234 );
println!( "{}", top( & v ) );
} // ()
But the safe version does not compile:
type SafeVec<T> = Arc< RwLock< Vec<T> > >;
// --------------------------------------------
fn new_safe_vec<T>() -> SafeVec<T> {
return Arc::new( RwLock::new( Vec::<T>::new() ) );
} // ()
// --------------------------------------------
fn top_safe<'a, T>( v: &'a SafeVec<T> ) -> &'a T {
return & v.read().unwrap()[0]; <------ returns a value referencing
<------ data owned by the current function
<------ (temporary crated here)
} // ()
// --------------------------------------------
fn main() {
} // ()
Does unwrap() create a temporary copy of the vector held inside? How to avoid it?

Answer 1

#Jmb comment makes perfect sense.
It's not safe to return a reference to a locked vector's cell. The lock drops at the end of the function top_safe(). The calling code would have a "nude" pointer to the cell, but the cell could be changed by different threads.
Better to return a copy of the cell.
use std::sync::Arc;
use std::sync::RwLock;
// ==================================================================
type SafeVec<T> = Arc< RwLock< Vec<T> > >;
// ------------------------------------------------------------------
fn new_safe_vec<T>() -> SafeVec<T> {
return Arc::new( RwLock::new( Vec::<T>::new() ) );
} // ()
// ------------------------------------------------------------------
fn top_safe<'a, T: Copy>( v: &'a SafeVec<T> ) -> T {
return v.read().unwrap()[0];
} // ()
// ------------------------------------------------------------------
fn top<'a, T>( v: &'a Vec<T> ) -> &'a T {
return & v[0];
} // ()
// ==================================================================
fn main() {
let sv = new_safe_vec::<i32>();
let mut v = Vec::<i32>::new();
v.push( 1234 );
println!( "{}", top( & v ) );
sv.write().unwrap().push( 1234 );
println!( "{}", top_safe( & sv ) );
} // ()

Answer 2

And, just for completeness, to avoid a copy we'll need to have a guarded reference to the cell. A trick could be using a macro so that the RwLockReadGuard is kept in main().
use std::sync::Arc;
use std::sync::RwLock;
// ==================================================================
type SafeVec<T> = Arc< RwLock< Vec<T> > >;
// ------------------------------------------------------------------
fn new_safe_vec<T>() -> SafeVec<T> {
return Arc::new( RwLock::new( Vec::<T>::new() ) );
} // ()
// ------------------------------------------------------------------
macro_rules! top_safe {
($v: expr) => {
$v.read().unwrap()[0]
} // ()
} // macro
// ==================================================================
fn main() {
let sv = new_safe_vec::<i32>();
sv.write().unwrap().push( 1234 );
println!( "{}", top_safe!( & sv ) );
} // ()