diff options
author | Christian Poveda <christianpoveda@protonmail.com> | 2018-02-23 13:00:26 -0500 |
---|---|---|
committer | Christian Poveda <christianpoveda@protonmail.com> | 2018-02-23 13:00:26 -0500 |
commit | 58d1f839520b97ac06e48aeb49d814282b20056c (patch) | |
tree | d6bee96ed191982cc53d7e7b1d668ec1920c7c32 | |
parent | f9e049afc544e70dc595df67d878b52c098aaa9a (diff) | |
download | rust-58d1f839520b97ac06e48aeb49d814282b20056c.tar.gz |
remove redundant info
-rw-r--r-- | src/libcore/cell.rs | 10 |
1 files changed, 5 insertions, 5 deletions
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 1067b6ff0c1..b3a7d20c4aa 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -17,19 +17,19 @@ //! - Having one mutable reference (`&mut T`) to the object (also know as Mutability). //! //! This is enforced by the Rust compiler. However, there are situations where this rule is not -//! flexible enough. Sometimes is required to have multiple references to an object and yet +//! flexible enough. Sometimes is required to have multiple references to an object and yet //! mutate it. //! //! Shareable mutable containers exist to permit mutability in presence of aliasing in a //! controlled manner. Both `Cell<T>` and `RefCell<T>` allows to do this in a single threaded -//! way, you can mutate them using an inmutable reference. 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 is possible to use `Mutex`, `RwLock` or `AtomicXXX`. +//! 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 is possible to use +//! `Mutex`, `RwLock` or `AtomicXXX`. //! //! Values of the `Cell<T>` and `RefCell<T>` types may be mutated through shared references (i.e. //! the common `&T` type), whereas most Rust types can only be mutated through unique (`&mut T`) //! references. We say that `Cell<T>` and `RefCell<T>` provide 'interior mutability', in contrast -//! with typical Rust types that exhibit 'inherited mutability'. +//! with typical Rust types that exhibit 'inherited mutability'. //! //! Cell types come in two flavors: `Cell<T>` and `RefCell<T>`. `Cell<T>` implements interior //! mutability by moving values in and out of the `Cell<T>`. To use references instead of values, |