diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..e9f2f13
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: [ecton]
\ No newline at end of file
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000..edd43e9
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,28 @@
+name: Docs
+
+on: [push, pull_request]
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Rust
+        uses: hecrj/setup-rust-action@v1
+        with:
+          rust-version: nightly
+
+      - uses: actions/checkout@v3
+      - name: Generate Docs
+        run: |
+          cargo +nightly doc --no-deps --all-features
+
+      - name: Deploy Docs
+        if: github.ref == 'refs/heads/main'
+        uses: JamesIves/github-pages-deploy-action@releases/v4
+        with:
+          branch: gh-pages
+          folder: target/doc/
+          git-config-name: kl-botsu
+          git-config-email: botsu@khonsulabs.com
+          target-folder: /main/
+          clean: true
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
new file mode 100644
index 0000000..dae6ed2
--- /dev/null
+++ b/.github/workflows/rust.yml
@@ -0,0 +1,51 @@
+name: Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: hecrj/setup-rust-action@v1
+
+      - name: Run clippy
+        run: |
+          cargo clippy
+
+      - name: Run unit tests
+        run: |
+          cargo test --all-targets
+
+  miri:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: hecrj/setup-rust-action@v1
+        with:
+          components: cargo,rustc,rust-std,miri
+          rust-version: nightly
+
+      - name: Run unit tests
+        run: |
+          cargo +nightly miri test
+        env:
+          MIRIFLAGS: "-Zmiri-permissive-provenance -Zmiri-ignore-leaks"
+
+  build-msrv:
+    name: Test on MSRV
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust
+        uses: hecrj/setup-rust-action@v1
+        with:
+          rust-version: 1.65
+      - name: Run unit tests
+        run: cargo test --all-targets
diff --git a/Cargo.lock b/Cargo.lock
index f4d6168..21c7169 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -287,6 +287,12 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
+[[package]]
+name = "intentional"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbc48117ac1523428c576e39831e93043112e2d2be0223bb0c0593af944e4e38"
+
 [[package]]
 name = "is-terminal"
 version = "0.4.12"
