21 unstable releases (3 breaking)
0.4.2 | Mar 25, 2024 |
---|---|
0.4.0 | Feb 29, 2024 |
0.2.9 | Oct 24, 2023 |
0.2.2 | Jul 31, 2023 |
#360 in Concurrency
1,438 downloads per month
Used in revive
27KB
244 lines
โโโโโโโ โโโโโโโโ โโโโโโ โโโโโโโโโโโโโโโโโโโโโโ โโโ โโโโโโ โโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโ โโโโโโโโโโโ โโโ โโโโโโ โโโโโโโโโโโ โโโ โโโโโโ โโโโโโโโโโโโโโ โโโโโโโโโโโ โโโ โโโโโโโ โโโโโโโโโโโโ โโโ โโโโโโ โโโ โโโโโโโโโโโโโโ โโโโโโโโโโโ โโโ โโโ โโโโโโโ โโโ โโโ โโโ โโโโโโโโ โโโ โโโโโโโโโโโโโโ โโโ โโโโโโโ โโโ โโโ โโโโโ โโโ โโโ โโโ โโโโโโโโ ------------------------------------------------------------------------------ Thread Safe Reactive Data Structure. Made with โค๏ธ for ๐ฆ
๐ Installation
include it in your Cargo.toml
under [dependencies]
reactivate = { version = "*", features = ["threadsafe"] }
๐งโ๐ป Usage examples
๐๏ธ Construction
use reactivate::Reactive;
fn main() {
let r = Reactive::new(10);
println!("{:?}", r); // Reactive(10)
println!("{:?}", r.value()); // 10
}
๐ฅ Derive
use reactivate::Reactive;
fn main() {
let r = Reactive::new(10);
let d = r.derive(|val| val + 5);
println!("{:?}", r); // Reactive(10)
println!("{:?}", d); // Reactive(15)
}
โจ Update
use reactivate::Reactive;
fn main() {
let r = Reactive::new(10);
let d = r.derive(|val| val + 5);
r.update(|_| 20);
println!("{:?}", r); // Reactive(20)
println!("{:?}", d); // Reactive(25)
}
โก Update Inplace
use reactivate::Reactive;
fn main() {
let r = Reactive::new(vec![1, 2, 3]);
let d = r.derive(|nums| nums.iter().sum::<i32>());
r.update_inplace(|nums| {
nums.push(4);
nums.push(5);
nums.push(6);
});
println!("{:?}", r); // Reactive([1, 2, 3, 4, 5, 6])
println!("{:?}", d); // Reactive(21)
}
๐ค Merge and Derive
use reactivate::{Merge, Reactive};
fn main() {
let a = Reactive::new(String::from("hazash"));
let b = Reactive::new(0);
let d = (&a, &b)
.merge()
.derive(|(a_val, b_val)| a_val.len() + b_val);
println!("{:?}", a); // Reactive("hazash")
println!("{:?}", b); // Reactive(0)
println!("{:?}", d); // Reactive(6)
b.update(|_| 5);
println!("{:?}", a); // Reactive("hazash")
println!("{:?}", b); // Reactive(5)
println!("{:?}", d); // Reactive(11)
a.update(|_| String::from("mouse"));
println!("{:?}", a); // Reactive("mouse")
println!("{:?}", b); // Reactive(5)
println!("{:?}", d); // Reactive(10)
}
๐ Add Observers
use reactivate::Reactive;
use std::sync::{Arc, Mutex};
fn main() {
let r: Reactive<String> = Reactive::default();
// Arc<Mutex<T>> is used to make the vector thread safe
// because Reactive as a whole must be thread safe
let changes: Arc<Mutex<Vec<String>>> = Default::default();
r.add_observer({
let changes = changes.clone();
move |val| changes.lock().unwrap().push(val.clone())
});
r.update(|_| String::from("a"));
r.update_inplace(|s| {
s.push('b');
});
println!("{:?}", r); // Reactive("ab")
println!("{:?}", changes.lock().unwrap().clone()); // ["a", "ab"]
}
๐งต With Threads (features = ["threadsafe"])
use reactivate::Reactive;
use std::{thread, time::Duration};
fn main() {
let r: Reactive<String> = Reactive::default();
let d = r.derive(|s| s.len());
let handle = thread::spawn({
let r = r.clone();
move || {
for _ in 0..10 {
r.update_inplace(|s| s.push('a'));
thread::sleep(Duration::from_millis(1));
}
}
});
for _ in 0..10 {
r.update_inplace(|s| s.push('b'));
thread::sleep(Duration::from_millis(1));
}
handle.join().unwrap();
println!("{:?}", r); // Reactive("babababababababababa")
println!("{:?}", d); // Reactive(20)
}
๐ Connect with Us
M. Zahash โ zahash.z@gmail.com
Distributed under the MIT license. See LICENSE
for more information.
๐ค Contribute to Reactivate!
- Fork it (https://github.com/zahash/reactivate/fork)
- Create your feature branch (
git checkout -b feature/fooBar
) - Commit your changes (
git commit -am 'Add some fooBar'
) - Push to the branch (
git push origin feature/fooBar
) - Create a new Pull Request
โค๏ธ Show Some Love!
If you find Reactivate helpful and enjoy using it, consider giving it a โญ on GitHub! Your star is a gesture of appreciation and encouragement for the continuous improvement of Reactivate.