Struct BoundState 

pub struct BoundState<T> { /* private fields */ }

Rust-side state a SwiftUI control can both read and write.

This is not @State. SwiftUI’s own property wrappers need the framework to reach into a Swift type’s storage through reflection metadata, which a Rust type does not have. What this gives instead is the half that matters from Rust: a real Binding<Value> backed by Rust closures, so a control renders from Rust state and writes edits straight back into it.

Redisplay is driven explicitly, because SwiftUI cannot observe a Rust value: a Binding’s getter is read only when something else causes the body to be evaluated. Register on_write to be told when a control writes, and answer it by bumping a @State (crate::state::set_state) or by handing the hosting controller a new tree (crate::HostingView::set_root). Without that, an edit moves the control and updates the Rust value while a Text showing that value stays as it was.

Implementations

impl<T: Clone> BoundState<T>

pub fn new(initial: T) -> Self

Examples found in repository

examples/todo.rs (line 37)

fn draft() -> &'static views::BoundState<String> {
    static DRAFT: OnceLock<views::BoundState<String>> = OnceLock::new();
    DRAFT.get_or_init(|| views::BoundState::new(String::new()))
}

examples/ios_app.rs (line 85)

fn slider_state() -> &'static views::BoundState<f64> {
    static S: std::sync::OnceLock<views::BoundState<f64>> = std::sync::OnceLock::new();
    S.get_or_init(|| views::BoundState::new(0.65))
}

/// The stepper's value, owned by Rust.
fn stepper_state() -> &'static views::BoundState<f64> {
    static S: std::sync::OnceLock<views::BoundState<f64>> = std::sync::OnceLock::new();
    S.get_or_init(|| views::BoundState::new(3.0))
}

/// The toggle's state, owned by Rust and read back after every tap.
fn switch_state() -> &'static views::BoundState<bool> {
    static S: std::sync::OnceLock<views::BoundState<bool>> = std::sync::OnceLock::new();
    S.get_or_init(|| views::BoundState::new(false))
}

examples/scenes.rs (line 45)

fn counter() -> &'static BoundState<i64> {
    static C: std::sync::OnceLock<&'static BoundState<i64>> = std::sync::OnceLock::new();
    C.get_or_init(|| Box::leak(Box::new(BoundState::new(0))))
}

examples/inbox.rs (line 38)

fn inbox() -> &'static Inbox {
    static I: OnceLock<Inbox> = OnceLock::new();
    I.get_or_init(|| Inbox {
        query: views::BoundState::new(String::new()),
        searching: views::BoundState::new(false),
    })
}

examples/common/spec.rs (line 442)

fn flag_slot(name: &str, initial: bool) -> views::BoundState<bool> {
    slots()
        .lock()
        .expect("slots")
        .flags
        .entry(name.to_string())
        .or_insert_with(|| views::BoundState::new(initial))
        .clone()
}

fn number_slot(name: &str, initial: f64) -> views::BoundState<f64> {
    slots()
        .lock()
        .expect("slots")
        .numbers
        .entry(name.to_string())
        .or_insert_with(|| views::BoundState::new(initial))
        .clone()
}

fn string_slot(name: &str, initial: &str) -> views::BoundState<String> {
    slots()
        .lock()
        .expect("slots")
        .strings
        .entry(name.to_string())
        .or_insert_with(|| views::BoundState::new(initial.to_string()))
        .clone()
}

examples/settings.rs (line 32)

fn settings() -> &'static Settings {
    static S: OnceLock<Settings> = OnceLock::new();
    S.get_or_init(|| Settings {
        name: views::BoundState::new("Ada".into()),
        notify: views::BoundState::new(true),
        volume: views::BoundState::new(0.6),
        theme: views::BoundState::new(0),
        refresh: views::BoundState::new(5.0),
        about: views::BoundState::new(false),
    })
}

pub fn get(&self) -> T

Examples found in repository

examples/ios_app.rs (line 41)

fn on_tap() {
    TAPS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    let s = switch_state();
    s.set(!s.get());
    refresh();
}