@@ -374,6 +380,7 @@ dependencies = [
  "criterion",
  "crossbeam-utils",
  "flume 0.11.0",
+ "intentional",
  "kempt",
  "nanorand",
  "parking_lot",
diff --git a/Cargo.toml b/Cargo.toml
index bbfeefb..554dde3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,13 +2,13 @@
 name = "musegc"
 version = "0.1.0"
 edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+rust-version = "1.73.0"
 
 [dependencies]
 ahash = "0.8.11"
 crossbeam-utils = "0.8.19"
 flume = "0.11.0"
+intentional = "0.1.1"
 kempt = "0.2.3"
 nanorand = { version = "0.7.0", default-features = false, features = [
     "std",
@@ -20,6 +20,9 @@ parking_lot = { version = "0.12.1", features = ["arc_lock"] }
 criterion = "0.5"
 timings = { path = "../timings" }
 
+[lints.clippy]
+pedantic = "warn"
+
 [[bench]]
 name = "vs-arc"
 harness = false
diff --git a/README.md b/README.md
index 8b122d3..b6e943d 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,38 @@
 
 An easy-to-use, incremental, multi-threaded garbage collector for Rust.
 
+```rust
+use musegc::{CollectionGuard, Root, Ref};
+
+// Execute a closure with access to a garbage collector.
+musegc::collected(|| {
+    let mut guard = CollectionGuard::acquire();
+    // Allocate a vec![Ref(1), Ref(2), Ref(3)].
+    let values: Vec<Ref<u32>> = (1..=3).map(|value| Ref::new(value, &mut guard)).collect();
+    let values = Root::new(values, &mut guard);
+    drop(guard);
+
+    // Manually execute the garbage collector. Our data will not be freed,
+    // since `values` is a "root" reference.
+    musegc::collect();
+
+    // Root references allow direct access to their data, even when a
+    // `CollectionGuard` isn't held.
+    let (one, two, three) = (values[0], values[1], values[2]);
+
+    // Accessing the data contained in a `Ref` requires a guard, however.
+    let mut guard = CollectionGuard::acquire();
+    assert_eq!(one.load(&guard), Some(&1));
+    assert_eq!(two.load(&guard), Some(&2));
+    assert_eq!(three.load(&guard), Some(&3));
+
+    // Dropping our root will allow the collector to free our `Ref`s.
+    drop(values);
+    guard.collect();
+    assert!(one.load(&guard).is_none());
+});
+```
+
 ## Motivation
 
 While working on [Muse][muse], @Ecton recognized [the need for garbage
@@ -22,20 +54,20 @@ Tracing garbage collectors can be implemented in various ways to identify the
 "roots" of known memory so that they can trace from the roots through all
 necessary references to determine which memory allocations can be freed.
 
-This crate exposes a `Strong<T>` type which behaves similarly to an `Arc<T>` but
-automatically becomes a root for the collector. `Strong<T>` implements
+This crate exposes a `Root<T>` type which behaves similarly to an `Arc<T>` but
+automatically becomes a root for the collector. `Root<T>` implements
 `Deref<Target = T>`, allowing access to the underlying data even while the
 collector is running.
 
-The `Weak<T>` type implements `Copy` and does not provide direct access to the
+The `Ref<T>` type implements `Copy` and does not provide direct access to the
 underlying data. To get a reference to the underlying data, a weak reference
 must be upgraded using a `CollectionGuard`. The returned reference is tied to
 the guard, which prevents collection from running while any guards are held.
 
 A `CollectionGuard` is needed to:
 
-- Allocate a new `Strong<T>` or `Weak<T>`
-- Upgrade a `Weak<T>` to an `&T`
+- Allocate a new `Root<T>` or `Ref<T>`
+- Load an `&T` from a `Ref<T>`
 
 ## Safety
 
@@ -61,9 +93,9 @@ triggered by incorrectly using the API or implementing the `Collectable` trait
 incorrectly. **Incorrect usage of this crate can lead to deadlocks and memory
 leaks.** Specifically:
 
-- Reference cycles between `Strong<T>`'s will lead to leaks just as `Arc<T>`'s
+- Reference cycles between `Root<T>`'s will lead to leaks just as `Arc<T>`'s
   will.
-- If a `Strong<T>` uses locking for interior mutability, holding a lock without
+- If a `Root<T>` uses locking for interior mutability, holding a lock without
   a collector guard can cause the garbage collector to block until the lock is
   released. This escalates from a pause to a deadlock if the lock can't be
   released without acquiring a collection guard. **All locks should acquired and
@@ -83,8 +115,8 @@ leaks.** Specifically:
 
 Benchmarking is hard. These benchmarks aren't adequate. These numbers are from
 executing `benches/timings.rs`, which compares allocating 100,000 32-byte values,
-comparing the time it takes to allocate each `Arc<[u8; 32]>`, `Strong<[u8;32]>`,
-and `Weak<[u8; 32]>`. The measurements are the amount of time it takes for an
+comparing the time it takes to allocate each `Arc<[u8; 32]>`, `Root<[u8;32]>`,
+and `Ref<[u8; 32]>`. The measurements are the amount of time it takes for an
 individual allocation. These results are from running on a Ryzen 3700X.
 
 ### 1 thread
@@ -92,40 +124,40 @@ individual allocation. These results are from running on a Ryzen 3700X.
 | Label  | avg     | min     | max     | stddev  | out%   |
 |--------|---------|---------|---------|---------|--------|
 | Arc    | 47.87ns | 20.00ns | 11.27us | 151.4ns | 0.010% |
-| Strong | 62.02ns | 30.00ns | 182.2us | 1.367us | 0.000% |
-| Weak   | 65.89ns | 30.00ns | 439.2us | 1.556us | 0.001% |
+| Root | 62.02ns | 30.00ns | 182.2us | 1.367us | 0.000% |
+| Ref   | 65.89ns | 30.00ns | 439.2us | 1.556us | 0.001% |
 
 ### 4 threads
 
 | Label  | avg     | min     | max     | stddev  | out%   |
 |--------|---------|---------|---------|---------|--------|
 | Arc    | 47.21ns | 20.00ns | 5.810us | 138.0ns | 0.010% |
-| Strong | 147.5ns | 30.00ns | 314.4us | 3.849us | 0.001% |
-| Weak   | 71.03ns | 30.00ns | 633.3us | 2.464us | 0.000% |
+| Root | 147.5ns | 30.00ns | 314.4us | 3.849us | 0.001% |
+| Ref   | 71.03ns | 30.00ns | 633.3us | 2.464us | 0.000% |
 
 ### 8 threads
 
 | Label  | avg     | min     | max     | stddev  | out%   |
 |--------|---------|---------|---------|---------|--------|
 | Arc    | 48.91ns | 20.00ns | 65.56us | 172.4ns | 0.010% |
-| Strong | 186.8ns | 30.00ns | 729.9us | 6.224us | 0.000% |
-| Weak   | 109.4ns | 30.00ns | 1.136ms | 5.817us | 0.000% |
+| Root | 186.8ns | 30.00ns | 729.9us | 6.224us | 0.000% |
+| Ref   | 109.4ns | 30.00ns | 1.136ms | 5.817us | 0.000% |
 
 ### 16 threads
 
 | Label  | avg     | min     | max     | stddev  | out%   |
 |--------|---------|---------|---------|---------|--------|
 | Arc    | 55.47ns | 20.00ns | 248.9us | 354.6ns | 0.010% |
-| Strong | 323.1ns | 30.00ns | 3.105ms | 18.29us | 0.000% |
-| Weak   | 206.6ns | 30.00ns | 3.492ms | 16.00us | 0.000% |
+| Root | 323.1ns | 30.00ns | 3.105ms | 18.29us | 0.000% |
+| Ref   | 206.6ns | 30.00ns | 3.492ms | 16.00us | 0.000% |
 
 ### 32 threads
 
 | Label  | avg     | min     | max     | stddev  | out%   |
 |--------|---------|---------|---------|---------|--------|
 | Arc    | 67.12ns | 20.00ns | 260.0us | 783.3ns | 0.001% |
-| Strong | 616.7ns | 30.00ns | 11.91ms | 55.58us | 0.000% |
-| Weak   | 432.5ns | 30.00ns | 13.66ms | 49.14us | 0.000% |
+| Root | 616.7ns | 30.00ns | 11.91ms | 55.58us | 0.000% |
+| Ref   | 432.5ns | 30.00ns | 13.66ms | 49.14us | 0.000% |
 
 ### Author's Benchmark Summary
 
@@ -133,7 +165,7 @@ In these benchmarks, 100 allocations are collected into a pre-allocated `Vec`.
 The `Vec` is cleared, and then the process is repeated 1,000 total times
 yielding 100,000 total allocations.
 
-In both the `Strong` and `Weak` benchmarks, explicit calls to
+In both the `Root` and `Ref` benchmarks, explicit calls to
 `CollectorGuard::yield_to_collector()` are placed after the `Vec` is cleared.
 The measurements include time waiting for the incremental garbage collector to
 run during these yield points.
diff --git a/benches/timings.rs b/benches/timings.rs
index 72d5c9b..98a3f09 100644
--- a/benches/timings.rs
+++ b/benches/timings.rs
@@ -1,8 +1,10 @@
+//! A multi-threaded benchmark
+
 use std::convert::Infallible;
 use std::hint::black_box;
 use std::sync::Arc;
 
-use musegc::{collected, CollectionGuard, Strong, Weak};
+use musegc::{collected, CollectionGuard, Ref, Root};
 use timings::{Benchmark, BenchmarkImplementation, Label, LabeledTimings, Timings};
 
 const TOTAL_ITERS: usize = 100_000;
@@ -15,8 +17,8 @@ fn main() {
     Benchmark::default()
         .with_each_number_of_threads([1, 4, 8, 16, 32])
         .with::<StdArc>()
-        .with::<GcWeak>()
-        .with::<GcStrong>()
+        .with::<GcRef>()
+        .with::<GcRoot>()
         .run(&timings)
         .unwrap();
 
@@ -71,11 +73,11 @@ impl BenchmarkImplementation<Label, (), Infallible> for StdArc {
     }
 }
 
-struct GcWeak {
+struct GcRef {
     metric: Label,
 }
 
-impl BenchmarkImplementation<Label, (), Infallible> for GcWeak {
+impl BenchmarkImplementation<Label, (), Infallible> for GcRef {
     type SharedConfig = Label;
 
     fn label(_number_of_threads: usize, _config: &()) -> Label {
@@ -102,13 +104,13 @@ impl BenchmarkImplementation<Label, (), Infallible> for GcWeak {
     }
 
     fn measure(&mut self, measurements: &LabeledTimings<Label>) -> Result<(), Infallible> {
-        let mut allocated = Vec::<Weak<[u8; 32]>>::with_capacity(ITERS_PER_RELEASE);
+        let mut allocated = Vec::<Ref<[u8; 32]>>::with_capacity(ITERS_PER_RELEASE);
         collected(|| {
             let mut guard = CollectionGuard::acquire();
             for _ in 0..OUTER_ITERS {
                 for i in 0..ITERS_PER_RELEASE {
                     let timing = measurements.begin(self.metric.clone());
-                    let result = black_box(Weak::new([0; 32], &mut guard));
+                    let result = black_box(Ref::new([0; 32], &mut guard));
                     if i == ITERS_PER_RELEASE - 1 {
                         allocated.clear();
                         guard.yield_to_collector();
@@ -123,11 +125,11 @@ impl BenchmarkImplementation<Label, (), Infallible> for GcWeak {
     }
 }
 
-struct GcStrong {
+struct GcRoot {
     metric: Label,
 }
 
-impl BenchmarkImplementation<Label, (), Infallible> for GcStrong {
+impl BenchmarkImplementation<Label, (), Infallible> for GcRoot {
     type SharedConfig = Label;
 
     fn label(_number_of_threads: usize, _config: &()) -> Label {
@@ -154,13 +156,13 @@ impl BenchmarkImplementation<Label, (), Infallible> for GcStrong {
     }
 
     fn measure(&mut self, measurements: &LabeledTimings<Label>) -> Result<(), Infallible> {
-        let mut allocated = Vec::<Strong<[u8; 32]>>::with_capacity(ITERS_PER_RELEASE);
+        let mut allocated = Vec::<Root<[u8; 32]>>::with_capacity(ITERS_PER_RELEASE);
         collected(|| {
             let mut guard = CollectionGuard::acquire();
             for _ in 0..OUTER_ITERS {
                 for i in 0..ITERS_PER_RELEASE {
                     let timing = measurements.begin(self.metric.clone());
-                    let result = black_box(Strong::new([0; 32], &mut guard));
+                    let result = black_box(Root::new([0; 32], &mut guard));
                     if i == ITERS_PER_RELEASE - 1 {
                         allocated.clear();
                         guard.yield_to_collector();
diff --git a/benches/vs-arc.rs b/benches/vs-arc.rs
index 52fb699..4653dd9 100644
--- a/benches/vs-arc.rs
+++ b/benches/vs-arc.rs
@@ -1,17 +1,19 @@
+//! A single-threaded benchmark run by Criterion.
+
 use std::sync::Arc;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use musegc::{collected, CollectionGuard, Strong, Weak};
+use musegc::{collected, CollectionGuard, Ref, Root};
 
 fn arc_string() -> Arc<[u8; 32]> {
     Arc::new([0; 32])
 }
 
-fn strong_string(guard: &mut CollectionGuard) -> Strong<[u8; 32]> {
-    Strong::new([0; 32], guard)
+fn strong_string(guard: &mut CollectionGuard) -> Root<[u8; 32]> {
+    Root::new([0; 32], guard)
 }
-fn weak_string(guard: &mut CollectionGuard) -> Weak<[u8; 32]> {
-    Weak::new([0; 32], guard)
+fn weak_string(guard: &mut CollectionGuard) -> Ref<[u8; 32]> {
+    Ref::new([0; 32], guard)
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
@@ -22,13 +24,13 @@ fn criterion_benchmark(c: &mut Criterion) {
             b.iter(move || {
                 let mut guard = CollectionGuard::acquire();
                 black_box(weak_string(&mut guard))
-            })
+            });
         });
         group.bench_function("strong", |b| {
             b.iter(move || {
                 let mut guard = CollectionGuard::acquire();
                 black_box(strong_string(&mut guard))
-            })
+            });
         });
     });
 }
diff --git a/examples/allocate_a_lot.rs b/examples/allocate_a_lot.rs
index 0427b7d..e839d8b 100644
--- a/examples/allocate_a_lot.rs
+++ b/examples/allocate_a_lot.rs
@@ -1,14 +1,14 @@
-use musegc::{collected, CollectionGuard, Weak};
+use musegc::{collected, CollectionGuard, Ref};
 
 fn main() {
     // collected(|| {
     //     let mut guard = CollectionGuard::acquire();
     //     for _ in 0..1000 {
-    //         Weak::new([0; 32], &mut guard);
+    //         Ref::new([0; 32], &mut guard);
     //     }
     //     guard.collect();
     //     for _ in 0..1000 {
-    //         Weak::new([0; 32], &mut guard);
+    //         Ref::new([0; 32], &mut guard);
     //     }
     //     guard.collect();
     // });
@@ -17,9 +17,9 @@ fn main() {
             s.spawn(|| {
                 collected(|| {
                     let mut guard = CollectionGuard::acquire();
-                    for _ in 0..1000 {
+                    for _ in 0..100 {
                         for _ in 0..100 {
-                            Weak::new([0; 32], &mut guard);
+                            Ref::new([0; 32], &mut guard);
                         }
                         guard.yield_to_collector();
                     }
diff --git a/examples/basic.rs b/examples/basic.rs
new file mode 100644
index 0000000..2931a5c
--- /dev/null
+++ b/examples/basic.rs
@@ -0,0 +1,31 @@
+use musegc::{CollectionGuard, Ref, Root};
+
+fn main() {
+    // Execute a closure with access to a garbage collector.
+    musegc::collected(|| {
+        let mut guard = CollectionGuard::acquire();
+        // Allocate a vec![Ref(1), Ref(2), Ref(3)].
+        let values: Vec<Ref<u32>> = (1..=3).map(|value| Ref::new(value, &mut guard)).collect();
+        let values = Root::new(values, &mut guard);
+        drop(guard);
+
+        // Manually execute the garbage collector. Our data will not be freed,
+        // since `values` is a "root" reference.
+        musegc::collect();
+
+        // Root references allow direct access to their data, even when a
+        // `CollectionGuard` isn't held.
+        let (one, two, three) = (values[0], values[1], values[2]);
+
+        // Accessing the data contained in a `Ref` requires a guard, however.
+        let mut guard = CollectionGuard::acquire();
+        assert_eq!(one.load(&guard), Some(&1));
+        assert_eq!(two.load(&guard), Some(&2));
+        assert_eq!(three.load(&guard), Some(&3));
+
+        // Dropping our root will allow the collector to free our `Ref`s.
+        drop(values);
+        guard.collect();
+        assert!(one.load(&guard).is_none());
+    });
+}
diff --git a/src/lib.rs b/src/lib.rs
index db99487..9744677 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+#![warn(missing_docs)]
 use core::slice;
 use std::alloc::{alloc_zeroed, Layout};
 use std::any::{Any, TypeId};
@@ -10,14 +12,15 @@ use std::panic::AssertUnwindSafe;
 use std::sync::atomic::{self, AtomicBool, AtomicU32, AtomicU64, AtomicU8, Ordering};
 use std::sync::{Arc, OnceLock};
 use std::time::{Duration, Instant};
-use std::{array, ptr, thread};
+use std::{array, thread};
 
 use ahash::AHashMap;
 use flume::{Receiver, RecvError, RecvTimeoutError, Sender};
+use intentional::{Assert, Cast};
 use kempt::Map;
 use nanorand::{Rng, WyRand};
 use parking_lot::lock_api::ArcRwLockReadGuard;
-use parking_lot::{Condvar, Mutex, RwLock};
+use parking_lot::{Condvar, Mutex, RwLock, RwLockWriteGuard};
 
 #[derive(Clone, Copy, Eq, PartialEq, Hash)]
 struct CollectorThreadId(u64);
@@ -41,7 +44,7 @@ impl CollectorCommand {
         GlobalCollector::get()
             .sender
             .send(self)
-            .expect("collector not running")
+            .expect("collector not running");
     }
 
     fn schedule_collect_if_needed() {
@@ -171,7 +174,7 @@ impl Collector {
                                 request.thread,
                                 &request.mark_one_sender,
                                 request.mark_bits,
-                            ))
+                            ));
                         }
                     }
                 });
@@ -213,7 +216,7 @@ impl Collector {
                         }
                     }
                     CollectorCommand::ScheduleCollect => {
-                        self.schedule_gc(Instant::now() + self.average_collection * 5)
+                        self.schedule_gc(Instant::now() + self.average_collection * 5);
                     }
                 }
             }
@@ -222,7 +225,7 @@ impl Collector {
             // full cleanup. Because of thread local storage limitations, this
             // may never execute on some platforms.
             drop(channels);
-        })
+        });
     }
 
     fn collect_and_notify(&mut self, channels: &CollectorThreadChannels) {
@@ -262,22 +265,21 @@ impl Collector {
             .store(false, Ordering::Relaxed);
     }
 
-    fn collect(&mut self, threads: &CollectorThreadChannels) -> CollectResult {
-        self.mark_bits = self.mark_bits.wrapping_add(1);
-        if self.mark_bits == 0 {
-            self.mark_bits = 1;
-        }
-
+    fn acquire_all_locks<'a>(
+        thread_bins: &'a AHashMap<CollectorThreadId, ThreadBins>,
+        start: Instant,
+        average_collection_locking: Duration,
+        pause_failures: u8,
+        rng: &mut WyRand,
+    ) -> Option<AHashMap<CollectorThreadId, RwLockWriteGuard<'a, Bins>>> {
         let mut all_bins = AHashMap::new();
-        let start = Instant::now();
         let mut now = start;
-        let force_gc = self.pause_failures >= 5;
-        let mut lock_wait = (self.average_collection_locking / 8).max(Duration::from_millis(
-            2 * u64::from(self.pause_failures + 1),
-        ));
+        let force_gc = pause_failures >= 5;
+        let mut lock_wait = (average_collection_locking / 8)
+            .max(Duration::from_millis(2 * u64::from(pause_failures + 1)));
         let long_lock_deadline = now + lock_wait * 8;
 
-        let mut bins_to_lock = self.thread_bins.keys().copied().collect::<Vec<_>>();
+        let mut bins_to_lock = thread_bins.keys().copied().collect::<Vec<_>>();
         while !bins_to_lock.is_empty() {
             let lock_deadline = now + lock_wait;
             let lock_deadline = if force_gc {
@@ -291,10 +293,7 @@ impl Collector {
             loop {
                 let thread = bins_to_lock[bin];
 
-                if let Some(locked) = self.thread_bins[&thread]
-                    .bins
-                    .try_write_until(lock_deadline)
-                {
+                if let Some(locked) = thread_bins[&thread].bins.try_write_until(lock_deadline) {
                     all_bins.insert(thread, locked);
                     bins_to_lock.remove(bin);
                     if bin > 0 {
@@ -310,18 +309,33 @@ impl Collector {
             if !bins_to_lock.is_empty() {
                 now = Instant::now();
                 lock_wait *= 2;
-                self.rng.shuffle(&mut bins_to_lock);
+                rng.shuffle(&mut bins_to_lock);
             }
         }
 
-        if !bins_to_lock.is_empty() {
-            drop(all_bins);
-            return CollectResult::CouldntRun;
+        bins_to_lock.is_empty().then_some(all_bins)
+    }
+
+    fn collect(&mut self, threads: &CollectorThreadChannels) -> CollectResult {
+        self.mark_bits = self.mark_bits.wrapping_add(1);
+        if self.mark_bits == 0 {
+            self.mark_bits = 1;
         }
 
+        let start = Instant::now();
+        let Some(mut all_bins) = Self::acquire_all_locks(
+            &self.thread_bins,
+            start,
+            self.average_collection_locking,
+            self.pause_failures,
+            &mut self.rng,
+        ) else {
+            self.pause_failures += 1;
+            return CollectResult::CouldntRun;
+        };
+
         let locking_time = start.elapsed();
         self.average_collection_locking = (locking_time + self.average_collection_locking * 2) / 3;
-
         self.pause_failures = 0;
 
         let (mark_one_sender, mark_ones) = flume::bounded(1024);
@@ -460,6 +474,15 @@ impl Drop for ThreadLocalBins {
     }
 }
 
+/// Executes `wrapped` with garbage collection available.
+///
+/// This function installs a garbage collector for this thread, if needed.
+/// Repeated and nested calls are allowed.
+///
+/// Invoking [`CollectionGuard::acquire()`] within `wrapped` will return a
+/// result, while invoking it outside of a collected context will panic.
+///
+/// This function utilizes Rust's thread-local storage.
 pub fn collected<R>(wrapped: impl FnOnce() -> R) -> R {
     // We initialize the global collector by invoking get.
     GlobalCollector::get();
@@ -475,12 +498,40 @@ pub fn collected<R>(wrapped: impl FnOnce() -> R) -> R {
 }
 
 type ArcRwBinGuard = ArcRwLockReadGuard<parking_lot::RawRwLock, Bins>;
+
+/// A guard that prevents garbage collection while held.
+///
+/// To perform garbage collection, all threads must be paused to be traced. A
+/// [`CollectionGuard`] allows the ability to read garbage-collectable data by
+/// ensuring the garbage collector can't run while it exists.
+///
+/// To ensure the garbage collector can run without long pauses, either:
+///
+/// - Acquire [`CollectionGuard`]s for short periods of time, dropping the
+///   guards when not needed.
+/// - Call [`CollectionGuard::yield_to_collector()`] at a regular basis. This
+///   function is very cheap to invoke if the collector is not trying to acquire
+///   the lock.
+///
+/// This type should not be held across potentially blocking operations such as
+/// IO, reading from a channel, or any other operation that may pause the
+/// current thread. [`CollectionGuard::while_unlocked()`] can be used to
+/// temporarily release a guard during a long operation.
 pub struct CollectionGuard {
     thread: ThreadLocalBins,
     inner: MaybeUninit<ArcRwBinGuard>,
 }
 
 impl CollectionGuard {
+    /// Manually invokes the garbage collector.
+    ///
+    /// This method temporarily releases this guard's lock and waits for a
+    /// garbage collection to run. If a garbage collection is already in
+    /// progress, this function will return when the in-progress collection
+    /// completes. Otherwise, the collector is started and this function waits
+    /// until the collection finishes.
+    ///
+    /// Finally, the guard is reacquired before returning.
     pub fn collect(&mut self) {
         // SAFETY: The guard is always present except during internal code which
         // never invokes this function. We can assume_init_mut since we have mut
@@ -491,6 +542,12 @@ impl CollectionGuard {
         ArcRwBinGuard::unlocked(guard, collect);
     }
 
+    /// Yield to the garbage collector, if needed.
+    ///
+    /// This function will not yield unless the garbage collector is trying to
+    /// acquire this thread's lock. Because of this, it is a fairly efficient
+    /// function to invoke. To minimize collection pauses, long-held guards
+    /// should call this function regularly.
     pub fn yield_to_collector(&mut self) {
         // SAFETY: The guard is always present except during internal code which
         // never invokes this function. We can assume_init_mut since we have mut
@@ -501,6 +558,17 @@ impl CollectionGuard {
         ArcRwBinGuard::bump(guard);
     }
 
+    /// Executes `unlocked` while this guard is temporarily released.
+    pub fn while_unlocked<R>(&mut self, unlocked: impl FnOnce() -> R) -> R {
+        // SAFETY: The guard is always present except during internal code which
+        // never invokes this function. We can assume_init_mut since we have mut
+        // reference to self. Because this function can invalidate references
+        // tied to this guard's lifetime, ownership of the guard is taken to
+        // force the compiler to invalidate any borrows.
+        let guard = unsafe { self.inner.assume_init_mut() };
+        ArcRwBinGuard::unlocked(guard, unlocked)
+    }
+
     /// # Safety
     ///
     /// This function should only be called when the underlying guard is
@@ -532,6 +600,11 @@ impl CollectionGuard {
 }
 
 impl CollectionGuard {
+    /// Acquires a lock that prevents the garbage collector from running.
+    ///
+    /// This guard is used to provide read-only access to garbage collected
+    /// allocations.
+    #[must_use]
     pub fn acquire() -> Self {
         let thread = ThreadLocalBins::get();
         Self {
@@ -549,12 +622,26 @@ impl Drop for CollectionGuard {
     }
 }
 
+/// A type that can be garbage collected.
 pub trait Collectable: Send + Sync + 'static {
+    /// If true, this type may contain references and should have its `trace()`
+    /// function invoked during the collector's "mark" phase.
     const MAY_CONTAIN_REFERENCES: bool;
 
+    /// Traces all refrences that this value references.
+    ///
+    /// This function should invoke [`Tracer::mark()`] for each [`Ref<T>`] it
+    /// contains. Failing to do so will allow the garbage collector to free the
+    /// data, preventing the ability to [`load()`](Ref::load) the data in the
+    /// future.
     fn trace(&self, tracer: &mut Tracer);
 }
 
+/// A type that can be garbage collected that cannot contain any [`Ref<T>`]s.
+///
+/// Types that implement this trait automatically implement [`Collectable`].
+/// This trait reduces the boilerplate for implementing [`Collectable`] for
+/// self-contained types.
 pub trait ContainsNoCollectables {}
 
 impl<T> Collectable for T
@@ -591,6 +678,7 @@ where
         }
     }
 }
+
 impl<T, const N: usize> Collectable for [T; N]
 where
     T: Collectable,
@@ -604,31 +692,33 @@ where
     }
 }
 
-impl<T> Collectable for Strong<T>
+impl<T> Collectable for Root<T>
 where
     T: Collectable,
 {
     const MAY_CONTAIN_REFERENCES: bool = T::MAY_CONTAIN_REFERENCES;
 
     fn trace(&self, _tracer: &mut Tracer) {
-        // Strong<T> is already a root, thus calling trace on a Strong<T> has no
+        // Root<T> is already a root, thus calling trace on a Root<T> has no
         // effect.
     }
 }
 
-impl<T> Collectable for Weak<T>
+impl<T> Collectable for Ref<T>
 where
     T: Collectable,
 {
-    const MAY_CONTAIN_REFERENCES: bool = T::MAY_CONTAIN_REFERENCES;
+    const MAY_CONTAIN_REFERENCES: bool = true;
 
-    fn trace(&self, _tracer: &mut Tracer) {
-        // The only way for Weak<T>::trace to be invoked is by having been
-        // marked already. Thus, marking this weak would just generate extra
-        // traffic.
+    fn trace(&self, tracer: &mut Tracer) {
+        tracer.mark(*self);
     }
 }
 
+/// A tracer for the garbage collector.
+///
+/// This type allows [`Collectable`] values to [`mark()`](Self::mark) any
+/// [`Ref<T>`]s they contain.
 pub struct Tracer<'a> {
     tracing_thread: CollectorThreadId,
     mark_bit: u8,
@@ -648,40 +738,48 @@ impl<'a> Tracer<'a> {
         }
     }
 
-    pub fn mark<T>(&mut self, collected: Weak<T>)
+    /// Marks `collectable` as being referenced, ensuring it is not garbage
+    /// collected.
+    pub fn mark<T>(&mut self, collectable: Ref<T>)
     where
         T: Collectable,
     {
         self.mark_one_sender
             .send(MarkRequest {
-                thread: collected.creating_thread,
+                thread: collectable.creating_thread,
                 type_id: TypeId::of::<T>(),
-                slot_generation: collected.slot_generation,
-                bin_id: collected.bin_id,
+                slot_generation: collectable.slot_generation,
+                bin_id: collectable.bin_id,
                 mark_bits: self.mark_bit,
                 mark_one_sender: self.mark_one_sender.clone(),
             })
-            .expect("marker thread not running");
+            .assert("marker thread not running");
     }
 }
 
 #[test]
 fn size_of_types() {
-    assert_eq!(std::mem::size_of::<Strong<u32>>(), 24);
-    assert_eq!(std::mem::size_of::<Weak<u32>>(), 16);
-}
-
-pub struct Strong<T>
+    assert_eq!(std::mem::size_of::<Root<u32>>(), 24);
+    assert_eq!(std::mem::size_of::<Ref<u32>>(), 16);
+}
+
+/// A root reference to a `T` that has been allocated in the garbage collector.
+///
+/// This type behaves very similarly to [`Arc<T>`]. It is cheap-to-clone,
+/// utilizing atomic reference counting to track the number of root references
+/// currently exist to the underlying value.
+///
+/// While any root references exist for a given allocation, the garbage
+/// collector will not collect the allocation.
+pub struct Root<T>
 where
     T: Collectable,
 {
     data: *const RefCounted<T>,
-    creating_thread: CollectorThreadId,
-    slot_generation: u32,
-    bin_id: BinId,
+    reference: Ref<T>,
 }
 
-impl<T> Strong<T>
+impl<T> Root<T>
 where
     T: Collectable,
 {
@@ -692,45 +790,47 @@ where
         let data = unsafe { guard.bins().allocated_slot_pointer::<T>(bin_id) };
         Self {
             data,
-            creating_thread: guard.thread.thread_id,
-            slot_generation,
-            bin_id,
+            reference: Ref {
+                creating_thread: guard.thread.thread_id,
+                slot_generation,
+                bin_id,
+                _t: PhantomData,
+            },
         }
     }
 
+    /// Stores `value` in the garbage collector, returning a root reference to
+    /// the data.
     pub fn new(value: T, guard: &mut CollectionGuard) -> Self {
         let (gen, bin) = guard.adopt(RefCounted::strong(value));
         Self::from_parts(gen, bin, guard)
     }
 
-    pub const fn downgrade(&self) -> Weak<T> {
-        Weak {
-            creating_thread: self.creating_thread,
-            slot_generation: self.slot_generation,
-            bin_id: self.bin_id,
-            _t: PhantomData,
-        }
+    /// Returns a "weak" reference to this root.
+    #[must_use]
+    pub const fn downgrade(&self) -> Ref<T> {
+        self.reference
     }
 
     fn ref_counted(&self) -> &RefCounted<T> {
         // SAFETY: The garbage collector will not collect data while we have a
         // strong count. The returned lifetime of the data is tied to `self`,
         // which ensures the returned lifetime is valid only for as long as this
-        // `Strong<T>` is alive.
+        // `Root<T>` is alive.
         unsafe { &(*self.data) }
     }
 }
 
-// SAFETY: Strong<T>'s usage of a pointer prevents auto implementation.
-// `Collectable` requires `Send`, and `Strong<T>` ensures proper Send + Sync
+// SAFETY: Root<T>'s usage of a pointer prevents auto implementation.
+// `Collectable` requires `Send`, and `Root<T>` ensures proper Send + Sync
 // behavior in its memory accesses.
-unsafe impl<T> Send for Strong<T> where T: Collectable {}
-// SAFETY: Strong<T>'s usage of a pointer prevents auto implementation.
-// `Collectable` requires `Send`, and `Strong<T>` ensures proper Send + Sync
+unsafe impl<T> Send for Root<T> where T: Collectable {}
+// SAFETY: Root<T>'s usage of a pointer prevents auto implementation.
+// `Collectable` requires `Send`, and `Root<T>` ensures proper Send + Sync
 // behavior in its memory accesses.
-unsafe impl<T> Sync for Strong<T> where T: Collectable {}
+unsafe impl<T> Sync for Root<T> where T: Collectable {}
 
-impl<T> Deref for Strong<T>
+impl<T> Deref for Root<T>
 where
     T: Collectable,
 {
@@ -741,28 +841,38 @@ where
     }
 }
 
-impl<T> Drop for Strong<T>
+impl<T> Drop for Root<T>
 where
     T: Collectable,
 {
     fn drop(&mut self) {
         if self.ref_counted().strong.fetch_sub(1, Ordering::Acquire) == 1 {
-            CollectorCommand::schedule_collect_if_needed()
+            CollectorCommand::schedule_collect_if_needed();
         }
     }
 }
 
-pub struct Weak<T> {
+/// A reference to data stored in a garbage collector.
+///
+/// Unlike a [`Root<T>`], this type is not guaranteed to have access to its
+/// underlying data. If no [`Collectable`] reachable via all active [`Root`]s
+/// marks this allocation, it will be collected.
+///
+/// Because of this, direct access to the data is not provided. To obtain a
+/// reference, call [`Ref::load()`].
+pub struct Ref<T> {
     creating_thread: CollectorThreadId,
     slot_generation: u32,
     bin_id: BinId,
     _t: PhantomData<fn(&T)>,
 }
 
-impl<T> Weak<T>
+impl<T> Ref<T>
 where
     T: Collectable,
 {
+    /// Stores `value` in the garbage collector, returning a "weak" reference to
+    /// it.
     pub fn new(value: T, guard: &mut CollectionGuard) -> Self {
         let (slot_generation, bin_id) = guard.adopt(RefCounted::weak(value));
 
@@ -774,6 +884,9 @@ where
         }
     }
 
+    /// Loads a reference to the underlying data. Returns `None` if the data has
+    /// been collected and is no longer available.
+    #[must_use]
     pub fn load<'guard>(&self, guard: &'guard CollectionGuard) -> Option<&'guard T> {
         let type_id = TypeId::of::<T>();
         // SAFETY: The guard is always present except during allocation which
@@ -781,10 +894,10 @@ where
         let slabs = &unsafe { guard.bins() }
             .by_type
             .get(&type_id)
-            .expect("areas are never deallocated")
+            .assert("areas are never deallocated")
             .as_any()
             .downcast_ref::<Bin<T>>()
-            .expect("type mismatch")
+            .assert("type mismatch")
             .slabs;
         let slab = slabs.get(self.bin_id.slab() as usize)?;
         let slot = &slab.slots[usize::from(self.bin_id.slot())];
@@ -799,22 +912,22 @@ where
     }
 }
 
-impl<T> Clone for Weak<T> {
+impl<T> Clone for Ref<T> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<T> Copy for Weak<T> {}
+impl<T> Copy for Ref<T> {}
 
-// SAFETY: Weak<T>'s usage of a pointer prevents auto implementation.
-// `Collectable` requires `Send`, and `Weak<T>` ensures proper Send + Sync
+// SAFETY: Ref<T>'s usage of a pointer prevents auto implementation.
+// `Collectable` requires `Send`, and `Ref<T>` ensures proper Send + Sync
 // behavior in its memory accesses.
-unsafe impl<T> Send for Weak<T> where T: Collectable {}
-// SAFETY: Weak<T>'s usage of a pointer prevents auto implementation.
-// `Collectable` requires `Send`, and `Weak<T>` ensures proper Send + Sync
+unsafe impl<T> Send for Ref<T> where T: Collectable {}
+// SAFETY: Ref<T>'s usage of a pointer prevents auto implementation.
+// `Collectable` requires `Send`, and `Ref<T>` ensures proper Send + Sync
 // behavior in its memory accesses.
-unsafe impl<T> Sync for Weak<T> where T: Collectable {}
+unsafe impl<T> Sync for Ref<T> where T: Collectable {}
 
 #[derive(Default)]
 struct Bins {
@@ -960,10 +1073,10 @@ where
                 let strong_count =
                     unsafe { (*slot.value.get()).allocated.strong.load(Ordering::Relaxed) };
                 if strong_count > 0 {
-                    tracer.mark::<T>(Weak {
+                    tracer.mark::<T>(Ref {
                         creating_thread: tracer.tracing_thread,
                         slot_generation,
-                        bin_id: BinId::new(slab_index as u32, index as u8),
+                        bin_id: BinId::new(slab_index.cast::<u32>(), index.cast::<u8>()),
                         _t: PhantomData,
                     });
                 }
@@ -999,11 +1112,11 @@ where
             {
                 match slot.sweep(mark_bits, free_head) {
                     SlotSweepStatus::Swept => {
-                        free_head = BinId::new(slab_index as u32, slot_index as u8);
+                        free_head = BinId::new(slab_index.cast::<u32>(), slot_index.cast::<u8>());
                     }
                     SlotSweepStatus::Allocated => {
                         allocated += 1;
-                        last_allocated = slot_index as u8;
+                        last_allocated = slot_index.cast::<u8>();
                     }
                     SlotSweepStatus::NotAllocated => {}
                 }
@@ -1042,6 +1155,7 @@ impl BinId {
         (self.0 >> 8) - 1
     }
 
+    #[allow(clippy::cast_possible_truncation)] // intentional
     const fn slot(self) -> u8 {
         self.0 as u8
     }
@@ -1050,7 +1164,7 @@ impl BinId {
 struct Slabs<T> {
     offset: usize,
     first_free_slab: Cell<usize>,
-    slabs: [UnsafeCell<Option<Box<Slab<T>>>>; 256],
+    slab_slots: [UnsafeCell<Option<Box<Slab<T>>>>; 256],
     next: UnsafeCell<Option<Box<Slabs<T>>>>,
 }
 
@@ -1063,7 +1177,7 @@ where
         Self {
             offset,
             first_free_slab: Cell::new(0),
-            slabs: array::from_fn(|index| {
+            slab_slots: array::from_fn(|index| {
                 UnsafeCell::new(if index == 0 {
                     Some(Slab::new(initial_value.take().expect("only called once")))
                 } else {
@@ -1078,7 +1192,7 @@ where
         if index < 256 {
             // SAFETY: Slabs are always initialized and this function ties the
             // lifetime of the slab to `self`.
-            unsafe { (*self.slabs[index].get()).as_ref() }.map(|slab| &**slab)
+            unsafe { (*self.slab_slots[index].get()).as_ref() }.map(|slab| &**slab)
         } else {
             // SAFETY: Slabs are always initialized and this function ties the
             // lifetime of the slab to `self`.
@@ -1092,7 +1206,7 @@ where
         for index in first_free..256 {
             // SAFETY: Slabs are always initialized and this
             // function ties the lifetime of the slab to `this`.
-            let slab = unsafe { &mut (*self.slabs[index].get()) };
+            let slab = unsafe { &mut (*self.slab_slots[index].get()) };
 
             if let Some(slab) = slab {
                 match slab.try_adopt(value, index + self.offset) {
@@ -1106,7 +1220,7 @@ where
                 }
             } else {
                 *slab = Some(Slab::new(value));
-                return (0, BinId::new(index as u32, 0), None);
+                return (0, BinId::new(index.cast::<u32>(), 0), None);
             }
         }
 
@@ -1116,19 +1230,23 @@ where
             next.adopt(value)
         } else {
             let slabs = Box::new(Slabs::new(value, self.offset + 256));
-            let new_tail = ptr::from_ref(&*slabs);
+            let new_tail: *const Slabs<T> = &*slabs;
 
             // SAFETY: next is never accessed by any other thread except the
             // thread that owns this set of bins.
             unsafe { self.next.get().write(Some(slabs)) };
 
-            (0, BinId::new(self.offset as u32 + 256, 0), Some(new_tail))
+            (
+                0,
+                BinId::new(self.offset.cast::<u32>() + 256, 0),
+                Some(new_tail),
+            )
         }
     }
 
     fn iter(&self) -> SlabsIter<'_, T> {
         SlabsIter {
-            slabs: self.slabs.iter(),
+            slabs: self.slab_slots.iter(),
             this: self,
         }
     }
@@ -1210,7 +1328,7 @@ impl<T> Slab<T> {
             let slot = &self.slots[usize::from(slot_index)];
             let generation = slot.allocate(value);
 
-            Ok((generation, BinId::new(slab_index as u32, slot_index)))
+            Ok((generation, BinId::new(slab_index.cast::<u32>(), slot_index)))
         } else {
             Err(value)
         }
@@ -1301,12 +1419,12 @@ impl SlotState {
 
     fn generation(&self) -> Option<u32> {
         let state = self.0.load(Ordering::Relaxed);
-        (state & Self::ALLOCATED != 0).then_some(state as u32)
+        (state & Self::ALLOCATED != 0).then(|| state.cast::<u32>())
     }
 
     fn allocated_with_generation(&self, generation: u32) -> bool {
         let state = self.0.load(Ordering::Relaxed);
-        state & Self::ALLOCATED != 0 && state as u32 == generation
+        state & Self::ALLOCATED != 0 && state.cast::<u32>() == generation
     }
 
     fn try_allocate(&self) -> Option<u32> {
@@ -1315,9 +1433,9 @@ impl SlotState {
             .0
             .fetch_update(Ordering::Release, Ordering::Acquire, |state| {
                 (state & Self::ALLOCATED == 0).then(|| {
-                    let generation = (state as u32).wrapping_add(1);
+                    let generation = state.cast::<u32>().wrapping_add(1);
                     new_generation = Some(generation);
-                    Self::ALLOCATED | generation as u64
+                    Self::ALLOCATED | u64::from(generation)
                 })
             })
             .is_ok()
@@ -1332,16 +1450,16 @@ impl SlotState {
         let state = self.0.load(Ordering::Acquire);
         debug_assert_eq!(state & Self::ALLOCATED, 0);
 
-        let generation = (state as u32).wrapping_add(1);
+        let generation = state.cast::<u32>().wrapping_add(1);
 
         self.0
-            .store(Self::ALLOCATED | generation as u64, Ordering::Release);
+            .store(Self::ALLOCATED | u64::from(generation), Ordering::Release);
         generation
     }
 
     fn mark(&self, mark_bits: u8, slot_generation: u32) -> bool {
         let mut state = self.0.load(Ordering::Acquire);
-        if state & Self::ALLOCATED == 0 || state as u32 != slot_generation {
+        if state & Self::ALLOCATED == 0 || state.cast::<u32>() != slot_generation {
             return false;
         }
 
@@ -1368,8 +1486,8 @@ impl SlotState {
             return SlotSweepStatus::Allocated;
         }
 
-        let generation = state as u32;
-        self.0.store(generation as u64, Ordering::Release);
+        let generation = state.cast::<u32>();
+        self.0.store(u64::from(generation), Ordering::Release);
         SlotSweepStatus::Swept
     }
 }
@@ -1381,6 +1499,11 @@ enum SlotSweepStatus {
     Swept,
 }
 
+/// Invokes the garbage collector.
+///
+/// This function will deadlock if any [`CollectionGuard`]s are held by the
+/// current thread when invoked. If a guard is held, consider calling
+/// [`CollectionGuard::collect()`] instead.
 pub fn collect() {
     let now = Instant::now();
     CollectorCommand::Collect(now).send();
@@ -1391,30 +1514,30 @@ pub fn collect() {
 fn weak_lifecycle() {
     collected(|| {
         let mut guard = CollectionGuard::acquire();
-        let collected = Weak::new(42_u32, &mut guard);
+        let collected = Ref::new(42_u32, &mut guard);
 
-        assert_eq!(collected.load(&guard).cloned(), Some(42));
+        assert_eq!(collected.load(&guard), Some(&42));
         drop(guard);
 
         collect();
 
         let guard = CollectionGuard::acquire();
         assert!(collected.load(&guard).is_none());
-    })
+    });
 }
 
 #[test]
 fn strong_lifecycle() {
     collected(|| {
         let mut guard = CollectionGuard::acquire();
-        let strong = Strong::new(42_u32, &mut guard);
+        let strong = Root::new(42_u32, &mut guard);
         let weak = strong.downgrade();
 
-        assert_eq!(weak.load(&guard).cloned(), Some(42));
+        assert_eq!(weak.load(&guard), Some(&42));
 
         // This collection should not remove anything.
         guard.collect();
-        assert_eq!(weak.load(&guard).cloned(), Some(42));
+        assert_eq!(weak.load(&guard), Some(&42));
 
         // Drop the strong reference
         drop(strong);
@@ -1423,5 +1546,5 @@ fn strong_lifecycle() {
         guard.collect();
 
         assert!(weak.load(&guard).is_none());
-    })
+    });
 }