bumpref 0.1.0

Explicit .bump() method for Arc and Rc that signals cheap refcount cloning
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

# bumpref

A lightweight Rust crate that provides a `bump()` method for reference-counted pointers.
This is an explicit alias for `clone()` that makes it clear the operation is cheap (just incrementing a reference count).

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
bumpref = "0.1"
```

Then use it in your code:

```rust
extern crate bumpref;

use bumpref::Bump;
use std::sync::Arc;
use std::rc::Rc;

fn main() {
    // For Arc
    let arc = Arc::new(42);
    let arc_bumped = arc.bump(); // same as Arc::clone(&arc)

    // For Rc
    let rc = Rc::new("hello");
    let rc_bumped = rc.bump();

    // Also works with Weak references
    let weak = Arc::downgrade(&arc);
    let weak_bumped = weak.bump();
}
```

## Supported Types

- `Arc<T>` and `std::sync::Weak<T>`
- `Rc<T>` and `std::rc::Weak<T>`

All implementations work with `T: ?Sized`, so they support trait objects and slices.

## Why?

When code contains many `.clone()` calls on reference-counted types, it's not immediately obvious whether you're doing an expensive deep clone or just bumping a refcount. Using `.bump()` makes the intent explicit and signals to readers that the operation is O(1).

## Inspiration

This came out of a conversation with Richard Feldman on the 'Rust in Production' podcast
about how Zed uses reference-counted pointers extensively in their codebase and how Richard 
was initially concerned that cloning datastructures might be expensive
until learning that all those clones were just bumping reference counts.
The interview is [here](https://corrode.dev/podcast/s05e04-roc/).