flo_binding, a data-driven binding libraryflo_binding is a library of types intended to help store state in interactive
applications. A binding is a mutable value that can notify observers when it
changes, or can supply its values as a stream. This is intended to make it easy
to build 'data-driven' applications, where updates to model state automatically
drive updates to the rest of the application.
This method of propagating state is sometimes called 'reactive programming',
and has also been called 'parametric programming' in the past: it's most notable
for being the methodology behind spreadsheets and CAD applications before its
recent rediscovery in web applications. flo_binding prefers the term
'data-driven' as it's a more plain description of how changes are pushed through
an application using the library.
The advantage of using a binding library like this over a standard event-driven architecture is that it's not necessary to send events or manually update state when updating the application data model. Bugs are reduced because it's very much harder for a dependent state update to go missing as this library can automatically associate.
There are three main types of binding provided by the flo_binding library:
A normal binding, created by bind(value) can be updated to a new value by
calling set(). These are useful for representing state that is directly
manipulated by the user.
A computed binding, created by compute(move || { some_func() }). When a
computed binding accesses the value of another binding by calling get(), it
will automatically monitor it for changes and indicate that it has changed
whenever that value changes. This makes it easy to create chains of dependent
bindings.
A stream binding, created by bind_stream(stream, initial_value, |old_value, new_value| { /* ... */ });.
This makes it possible for a binding to update its values in response to a
stream of events, such as might be available from a UI framework.
To make using computed bindings easier to generate, cloning a binding creates
a reference to the same piece of state. ie: let a = bind(1); let b = a.clone();
will give a and b a reference to the same value, so a.set(2); b.get() will
return 2.
The when_changed function can be called to register a function that is called
whenever a binding's value becomes invalidated. Once invalidated, a binding
remains invalidated until it's read with get(), which avoids computing values
for computed bindings that are never used. This can be used to integrate with
traditional UI frameworks.
Calling when_changed() will return a lifetime object: the event will stop firing
when this object is dropped (or when done() is called on it). keep_alive() can
be used to keep the event firing for as long as the binding exists if necessary.
The event-driven approach to application design has many disadvantages: the need to
manage event lifetimes is one, and another important one is the need to pass the
actual bindings around in order to attach events to them, so flo_binding provides
an alternative approach.
A superior alternative to the traditional OO-style event-driven architecture is to take a stream-driven approach. Unlike events, streams can be combined or split, and it's possible to pass around a stream without also providing access to its source, which is a property that can be exploited to produce a less interdependent application. FlowBetween, the application that flo_binding was developed for is an example of a stream-driven application.
Calling follow(binding) will generate a stream of updates from a binding. This
can be used to update part of a user interface directly. It can also be used as
an input for bind_stream() to create more complicated update rules than are
allowed by a simple computed binding.
The companion library desync provides the pipe() and pipe_in() functions
which can be used to schedule events generated by a stream.
```rust
let mut number = bind(1); let numberclone = number.clone(); let plusone = computed(move || numberclone.get() + 1);
let mut lifetime = plusone.when_changed(notify(|| println!("Changed!")));
println!("{}", plusone.get()); // 2
number.set(2); // 'Changed!' println!("{}", plusone.get()); // 3
lifetime.done();
number.set(3); // Lifetime is done, so no notification println!("{}", plusone.get()); // 4
```