Feature: Relax draw() closure 'static bound

[subinium]

Problem

draw() requires FnOnce + 'static (container.rs:1183):

pub fn draw(self, f: impl FnOnce(&mut Buffer, Rect) + 'static)

This forces users to .clone() all captured state every frame, since local borrows can't satisfy 'static. For data-dense UIs (e.g., a 12×16 step grid), this means cloning the entire pattern state into the closure 60 times per second.

Root Cause

The closure is stored in ctx.deferred_draws as Box<dyn FnOnce(&mut Buffer, Rect)>, executed after the UI closure returns during run_frame_kernel (lib.rs:1073-1089). Since it runs after the UI closure's stack frame is gone, it can't borrow from it.

However, the closures are consumed within the same run_frame_kernel call (line 1078: c.take() followed by cb(buffer, rdr.rect)). They never escape the function.

Proposed Solution

A frame-scoped lifetime bound instead of 'static:

pub fn draw<'frame>(self, f: impl FnOnce(&mut Buffer, Rect) + 'frame)

This would require architectural changes to the command/layout pipeline to support bounded lifetimes on stored closures, but would dramatically improve ergonomics for custom drawing.

Alternative: draw_ref()

A simpler short-term fix: add a draw_ref() that executes the closure immediately during the command-building phase (before layout), writing to a temporary buffer that gets composited during layout. This avoids the deferred execution entirely:

pub fn draw_ref(self, f: impl FnOnce(&mut Buffer, Rect))  // no 'static needed

Source Reference

• container.rs:1183 — draw() signature with 'static
• core.rs:44 — deferred_draws: Vec<Option<RawDrawCallback>>
• lib.rs:1073-1089 — deferred draw execution

[subinium]

Analysis: 'static bound is necessary — both proposed solutions have issues

After deep investigation of the code, here's what we found:

The 'static bound IS overly restrictive in theory

The closure stored in deferred_draws is created and consumed within the same run_frame_kernel call (lib.rs:975-1085). It never escapes the function. So semantically, 'static is stronger than needed.

However, removing it is not straightforward

Proposed Solution 1 — 'frame lifetime on Context: This would require adding a lifetime parameter to Context, which propagates to every impl Context block (15+ files), every run()/frame() signature, and requires HRTB (impl for<'a> FnMut(&mut Context<'a>)). This is a semver-breaking change that degrades ergonomics for ALL users, not just draw() users. Not practical.

Proposed Solution 2 — draw_ref() with immediate execution: The rect is unknown at closure call time. The whole point of deferral is that the rect is determined by layout::compute(), which runs AFTER the user closure returns. Fundamentally impossible.

Considered Solution 3 — Unsafe transmute to erase lifetime: Initially seemed viable, but has a soundness hole. The deferred closure executes AFTER f(&mut ctx) returns. If the closure borrows variables local to the FnMut body (not captures from the outer scope), those borrows become dangling:

slt::run(|ui| {
    let computed = expensive_compute(); // local to FnMut body
    ui.container().draw_ref(|buf, rect| {
        use_data(&computed); // ← dangling after f() returns!
    });
});

The type system cannot distinguish "borrows from FnMut captures" (safe) from "borrows from FnMut locals" (unsound).

Recommended path forward

This needs an architectural approach — either restructuring run_frame_kernel so deferred draws execute while the user closure's stack is still alive, or a scoped-arena approach. Both are significant refactors that warrant a separate design RFC.

For now, the 'static bound is the correct safe choice. The internal .to_vec() / Arc::new() clones in widgets_viz.rs are the known cost.