cannot return reference to local variable `s0` - rust

Question

I'm new to rust and I'm getting an error which I wasn't able to solve on my own.
I was advised to use a Cow but the person then said it wasn't possible after further inspection.
Link to playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=d2910c05fed1ed8c615c28eaddf77d1d
Code:
use std::collections::HashMap;
enum Value<'a> {
Symbol(&'a str),
Call(&'a str, Vec<&'a Value<'a>>),
}
enum V<'a> {
Null,
String(&'a str),
Symbol(&'a str),
Builtin(Box<dyn for<'b> Fn(Vec<&'b V>) -> V<'b>>),
Function(Vec<&'a str>, &'a ()),
}
struct S<'a> {
i: HashMap<&'a str, V<'a>>,
parent: Option<&'a S<'a>>,
}
impl<'a> S<'a> {
fn lookup(&self, name: &str) -> &V<'a> {
match self.i.get(name) {
Some(v) => v,
None => match self.parent {
Some(parent) => parent.lookup(name),
None => &V::Null,
},
}
}
fn put(&mut self, name: &'a str, v: V<'a>) {
self.i.entry(name).or_insert(v);
}
}
fn eval<'a>(val: &'a Value, s: &'a S<'a>) -> V<'a> {
match val {
Value::Symbol(str) => V::Symbol(str),
Value::Call(str, args) => match s.lookup(str) {
V::Builtin(_fn) => {
let args: Vec<&V> = args
.iter()
.map(|z| {
let s0 = eval(z, s);
match s0 {
V::Symbol(str) => s.lookup(str),
_ => &s0
}
})
.collect();
_fn(args)
}
_ => V::Null,
},
}
}
fn main() {
let mut m = S {
i: HashMap::new(),
parent: None,
};
m.put("x", V::Null);
m.put("y", V::Builtin(Box::new(|_x| V::Null)));
let v = Value::Call("y", vec![&Value::Symbol("x")]);
eval(&v, &m);
}
And the error:
error[E0515]: cannot return reference to local variable `s0`
--> src/main.rs:47:34
|
47 | ... _ => &s0
| ^^^ returns a reference to data owned by the current function

Answer 1

Your eval function is creating data and trying to return it. You probably want to return it by value, without the reference.
_ => s0
If you don't own the data, then you'll need to make a clone of it. Your type makes extensive use of Vec, so it'll never be able to implement Copy. It's pretty close to implementing clone, though. The only issue is
Builtin(Box<dyn for<'b> Fn(Vec<&'b V>) -> V<'b>>),
There's no general way to clone a dyn Fn. If you really need general cloning on something like that, you can look into reference-counted types like Rc and Arc, but that's probably massively overkill for this.
Assuming Builtin refers to a handful of language builtins that are set at compile-time, they're probably all top-level Rust functions. The type Fn encompasses not just ordinary functions but also closures (and, I believe in new versions of Rust, any user-defined class can implement that trait as well by hand). If all you need is ordinary closures, use fn (note the lowercase "f"). This will only allow ordinary Rust function pointers, not closures or anything more advanced.
Builtin(fn(Vec<&'b V>) -> V<'b>),
The nice thing about fn (as opposed to dyn Fn) is that it's Clone, so we can #[derive(Clone)] now.