# syncell
[](https://crates.io/crates/syncell)
[](https://docs.rs/syncell)
[](https://github.com/kvark/syncell/actions)
[](https://codecov.io/gh/kvark/syncell)
Just a `Sync` alternative to `std::cell::RefCell`. Useful when you have a value to share between tasks/closures,
and you already know or guarantee that the access to the value is safe (for example, via [choir task](https://github.com/kvark/choir) dependencies).
The cost of borrowing is a single atomic operation, and it's riguriously checked by both [Loom](https://github.com/tokio-rs/loom) and [Miri](https://github.com/rust-lang/miri).
## Motivation
Rust already has tools for sharing values between threads, but it strikes me that they are all rather involved and complicated:
> Shareable mutable containers exist to permit mutability in a controlled manner, even in the presence of aliasing. Both `Cell<T>` and `RefCell<T>` allow doing this in a single-threaded way. However, neither `Cell<T>` nor `RefCell<T>` are thread safe (they do not implement `Sync`). If you need to do aliasing and mutation between multiple threads it is possible to use `Mutex<T>`, `RwLock<T>` or atomic types.
This paragraph from [std::cell](https://doc.rust-lang.org/stable/std/cell/index.html) documentation proposes to use lock-based primitives as an alternative in `Sync` world. But what if you just need sharing without locking, and still want safety? `SynCell` comes to help.