#clone #cell #mutability


A Cell that works with a restrictive form of Clone

9 releases

0.4.0 Nov 28, 2022
0.3.1 Oct 10, 2021
0.2.0 Sep 25, 2021
0.1.4 Sep 15, 2021

#249 in Rust patterns

Download history 27/week @ 2022-11-28 3/week @ 2022-12-05 9/week @ 2022-12-12 1/week @ 2022-12-19 1/week @ 2022-12-26 1/week @ 2023-01-02 2/week @ 2023-01-09 1/week @ 2023-01-16 4/week @ 2023-01-23 8/week @ 2023-01-30 17/week @ 2023-02-06 19/week @ 2023-02-13 18/week @ 2023-02-20 18/week @ 2023-02-27 3/week @ 2023-03-06

58 downloads per month


237 lines


clone_cell provides a Cell implementation that works with types whose clone methods are guaranteed not to mutate the Cell content through the &self reference. This is enforced with the provided PureClone trait, which is a subtrait of Clone (and a logical supertrait of Copy). It is only implemented for types with a compliant clone method.


The Cell implementation provided by this crate is intended to be a drop-in replacement of std::cell::Cell. It can work with types that behave like values, such as Rc<T>, Weak<T> (shared pointers themselves are like values; it is the pointees that behave like references), Option<T: PureClone>, and more. Some motivating use cases include implementing the observer pattern and combining Cell with clone-on-write or immutable collections to enable efficient sharing of data structures.

PureClone is currently implemented for the following types:

  • All primitives such as i32, usize, f64, etc;
  • References: &T;
  • Rc<T> and Weak<T>;
  • Option<T: PureClone>; and
  • Tuples: (A: PureClone, ...).

See PureClone for a complete list.


In this example below, we store an Rc<T> in a Cell and later retrieve a copy of it.

use std::rc::Rc;
use clone_cell::cell::Cell;

let x = Cell::new(Rc::new(0));


assert_eq!(*x.get(), 42);

See the documentation for Cell for more.

A proc macro is also provided to derive PureClone for user types safely.

use std::rc::Rc;
use clone_cell::{cell::Cell, clone::PureClone};

// Note: This also generates a `Clone` impl.
struct Foo<T> {
    p: Rc<T>, // `Rc<T>` is always `PureClone`.
    t: Option<T>, // `Option<T>` is `PureClone` if `T` is.
    x: i32, // `i32` is `PureClone`.

let p = Rc::new(-42);
let f = Cell::new(Foo {
    p: p.clone(),
    t: Some(0),
    x: 0,

f.set(Foo {
    t: Some(42),
    x: 21,

assert_eq!(*f.get().p, -42);
assert_eq!(f.get().t, Some(42));
assert_eq!(f.get().x, 21);

See the clone module documentation for more information.


  • Similar to std::cell::Cell, this Cell is !Sync.
  • Since a new trait PureClone is used, there is no out-of-the-box support for types from third-party crates.


This is safe to use, because PureClone is an unsafe trait, and all PureClone implementations are checked. This trait is implemented for:

  • Copy types;
  • Types that perform a shallow clone such as Rc and Weak; and
  • Types whose clone methods are otherwise known to be safe, such as compound types that only contain PureClone types.

See the documentation for more information. Please let me know if you find any soundness issues!


Pull requests are welcome and any feedback is appreciated!