Update docs

README.md

@@ -6,8 +6,8 @@
 ![Tests status](https://github.com/EricLBuehler/trc/actions/workflows/tests.yml/badge.svg)
 
 `Trc` is a performant heap-allocated smart pointer for Rust that implements a version of biased reference counting.
-`Trc<T>` stands for: Thread Reference Counted.
-`Trc<T>` provides a shared ownership of the data similar to `Arc<T>` and `Rc<T>`.
+`Trc` stands for: Thread Reference Counted.
+`Trc` provides a shared ownership of the data similar to `Arc<T>` and `Rc<T>`.
 It implements a custom version of biased reference counting, which is based on the observation that most objects are only used by one thread.
 This means that two reference counts can be created: one for thread-local use, and one atomic one for sharing between threads.
 This implementation of biased reference counting sets the atomic reference count to the number of threads using the data.
@@ -17,7 +17,7 @@ A `Weak<T>` is a non-owning reference to the data held by a `Trc<T>`.
 They break reference cycles by adding a layer of indirection and act as an observer. They cannot even access the data directly, and
 must be converted back into `Trc<T>`. `Weak<T>` does not keep the value alive (whcih can be dropped), and only keeps the backing allocation alive.
 
-To soundly implement thread safety `Trc<T>` does not itself implement `Send` or `Sync`. However, `SharedTrc<T>` does, and it is the only way to safely send a `Trc<T>` across threads. See `SharedTrc` for it's API, which is similar to that of `Weak`.
+To soundly implement thread safety `Trc<T>` does not implement `Send` or `Sync`. However, `SharedTrc<T>` does, and it is the only way to safely send a `Trc<T>` across threads. See `SharedTrc` for it's API, which is similar to that of `Weak`.
 
 
 ## Examples

src/lib.rs

@@ -1,16 +1,18 @@
 //! If you find any issues with `Trc`, I would greatly appreciate you submitting a pull request or issue to the [GitHub page](https://github.com/EricLBuehler/trc).
 //!
-//! `Trc<T>` is a heap-allocated smart pointer for sharing data across threads is a thread-safe and performant manner.
-//! `Trc<T>` stands for: Thread Reference Counted.
-//! `Trc<T>` provides shared ownership of the data similar to `Arc<T>` and `Rc<T>`. In addition, it also provides interior mutability.
-//! It implements a custom version of biased reference counting, which is based on the observation that most objects are only used by one thread.
-//! This means that two reference counts can be created: one for thread-local use, and one atomic one for sharing between threads.
+//! `Trc` is a performant heap-allocated smart pointer for Rust that implements a version of biased reference counting.
+//! `Trc` stands for: Thread Reference Counted.
+//! `Trc` provides shared ownership of the data similar to `Arc<T>` and `Rc<T>`.
+//! It implements biased reference counting, which is based on the observation that most objects are only used by one thread.
+//! This means that two reference counts can be created: one for local thread use, and one atomic one for sharing between threads.
 //! This implementation of biased reference counting sets the atomic reference count to the number of threads using the data.
 //!
+//! ## Breaking reference cycles with `Weak<T>`
 //! A cycle between `Trc` pointers cannot be deallocated as the reference counts will never reach zero. The solution is a `Weak<T>`.
 //! A `Weak<T>` is a non-owning reference to the data held by a `Trc<T>`.
 //! They break reference cycles by adding a layer of indirection and act as an observer. They cannot even access the data directly, and
-//! must be converted back into `Trc<T>`. `Weak<T>` does not keep the value alive (which can be dropped), and only keeps the backing allocation alive.
+//! must be converted back into `Trc<T>`. `Weak<T>` does not keep the value alive (whcih can be dropped), and only keeps the backing allocation alive.
+//! See [`Weak`] for more information.
 
 extern crate alloc;
 

src/trc.rs

@@ -27,9 +27,9 @@ pub struct SharedTrcInternal<T: ?Sized> {
     pub data: T,
 }
 
-/// `Trc<T>` is a performant heap-allocated smart pointer for Rust that implements a version of biased reference counting.
-/// `Trc<T>` stands for: Thread Reference Counted.
-/// `Trc<T>` provides shared ownership of the data similar to `Arc<T>` and `Rc<T>`. In addition, it also provides interior mutability.
+/// `Trc` is a performant heap-allocated smart pointer for Rust that implements a version of biased reference counting.
+/// `Trc` stands for: Thread Reference Counted.
+/// `Trc` provides shared ownership of the data similar to `Arc<T>` and `Rc<T>`.
 /// It implements biased reference counting, which is based on the observation that most objects are only used by one thread.
 /// This means that two reference counts can be created: one for local thread use, and one atomic one for sharing between threads.
 /// This implementation of biased reference counting sets the atomic reference count to the number of threads using the data.