/// The one piece of SwiftUI-owned state in the application.
///
/// Everything the interface shows lives in Rust. SwiftUI cannot observe a Rust
/// value, so redisplay needs something it *does* track: a real `@State` on a
/// type synthesised at run time. Bumping it re-runs the body, which rebuilds
/// the whole tree from whatever Rust now holds.
///
/// The view itself is main-thread only — it holds raw metadata pointers — but
/// its `id` is just a number, and that is all [`refresh`] needs.
fn root_view() -> views::ViewHandle {
    thread_local! {
        static ROOT: std::cell::OnceCell<swiftui_native::state::StatefulView> =
            const { std::cell::OnceCell::new() };
    }
    ROOT.with(|cell| {
        let sv = cell.get_or_init(|| {
            let sv = swiftui_native::state::StatefulView::new(0, |_generation| ui());
            ROOT_ID.store(sv.id, std::sync::atomic::Ordering::Release);
            sv
        });
        sv.as_view()
    })
}

static ROOT_ID: std::sync::atomic::AtomicI64 = std::sync::atomic::AtomicI64::new(-1);

/// Tell SwiftUI that Rust state changed, so it re-runs the body.
fn refresh() {
    use std::sync::atomic::Ordering;
    static GENERATION: std::sync::atomic::AtomicI64 = std::sync::atomic::AtomicI64::new(0);
    let id = ROOT_ID.load(Ordering::Acquire);
    if id >= 0 {
        let n = GENERATION.fetch_add(1, Ordering::Relaxed) + 1;
        swiftui_native::state::set_state(id, n);
    }
}

/// The slider's value, owned by Rust and written on every drag.
fn slider_state() -> &'static views::BoundState<f64> {
    static S: std::sync::OnceLock<views::BoundState<f64>> = std::sync::OnceLock::new();
    S.get_or_init(|| views::BoundState::new(0.65))
}

/// The stepper's value, owned by Rust.
fn stepper_state() -> &'static views::BoundState<f64> {
    static S: std::sync::OnceLock<views::BoundState<f64>> = std::sync::OnceLock::new();
    S.get_or_init(|| views::BoundState::new(3.0))
}

/// The toggle's state, owned by Rust and read back after every tap.
fn switch_state() -> &'static views::BoundState<bool> {
    static S: std::sync::OnceLock<views::BoundState<bool>> = std::sync::OnceLock::new();
    S.get_or_init(|| views::BoundState::new(false))
}

fn ui() -> views::ViewHandle {
    views::zstack(&[
        views::background_linear_gradient(
            &views::color(0.0, 0.0, 0.0, 0.0),
            &[Color::new(0.06, 0.07, 0.16, 1.0), Color::new(0.24, 0.07, 0.33, 1.0)],
            (0.0, 0.0),
            (1.0, 1.0),
        ),
        views::scroll(&views::padding(
            &views::vstack_spacing(
                &[
                    header(),
                    section("Typography", typography()),
                    section("Shapes", shapes()),
                    section("Controls", controls()),
                    section("Symbols", symbols()),
                    section("Effects", effects()),
                    section("Layout", layout()),
                ],
                18.0,
            ),
            16.0,
        )),
    ])
}

/// White text at a given size and weight — the showcase's workhorse.
fn label_text(s: &str, size: f64, weight: Option<views::Weight>, alpha: f64) -> views::ViewHandle {
    views::foreground_style_color(
        &views::font_system(&views::text(s), size, weight, None),
        1.0,
        1.0,
        1.0,
        alpha,
    )
}

fn header() -> views::ViewHandle {
    views::vstack_spacing(
        &[
            label_text("SwiftUI from Rust", 30.0, Some(views::Weight::Bold), 1.0),
            label_text(entry(), 13.0, None, 0.75),
            label_text(
                &format!("taps: {}", TAPS.load(std::sync::atomic::Ordering::Relaxed)),
                13.0,
                Some(views::Weight::Semibold),
                0.9,
            ),
        ],
        4.0,
    )
}

