Confused of how `Box<dyn Fn(Args)>` is interpreted - rust

Question

I don't really know how to put this question, but can somebody explain why this works:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=969cf50f66746c4aa3941200e01f1570
enum SlotFn<'a, Comp, Args = (), R = ()>
where Args: 'static,
R: Default + 'static,
{
SimpleFn(fn(Args) -> R),
MemberFn(fn(&'a Comp) -> R),
MemberFnMut(fn(&'a mut Comp, Args) -> R),
}
impl<'a, Comp, Args, R> SlotFn<'a, Comp, Args, R>
where Args: 'static,
R: Default + 'static,{
fn from_member(f: fn(&'a Comp) -> R) -> Self{
SlotFn::MemberFn(f)
}
fn from_member_mut(f: fn(&'a mut Comp, Args) -> R) -> Self {
SlotFn::MemberFnMut(f)
}
fn emit(&self, comp: &'a Comp, args: Args) -> R {
match self {
SlotFn::SimpleFn(f) => f(args),
SlotFn::MemberFn(f) => f(comp),
_ => Default::default()
}
}
fn emit_mut(&mut self, comp: &'a mut Comp, args: Args) -> R {
match self {
SlotFn::MemberFnMut(f) => f(comp, args),
_ => Default::default()
}
}
}
struct Test(u32);
impl Test {
fn reffunc(&self) {
println!("value: {}", self.0);
}
fn reffunc_mut(&mut self, val: u32) {
self.0 = val;
}
}
fn main() {
let mut test = Test(0);
let slot = SlotFn::from_member(Test::reffunc);
let mut mslot = SlotFn::from_member_mut(Test::reffunc_mut);
mslot.emit_mut(&mut test, 10);
slot.emit(&test, ());
}
but not this:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=1534d9b49327272ddbbd04826efd644a
enum SlotFn<'a, Comp, Args = (), R = ()>
where Args: 'static,
R: Default + 'static,
{
SimpleFn(Box<dyn Fn(Args) -> R + Send + Sync + 'static>),
MemberFn(Box<dyn Fn(&'a Comp) -> R + Send + Sync + 'static>),
MemberFnMut(Box<dyn FnMut(&'a mut Comp, Args) -> R + Send + Sync + 'static>),
}
impl<'a, Comp, Args, R> SlotFn<'a, Comp, Args, R>
where Args: 'static,
R: Default + 'static,{
fn from_member<F>(f: F) -> Self where F: Fn(&'a Comp) -> R + Send + Sync + 'static{
SlotFn::MemberFn(Box::new(f))
}
fn from_member_mut<F>(f: F) -> Self where F: FnMut(&'a mut Comp, Args) -> R + Send + Sync + 'static{
SlotFn::MemberFnMut(Box::new(f))
}
fn emit(&self, comp: &'a Comp, args: Args) -> R {
match self {
SlotFn::SimpleFn(f) => f(args),
SlotFn::MemberFn(f) => f(comp),
_ => Default::default()
}
}
fn emit_mut(&mut self, comp: &'a mut Comp, args: Args) -> R {
match self {
SlotFn::MemberFnMut(f) => f(comp, args),
_ => Default::default()
}
}
}
struct Test(u32);
impl Test {
fn reffunc(&self) {
println!("value: {}", self.0);
}
fn reffunc_mut(&mut self, val: u32) {
self.0 = val;
}
}
fn main() {
let mut test = Test(0);
let slot = SlotFn::from_member(Test::reffunc);
let mut mslot = SlotFn::from_member_mut(Test::reffunc_mut);
mslot.emit_mut(&mut test, 10);
slot.emit(&test, ());
}
in the second case, I'm getting the following error:
error[E0502]: cannot borrow `test` as immutable because it is also borrowed as mutable
mutable borrow might be used here, when `mslot` is dropped and runs the destructor for type `SlotFn<'_, Test, u32>`

Answer 1

Let's call the 'a of from_member() 'a1, and the 'a of from_member_mut() 'a2. If 'a1 and 'a2 overlap, this is an error test is mutably borrowed for 'a2 while it is borrowed for 'a1. So what are 'a1 and 'a2?
The shortest they can be is from the creation of the SlotFn (for each its own SlotFn) object to its destruction, because for all that time the SlotFn can access the data of 'a.
In the first code, we can destroy the SlotFns early, because they do not implement Drop therefore they cannot perform any action while destroyed, so an early destruction cannot be observed. Therefore, in the first code, the compiler shortens 'a1 and 'a2 just until the emit_mut() and emit(), respectively, so they do not conflict.
In the second case, however, they may implement Drop - dyn Trait is always considered as implementing Drop, as the compiler cannot know what is inside - and therefore, their lifetimes must end at the end of the block, because Drop could observe 'a. So they conflict.