Struct Field 

pub struct Field<S, T, V>
where
    T: 'static,
    V: 'static,
{ /* private fields */ }

One field, projected out of any Source. Copy, itself a Source (so fields nest), and a Binding (so every control binds to it).

Implementations

impl<S, T, V> Field<S, T, V>

where S: Source<T>, T: 'static, V: 'static,

pub fn with<R>(self, f: impl FnOnce(Option<&V>) -> R) -> R

Tracked read of this field only.

pub fn with_untracked<R>(self, f: impl FnOnce(Option<&V>) -> R) -> R

pub fn update(self, f: impl FnOnce(&mut V))

where V: Clone,

Write, waking readers of this field and of anything coarser. When a change-log consumer asked for values (record_values), the slot’s prior and new value ride along.

pub fn touch(self, tx: &mut Vec<(Vec<u64>, &'static str)>)

Name this field inside a background transaction. Portable: what is queued is the path’s components, which the main thread re-establishes on its own side when it announces.

pub fn path(self) -> Path

pub fn label(self) -> &'static str

impl<S, T, V> Field<S, T, V>

where S: Source<T>, T: 'static, V: 'static,

pub fn map<U>( self, to: fn(&V) -> U, from: fn(&U) -> V, ) -> Mapped<Field<S, T, V>, V, U>

where U: 'static,

Read this field through to, write it back through from. Both are fn pointers, so the result stays Copy.

impl<S, T, V> Field<S, T, V>

where S: Source<T>, T: 'static, V: Clone + Default + 'static,

pub fn write_preview(self, v: V)

A live write: the value lands and this field’s readers wake (a label tracking a dragged slider follows), but no change record is born, so autosave, the undo stack and every sink stay quiet. The first preview since the last commit captures the pre-session value; Field::write_commit turns the whole gesture into one record.

pub fn write_commit(self, v: V)

The settled value that ends a preview sequence: applies v, then announces one change whose prior is the pre-session value, so sixty thumb positions become one record, one undo unit, one UPDATE. Without an open session this is a plain Binding::write.

pub fn session(self) -> FieldSession<S, T, V>

The explicit session handle, for custom pieces and programmatic gestures; bindings drive Field::write_preview/Field::write_commit on their own.

Trait Implementations

impl<S, T, V> Binding<V> for Field<S, T, V>

where S: Source<T>, T: 'static, V: Clone + Default + 'static,

A field is a two-way binding: every control takes one, unchanged.

fn read(&self) -> V

Tracked read: the current value, subscribing the running computation to changes.

fn peek(&self) -> V

Untracked read: the current value, subscribing nothing (the reactive world’s “peek”).

fn write(&self, v: V)

Write the value, waking whatever tracks it.

fn write_preview(&self, v: V)

A live write mid-gesture (Event::ValueChanged): readers must follow, but nothing durable should key off it. Defaults to Binding::write: a plain signal has no notion of “durable”, and a degraded backend that never commits stays correct.

fn write_commit(&self, v: V)

The settled value that ends a gesture (Event::ValueCommitted). Defaults to Binding::write; a day-model field seals its preview session here: one change record, one undo unit, one UPDATE for the whole drag.

fn write_teardown(&self, v: T)

Seal the last preview when its control is disposed. Persistent bindings default to committing; scope-owned signals have already received the preview and may be gone.

impl<S, T, V> Clone for Field<S, T, V>

where S: Copy,

fn clone(&self) -> Field<S, T, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, T, V> Copy for Field<S, T, V>

where S: Copy,

impl<S, T, V> Source<V> for Field<S, T, V>

where S: Source<T>, T: 'static, V: 'static,

A field is itself a source, so item.address().city() works.

fn node(self) -> NodeId

Interning happens here and only here: when a field is used as a parent, which is what nesting one struct inside another means.

const DYNAMIC: bool = S::DYNAMIC

Whether this source’s location can change over the handle’s lifetime: a recycled list slot whose current row rotates. Fields projected from a dynamic source resolve their path through the source on every operation instead of trusting the one cached at projection time, and their tracked reads also run Source::track_extra.

fn track_extra(self)

Extra tracking a projected field’s tracked reads perform. A dynamic source tracks its own rebind signal here, so a control bound at build follows the slot to its next row.

fn path(self) -> Path

The path this source occupies. Implementations revalidate against the interner, so the result is always current.

fn components(self, out: &mut Vec<u64>)

The path as plain components, resolved by walking the handle chain rather than the interner. This is what crosses a thread boundary: a worker names what it changed with components, and the main thread re-establishes them on its own side when it announces.

fn with_value_untracked<R>(self, f: impl FnOnce(Option<&V>) -> R) -> R

fn update_value(self, f: impl FnOnce(&mut V)) -> bool

Returns false when the value is gone (a deleted row), in which case nothing is announced either.

fn bump_version(self)

fn with<R>(self, f: impl FnOnce(Option<&T>) -> R) -> R

Tracked read of the whole value: the coarse subscription.