/// A titled group: a caption, then the content, over a rounded panel.
fn section(title: &str, content: views::ViewHandle) -> views::ViewHandle {
    views::vstack_spacing(
        &[
            label_text(title, 12.0, Some(views::Weight::Semibold), 0.55),
            views::padding(
                &views::corner_radius(
                    &views::background(&views::padding(&content, 12.0), 1.0, 1.0, 1.0, 0.07),
                    14.0,
                ),
                0.0,
            ),
        ],
        6.0,
    )
}

fn typography() -> views::ViewHandle {
    views::vstack_spacing(
        &[
            views::hstack_spacing(
                &[
                    views::font_text_style(&views::text("Title"), views::TextStyle::Title3),
                    views::italic(&views::text("Italic")),
                    views::monospaced(&views::text("mono")),
                ],
                14.0,
            ),
            views::kerning(&label_text("K E R N E D", 15.0, None, 0.9), 2.0),
            views::foreground_style_linear_gradient(
                &views::font_system(&views::text("Gradient fill"), 22.0, Some(views::Weight::Bold), None),
                &[
                    views::color_value_of(Color::new(1.0, 0.55, 0.25, 1.0)),
                    views::color_value_of(Color::new(1.0, 0.25, 0.6, 1.0)),
                ],
                (0.0, 0.0),
                (1.0, 0.0),
            ),
        ],
        10.0,
    )
}

fn shapes() -> views::ViewHandle {
    let swatch = |shape: views::Shape, c: Color| {
        views::frame(&shape.fill(views::color_value_of(c)), 58.0, 44.0)
    };
    views::hstack_spacing(
        &[
            swatch(views::Shape::circle(), Color::new(0.95, 0.35, 0.30, 1.0)),
            swatch(views::Shape::capsule(), Color::new(0.98, 0.70, 0.20, 1.0)),
            swatch(views::Shape::rounded_rectangle(10.0, true), Color::new(0.30, 0.65, 1.0, 1.0)),
            swatch(views::Shape::ellipse(), Color::new(0.35, 0.85, 0.55, 1.0)),
        ],
        10.0,
    )
}

fn controls() -> views::ViewHandle {
    views::vstack_spacing(
        &[
            // Two toggles, both starting `false`: one bound to Rust-owned
            // state, one a constant. If they ever disagree on screen, the
            // binding's getter is at fault rather than the control.
            views::toggle_bound("Bound to Rust state", switch_state()),
            views::toggle("Constant false", false),
            views::hstack_spacing(
                &[
                    label_text(&format!("{:.2}", slider_state().get()), 14.0, None, 0.9),
                    views::slider_bound(slider_state(), 0.0, 1.0),
                ],
                10.0,
            ),
            views::stepper_bound(
                &format!("Stepper: {:.0}", stepper_state().get()),
                stepper_state(),
                0.0,
                10.0,
                1.0,
            ),
            // Reads the stepper's Rust value. A `ProgressView` takes a plain
            // number rather than a binding, so it can only ever show what it
            // was built with — which is fine now that every write rebuilds the
            // body from current state.
            views::progress(stepper_state().get(), 10.0),
            views::hstack_spacing(
                &[
                    views::button_style(
                        &views::button("Bordered", on_tap),
                        views::ButtonStyle::Bordered,
                    ),
                    views::button_style(
                        &views::button("Glass", on_tap),
                        views::ButtonStyle::Glass,
                    ),
                ],
                12.0,
            ),
            views::textfield("A text field", ""),
        ],
        12.0,
    )
}

examples/todo.rs (line 41)

fn add() {
    let text = draft().get();
    if text.trim().is_empty() {
        return;
    }
    items().lock().unwrap().push(Item { title: text, done: false });
    draft().set(String::new());
    state::refresh_animated(state::ease_in_out(0.25));
}

examples/common/spec.rs (line 391)

pub fn slot_value(name: &str) -> Option<String> {
    let g = slots().lock().expect("slots");
    g.flags
        .get(name)
        .map(|v| v.get().to_string())
        .or_else(|| g.numbers.get(name).map(|v| format!("{:.2}", v.get())))
        .or_else(|| g.strings.get(name).map(|v| format!("{:?}", v.get())))
}

