Values that must be used

Where Rust is+

Rust's types are affine: a value is used at most once. Nothing makes you use it at least once. Drop runs at the end of scope, but mem::forget, Box::leak and reference cycles can skip it, and all of them are safe.+

That was decided in 2015, when a reference cycle through Rc let a scoped thread outlive its borrows (JoinGuard). Making leaks safe was the fix; guaranteed destructors went away with it.²³+

Since then, APIs that must run cleanup keep ownership themselves: thread::scope(|s| ...) never hands the scope out. That works for sync code. It does not work for async, where the future is a value the caller can forget.⁴+

Proposal+

Adopt the hierarchy from the Rust 2026 project goal and Niko Matsakis's design, unchanged, in the new edition:¹⁴+

trait Forget: Destruct {}  // can be forgotten: mem::forget, Box::leak
trait Destruct: Move {}    // can be dropped implicitly at end of scope
trait Move: Pointee {}     // can be moved
trait Pointee {}           // any value

Every generic parameter keeps a default Forget bound, so every existing signature means what it means today. Writing a weaker bound opts out of the default, the way RFC 3729 does for Sized: T: Destruct accepts values that may not be forgotten, T: Move accepts values that must be consumed explicitly.⁵+

The borrow checker enforces it: a value going out of scope needs Destruct, a moved value needs Move, and mem::forget asks for Forget. ra-jit has its own borrow checker, so it can implement and test this now, on real code, without waiting for rustc.⁶+

struct Transaction { /* ... */ }
impl !Forget for Transaction {}
impl !Destruct for Transaction {}   // must call commit or rollback

impl Transaction {
    fn commit(self) -> Result<(), Error> { /* ... */ }
    fn rollback(self) { /* ... */ }
}

fn transfer(db: &Db) -> Result<(), Error> / Db {
    let tx = db.begin();
    tx.debit(a, 10)?;   // error: `tx` is dropped on this path
    tx.commit()
}

Names, syntax and the order of the traits follow upstream. Where upstream changes, this RFC changes with it.+

Why ra-jit wants it+

• Scoped async tasks that borrow from the stack: the handle cannot be forgotten, so the join is guaranteed.+

  No comments yet.

  Comments are not set up yet.

• Effects that must be handled. With capabilities, a pending write or an open connection can be a value that has to be finished or explicitly abandoned, not silently dropped.+

  No comments yet.

  Comments are not set up yet.

• GPU, DMA and FFI resources whose cleanup must run, or must run with arguments.+

  No comments yet.

  Comments are not set up yet.

• In-place updates in pure code. A value the compiler knows is unique can be updated in place by a pure function, which makes pure, cacheable code cheaper.⁷+

  No comments yet.

  Comments are not set up yet.

Prior art+

• Rust 2026 goal: Move trait, rust-lang/rust#149607: tracking issue for Move, Niko Matsakis, Move, Destruct, Leak: the design this RFC adopts.+

  No comments yet.

  Comments are not set up yet.

• rust-lang/rfcs#814: add a linear type facility, rust-lang/rfcs#3782: Forget marker trait, rust-lang/rfcs#3867: forgettable auto trait, rust-lang/rfcs#3729: hierarchy of Sized traits: the RFCs around it.+

  No comments yet.

  Comments are not set up yet.

• Yoshua Wuyts, linear types one-pager, Effects initiative: unleakable types, Aria Desires, The pain of real linear types in Rust, without.boats, Changing the rules of Rust: why it is hard and how editions can carry it.+

  No comments yet.

  Comments are not set up yet.

• rust-lang/rust#24292: JoinGuard is unsound because of reference cycles, Niko Matsakis, On reference counting and leaks (2015): how Rust got here.+

  No comments yet.

  Comments are not set up yet.

• Austral (linear types and capabilities together), GHC LinearTypes, Perceus: garbage-free reference counting with reuse.+

  No comments yet.

  Comments are not set up yet.

Open issues+

References

1. Rust 2026 goal: Move trait The project goal to add the trait hierarchy below Sized.
2. Niko Matsakis, On reference counting and leaks (2015) Why mem::forget became safe.
3. rust-lang/rust#24292: JoinGuard is unsound because of reference cycles The 2015 bug that made leaking safe.
4. Niko Matsakis, Move, Destruct, Leak The proposed hierarchy, from types that cannot move to types that may be leaked.
5. rust-lang/rfcs#3729: hierarchy of Sized traits Open. The ?Trait machinery the new bounds would reuse.
6. ra-jit: borrow checking
7. Perceus: garbage-free reference counting with reuse Unique values updated in place by pure code.
8. rust-lang/rust#149607: tracking issue for Move Open.
9. rust-lang/rfcs#814: add a linear type facility Open since 2015.
10. rust-lang/rfcs#3782: Forget marker trait Open.
11. rust-lang/rfcs#3867: forgettable auto trait Closed 2025-10-05.
12. Yoshua Wuyts, linear types one-pager
13. Effects initiative: unleakable types
14. Aria Desires, The pain of real linear types in Rust Why it is hard: unwinding, generics, every std API.
15. without.boats, Changing the rules of Rust Adding a new auto trait across editions.
16. Austral A systems language with linear types and capabilities.
17. GHC LinearTypes
18. ra-jit: the function cache #[ra_jit::cache], and what makes a function ineligible.