Code shared from the Rust Playground

playground.rs

#[derive(Debug)]
struct Context<'a> {
    child: Ui,
    parent: &'a mut Ui,
}

struct ContextManager<'a> {
    f: Box<dyn Fn(&mut Context)>,
    ctx: Context<'a>,
}

impl<'a> ContextManager<'_> {
    fn new(f: impl Fn(&mut Context) + 'static, ctx: Context<'a>) -> ContextManager<'a> {
        ContextManager{f: Box::new(f), ctx}
    }
    
    fn exit(&mut self) {
        (self.f)(&mut self.ctx);
    }
    
    fn horizontal(&mut self) -> ContextManager {
        self.ctx.child.horizontal()
    }
}

impl Drop for ContextManager<'_> {
    fn drop(&mut self) {
        self.exit();
    }
}

use core::fmt::Debug;
impl Debug for ContextManager<'_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "ContextManager{{ctx={:?}}}", self.ctx)
    }
}

#[derive(Debug)]
struct Ui {
    id: u64,
    parent: u64,
    mutable: u64,
}

impl Ui {
    fn allocate_ui_with_layout_dyn(&mut self) -> ContextManager {
        let child = Ui{id: self.id + 1, parent: self.id, mutable: 0};
        ContextManager::new(|ctx| {
            println!("deferred exit {:?}", ctx);
            ctx.child.mutable = 1;
            ctx.parent.mutable = 1;
        }, Context{child: child, parent: self})
    }
    
    fn horizontal_with_main_wrap_dyn(&mut self, main_wrap: bool) -> ContextManager {
        self.allocate_ui_with_layout_dyn()
    }
    
    fn horizontal(&mut self) -> ContextManager {
        self.horizontal_with_main_wrap_dyn(false)
    }
}

fn main() {
    let mut root = Ui{parent: 0, id: 0, mutable: 0};
    println!("root {:?}", root);
    {
        let mut ui = root.horizontal();
        println!("ui 1 {:?}", ui);
        {
            let mut ui = ui.horizontal();
            println!("ui 2 {:?}", ui);
        }
    }
}