/// What every slot currently holds, for a status line or a test.
pub fn slot_summary() -> Vec<(String, String)> {
    let g = slots().lock().expect("slots");
    let mut out: Vec<(String, String)> = g
        .flags
        .iter()
        .map(|(k, v)| (k.clone(), v.get().to_string()))
        .chain(g.numbers.iter().map(|(k, v)| (k.clone(), format!("{:.2}", v.get()))))
        .chain(g.strings.iter().map(|(k, v)| (k.clone(), format!("{:?}", v.get()))))
        .collect();
    out.sort();
    out
}

examples/inbox.rs (line 46)

fn matching() -> Vec<usize> {
    let q = inbox().query.get().to_lowercase();
    MESSAGES
        .iter()
        .enumerate()
        .filter(|(_, m)| {
            q.is_empty()
                || m.from.to_lowercase().contains(&q)
                || m.subject.to_lowercase().contains(&q)
        })
        .map(|(i, _)| i)
        .collect()
}

examples/scenes.rs (line 54)

fn main_window() -> ViewHandle {
    vstack(&[
        text("A SwiftUI app, no Swift source")
            .font_size(20.0)
            .padding(8.0),
        divider(),
        text(&format!("count: {}", counter().get()))
            .font_size(34.0)
            .padding(12.0),
        hstack(&[
            button("−", || counter().set(counter().get() - 1)),
            button("+", || counter().set(counter().get() + 1)),
        ]),
        spacer(),
        text("⌘, for Settings · the ★ in the menu bar has a menu")
            .font_size(11.0)
            .opacity(0.6),
    ])
    .padding(24.0)
    .frame(420.0, 300.0)
    .focused_scene_value(counter_focus_key(), counter().get())
    .into_handle()
}

/// The focused-value key the window publishes its count under.
///
/// `.focusedSceneValue(\.key, value)` is how a window tells the commands above
/// it what is selected. Both halves are synthesised at run time: the
/// `FocusedValueKey` conformance *and* the `WritableKeyPath<FocusedValues, Int?>`
/// — `FocusedValues` exports no properties, so unlike `EnvironmentValues` there
/// is no SwiftUI modifier holding a key path to borrow.
///
/// The menu cannot *read* it yet: that needs `@FocusedValue`, a `DynamicProperty`
/// SwiftUI instantiates itself, which is a different mechanism from anything
/// here. What this demonstrates is the publishing half, in a real app.
fn counter_focus_key() -> &'static views::FocusKey {
    static K: std::sync::OnceLock<views::FocusKey> = std::sync::OnceLock::new();
    K.get_or_init(|| views::focus_key("sceneCounter"))
}

fn settings_pane() -> ViewHandle {
    vstack(&[
        text("Preferences").font_size(18.0),
        divider(),
        text("This pane is a `Settings` scene — the one ⌘, opens."),
        text(&format!("It sees the same state: {}", counter().get()))
            .opacity(0.7),
    ])
    .padding(24.0)
    .frame(360.0, 200.0)
    .into_handle()
}

fn utility_window() -> ViewHandle {
    vstack(&[
        text("Utility").font_size(16.0),
        text("A `Window`, not a `WindowGroup`: one of it, addressed by id.")
            .opacity(0.7),
    ])
    .padding(20.0)
    .frame(320.0, 140.0)
    .into_handle()
}

fn menu_bar_item() -> ViewHandle {
    vstack(&[
        text(&format!("count: {}", counter().get())),
        button("Reset", || counter().set(0)),
    ])
    .padding(10.0)
    .into_handle()
}

/// The whole app, as one scene.
///
/// Built afresh every time SwiftUI reads `App.body`, which is what makes the
/// numbers in it live rather than a snapshot taken at launch.
///
/// macOS only, and not by choice: `Settings`, `Window`, `MenuBarExtra` and the
/// whole of `Commands` are `@available(iOS, unavailable)`. iOS gets
/// [`ios_body`], which is the part of this that exists there.
#[cfg(target_os = "macos")]
fn body() -> SceneHandle {
    scenes! {
        window_group { main_window() }
        settings { settings_pane() }
        window("Utility", "utility") { utility_window() }
        menu_bar_extra("Count", "star.fill") { menu_bar_item() }
        commands {
            // A menu of its own, beside File and Edit.
            menu("Counter") {
                vstack(&[
                    button("Increment", || counter().set(counter().get() + 1)),
                    button("Decrement", || counter().set(counter().get() - 1)),
                    divider(),
                    button("Reset", || counter().set(0)),
                ])
            }
            // In place of the standard File ▸ New.
            replacing(NewItem) { button("New Count", || counter().set(0)) }
            // Added after the standard Help entry.
            after(Help) {
                button("About this Rust app", || {
                    eprintln!("built with no Swift compiler in sight");
                })
            }
        }
    }
}

