Struct App 

pub struct App<State, Build> { /* private fields */ }

A Frust application: the app state plus the build closure that maps it to a view tree.

This is the low-level primitive. app! and run expand into App::new(state, move |state| root.build(state)) (see run_with_setup_and_config); ordinary apps write a Component and start it with those instead of constructing an App by hand.

Construct with App::new and start the event loop with App::run, optionally naming a desktop identity with App::desktop in between.

The view type is intentionally not a parameter of this struct: capturing a build fn’s impl View<State> opaque return type into a stored type parameter defeats method resolution (the opaque type’s trait bounds can’t be re-proven on the already-typed value). Instead App::run infers the view type freshly at the call site, so App::new(state, build).run() compiles for both impl View and concrete-typed build.

Implementations

impl<State, Build> App<State, Build>

pub fn new(state: State, build: Build) -> Self

Create an app from an initial state and its build closure.

build is a FnMut(&mut State) -> impl View<State> re-run each frame to produce the current view tree.

impl<State: 'static, Build> App<State, Build>

pub fn desktop(self, config: DesktopConfig) -> Self

Give the app a desktop identity — name, reverse-DNS id, window icon, native menu bar, last-window-close policy (see DesktopConfig).

Optional: an app that never calls this runs with DesktopConfig::default(), which is the dev-preview window exactly as it has always been. Each per-OS shell reads the fields it can act on and ignores the rest (Linux has no native menu bar, macOS wants an application icon rather than a window one, and so on).

// `App::new` is the low-level primitive; apps normally use a `Component`.
frust::App::new(AppState, build)
    .desktop(frust::DesktopConfig::new().with_app_name("Huddle"))
    .run()
    .unwrap();

pub fn run<V>(self) -> Result<()>

where V: View<State>, Build: FnMut(&mut State) -> V + 'static,

Run the app in the desktop window until it is closed.

Blocks the calling thread on the platform event loop. Returns once the window closes, or an error if the window/GPU surface could not be created. The concrete view type V is inferred from build.

Desktop-only: on Android the app is driven by the JNI bridge that android_app! generates and on iOS by the C-ABI entry points ios_app! generates, not by this loop.