65 lines
3.1 KiB
Markdown
65 lines
3.1 KiB
Markdown
# r3vi - Rust Runtime for Reactive View-Projections
|
|
|
|
**r3vi** is a Rust library designed to handle reactive transformations on data views, known as *Projections*. These projections are updated incrementally and efficiently whenever the source data changes, utilizing fine-grained diffs.
|
|
|
|
## Key Concepts
|
|
- **Views**: Abstract accessor interfaces that define the protocol for updates, including the structure of the diffs.
|
|
- **Observers**: Entities that can register to monitor a *View* and receive notifications with the appropriate diff messages whenever the view undergoes changes.
|
|
- **Projections**: Transformations from one view to another. A projection comprises a target view and an observer that listens to changes in the source view and updates the target view accordingly.
|
|
r3vi provides essential data structures and projections to build projectional pipelines with an interface similar to native Rust iterators, enabling seamless and reactive data transformations.
|
|
|
|
### Examples
|
|
Below is an example demonstrating how to use **r3vi** to create and manipulate reactive views:
|
|
|
|
```rust
|
|
use r3vi::buffer::vec::*;
|
|
|
|
fn main() {
|
|
// Create a new VecBuffer of i32
|
|
let mut buffer = VecBuffer::<i32>::new();
|
|
buffer.push(3);
|
|
|
|
// Create a projected port from the buffer
|
|
let projected_port = buffer.get_port()
|
|
.to_sequence() // Convert VecBuffer to SequenceView
|
|
.map(|x| x + 10)
|
|
.filter(|x| *x > 10);
|
|
|
|
// Obtain the projected view
|
|
let projected_view = projected_port.get_view();
|
|
|
|
// Assert initial values in the projected view
|
|
assert_eq!(projected_view.get(&0), Some(13));
|
|
|
|
// Add more elements to the buffer and observe changes in the projected view
|
|
buffer.push(5); // 5 maps to 15 in the projection
|
|
buffer.push(-9); // -9 maps to 1, which is filtered out
|
|
buffer.push(1); // 1 maps to 11 in the projection
|
|
|
|
// Assert updated values in the projected view
|
|
assert_eq!(projected_view.get(&1), Some(15));
|
|
assert_eq!(projected_view.get(&2), Some(11));
|
|
}
|
|
```
|
|
|
|
### How It Works
|
|
1. **Creating a Buffer**: We start by creating a `VecBuffer` to store integers.
|
|
2. **Defining a Projection**: Using `get_port()`, we convert the buffer to a sequence view, apply a map transformation to add 10 to each element, and then filter out values less than or equal to 10.
|
|
3. **Obtaining a View**: The transformed data is accessed through `get_view()`, allowing us to interact with the projected data.
|
|
4. **Reactive Updates**: As new elements are added to the buffer, the projections update reactively, maintaining the transformations and filters defined.
|
|
|
|
This example demonstrates the reactive nature of **r3vi**'s projections, where changes in the source data are automatically and incrementally propagated to the target view.
|
|
|
|
### Getting Started
|
|
To start using **r3vi**, add it to your `Cargo.toml`:
|
|
|
|
```toml
|
|
[dependencies]
|
|
r3vi = "0.1"
|
|
```
|
|
|
|
For detailed documentation and more examples, please refer to the official documentation.
|
|
|
|
## License
|
|
This project is licensed under the [GPLv3](COPYING) License.
|
|
|