examples/settings.rs (line 62)

fn body() -> View {
    let s = settings();

    form![
        section![header: text("Account");
            hstack![
                text("Name"),
                spacer(),
                textfield_bound("Your name", &s.name).text_field_style(
                    views::TextFieldStyle::RoundedBorderTextFieldStyle,
                ),
            ],
            toggle_bound("Notifications", &s.notify),
        ],
        section![header: text("Playback");
            vstack_aligned(&[
                hstack![
                    text("Volume"),
                    spacer(),
                    text!("{:.0}%", s.volume.get() * 100.0).fg_system(SystemColor::Gray),
                ],
                slider_bound(&s.volume, 0.0, 1.0),
            ], HorizontalAlignment::Leading),
            stepper_bound("Refresh every", &s.refresh, 1.0, 60.0, 1.0),
        ],
        section![header: text("Appearance");
            picker_bound!(
                "Theme",
                &s.theme,
                text(THEMES[0]).tag_int(0),
                text(THEMES[1]).tag_int(1),
                text(THEMES[2]).tag_int(2),
            )
            .picker_style(PickerStyle::InlinePickerStyle),
        ],
        section![
            button("About", show_about)
                .a11y_hint("Opens a panel describing this app"),
        ],
    ]
    .form_style(FormStyle::GroupedFormStyle)
    .sheet_bound(&s.about, about_panel())
}

/// The sheet, which the user can dismiss — the flag is Rust's, so closing it
/// writes `false` back rather than leaving the two sides disagreeing.
fn about_panel() -> View {
    let s = settings();
    vstack_spacing(
        &[
            system_image("gearshape.fill")
                .symbol_rendering_mode(Some(views::SymbolRenderingMode::Hierarchical))
                .view()
                .font_size(48.0)
                .fg_system(SystemColor::Blue),
            text("Settings").text_style(TextStyle::Title).bold(),
            text!("Signed in as {}", s.name.get()).fg_system(SystemColor::Gray),
            spacer(),
            button("Done", hide_about).button_style(views::ButtonStyle::BorderedProminent),
        ],
        16.0,
    )
    .padding(24.0)
    .presentation_detents(&[views::PresentationDetent::Medium])
    .presentation_drag_indicator(Visibility::Visible)
}

pub fn set(&self, v: T)

Examples found in repository

examples/settings.rs (line 111)

fn show_about() {
    settings().about.set(true);
    state::refresh();
}

fn hide_about() {
    settings().about.set(false);
    state::refresh();
}

examples/ios_app.rs (line 41)

fn on_tap() {
    TAPS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    let s = switch_state();
    s.set(!s.get());
    refresh();
}

examples/common/spec.rs (line 379)

pub fn set_flag(name: &str, value: bool) {
    slots()
        .lock()
        .expect("slots")
        .flags
        .get(name)
        .unwrap_or_else(|| panic!("no flag slot called {name:?}"))
        .set(value);
}

examples/todo.rs (line 46)

fn add() {
    let text = draft().get();
    if text.trim().is_empty() {
        return;
    }
    items().lock().unwrap().push(Item { title: text, done: false });
    draft().set(String::new());
    state::refresh_animated(state::ease_in_out(0.25));
}

examples/scenes.rs (line 58)

