Rust project goals: Immobile types and guaranteed destructors

Rust proposes significant enhancements to its type system with new Move and Forget traits, aiming to simplify self-referential types and guarantee destructor execution. This initiative seeks to replace the notoriously complex Pin mechanism and enable safer, more ergonomic async patterns like scoped spawning. Hacker News is buzzing with the prospect of more robust asynchronous programming in Rust.

Score

Comments

Highest Rank

14h

on Front Page

First Seen

Aug 3, 7:00 AM

Last Seen

Aug 3, 8:00 PM

Rank Over Time

The Lowdown

The Rust core team has unveiled a proposal for fundamental changes to the language's type system, introducing Move and Forget auto-traits targeted for implementation between 2026-2027. This initiative addresses long-standing challenges in Rust, particularly within asynchronous programming and precise resource management.

Simplifying Immobile Types: Rust currently assumes all types are movable, but self-referential types (common in async futures) require a stable memory address. The existing Pin mechanism, which handles immovability at the place level, is often complex. The proposed !Move trait would make immovability a type property, aiming to simplify such designs and eventually deprecate Pin.
Guaranteed Destructor Execution: The mem::forget function can prevent destructors from running, posing risks for types requiring strict cleanup (e.g., transaction commit/rollback, scoped task handles). The !Forget trait would ensure a type's destructor is always called, preventing accidental resource leaks or unsafe state.
Enabling Safe Scoped Spawning: A key benefit of guaranteed destructors is the ability to implement safe scoped spawning in async Rust. By ensuring a task's handle destructor joins the task, the system can reliably prevent spawned tasks from outliving their parent scope, eliminating common async cancellation headaches.
Architectural Precedent: This work builds on the successful pattern of the Sized hierarchy, which relaxed the universal assumption of compile-time-known sizes. Similarly, Move and Forget aim to relax the assumptions that all types can be moved and forgotten.
Alternative to Pin Ergonomics: The Move trait is positioned as a direct alternative to ongoing efforts to improve Pin ergonomics, arguing for addressing the root cause of Pin's complexity rather than patching its usability.

In essence, these new traits promise to provide Rust developers with more granular control over type behavior, leading to more predictable, safer, and ultimately more ergonomic code, especially in the demanding world of async systems.

The Gossip

Async Awakening: Unpacking Practical Benefits

Many commenters, including those less familiar with async Rust, sought a clear explanation of the practical advantages these new traits would bring. Responses highlighted significant improvements for async ergonomics, such as simplifying recursive async functions and enabling easier borrowing from parent scopes. The most lauded benefit was the ability to implement safe scoped task spawning, which is crucial for reliable async cancellation and resource management, mirroring the safety guarantees of Rust's synchronous scoped threads.

Forget-Me-Not: The Leakage Debate

A thought-provoking question arose regarding the true effectiveness of the `!Forget` trait in guaranteeing destructor execution. One commenter noted that `mem::forget` isn't the only way to leak values (e.g., through reference cycles), prompting a discussion on whether the proposed mechanism comprehensively addresses all forms of value leakage or primarily targets explicit 'forgetting' actions. This underscored the nuanced challenges of ensuring complete resource cleanup in Rust.

Algebraic Adventures & Language Evolution

Some discussion framed the proposal as a further integration of 'algebraic effects' into Rust. This perspective reflects a broader conversation on the language's ongoing evolution, suggesting that these changes represent a continuous effort to enhance its expressive power and safety features. It touches upon the philosophical implications of such deep type system modifications on Rust's overall design and potential future trajectory.