fn main_window() -> ViewHandle {
    vstack(&[
        text("A SwiftUI app, no Swift source")
            .font_size(20.0)
            .padding(8.0),
        divider(),
        text(&format!("count: {}", counter().get()))
            .font_size(34.0)
            .padding(12.0),
        hstack(&[
            button("−", || counter().set(counter().get() - 1)),
            button("+", || counter().set(counter().get() + 1)),
        ]),
        spacer(),
        text("⌘, for Settings · the ★ in the menu bar has a menu")
            .font_size(11.0)
            .opacity(0.6),
    ])
    .padding(24.0)
    .frame(420.0, 300.0)
    .focused_scene_value(counter_focus_key(), counter().get())
    .into_handle()
}

/// The focused-value key the window publishes its count under.
///
/// `.focusedSceneValue(\.key, value)` is how a window tells the commands above
/// it what is selected. Both halves are synthesised at run time: the
/// `FocusedValueKey` conformance *and* the `WritableKeyPath<FocusedValues, Int?>`
/// — `FocusedValues` exports no properties, so unlike `EnvironmentValues` there
/// is no SwiftUI modifier holding a key path to borrow.
///
/// The menu cannot *read* it yet: that needs `@FocusedValue`, a `DynamicProperty`
/// SwiftUI instantiates itself, which is a different mechanism from anything
/// here. What this demonstrates is the publishing half, in a real app.
fn counter_focus_key() -> &'static views::FocusKey {
    static K: std::sync::OnceLock<views::FocusKey> = std::sync::OnceLock::new();
    K.get_or_init(|| views::focus_key("sceneCounter"))
}

fn settings_pane() -> ViewHandle {
    vstack(&[
        text("Preferences").font_size(18.0),
        divider(),
        text("This pane is a `Settings` scene — the one ⌘, opens."),
        text(&format!("It sees the same state: {}", counter().get()))
            .opacity(0.7),
    ])
    .padding(24.0)
    .frame(360.0, 200.0)
    .into_handle()
}

fn utility_window() -> ViewHandle {
    vstack(&[
        text("Utility").font_size(16.0),
        text("A `Window`, not a `WindowGroup`: one of it, addressed by id.")
            .opacity(0.7),
    ])
    .padding(20.0)
    .frame(320.0, 140.0)
    .into_handle()
}

fn menu_bar_item() -> ViewHandle {
    vstack(&[
        text(&format!("count: {}", counter().get())),
        button("Reset", || counter().set(0)),
    ])
    .padding(10.0)
    .into_handle()
}

/// The whole app, as one scene.
///
/// Built afresh every time SwiftUI reads `App.body`, which is what makes the
/// numbers in it live rather than a snapshot taken at launch.
///
/// macOS only, and not by choice: `Settings`, `Window`, `MenuBarExtra` and the
/// whole of `Commands` are `@available(iOS, unavailable)`. iOS gets
/// [`ios_body`], which is the part of this that exists there.
#[cfg(target_os = "macos")]
fn body() -> SceneHandle {
    scenes! {
        window_group { main_window() }
        settings { settings_pane() }
        window("Utility", "utility") { utility_window() }
        menu_bar_extra("Count", "star.fill") { menu_bar_item() }
        commands {
            // A menu of its own, beside File and Edit.
            menu("Counter") {
                vstack(&[
                    button("Increment", || counter().set(counter().get() + 1)),
                    button("Decrement", || counter().set(counter().get() - 1)),
                    divider(),
                    button("Reset", || counter().set(0)),
                ])
            }
            // In place of the standard File ▸ New.
            replacing(NewItem) { button("New Count", || counter().set(0)) }
            // Added after the standard Help entry.
            after(Help) {
                button("About this Rust app", || {
                    eprintln!("built with no Swift compiler in sight");
                })
            }
        }
    }
}

pub fn is_persistent(&self) -> bool

Is this state written through to UserDefaults?

impl<T: Persisted> BoundState<T>

pub fn persistent(key: &str, default: T) -> Self

State backed by UserDefaults, which is what @AppStorage is for.

The stored value wins over default when there is one — including a stored false or 0, which is why defaults::has exists rather than leaning on the typed readers.

Writes go through on set, so a control bound to this persists as the user changes it and comes back to the same value in the next process. SwiftUI is not involved in the storage at all: the value lives in Rust and is mirrored to the same UserDefaults that @AppStorage would have used.

Trait Implementations

impl<T> Clone for BoundState<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.