Scope-cell: Temporary, Scope-Bound, Reverting Mutations in Rust

Scope-cell provides a mechanism for temporary, scope-bound mutability of immutable data in Rust. It allows for non-permanent changes within a defined scope while ensuring the original data remains unaffected. This is useful in scenarios where you need temporary mutation without ownership or long-term modification of the underlying data.

Key features include:

• Temporary mutation: Enables mutation of data within a scope without requiring ownership.

• Automatic reversion: All changes are discarded when the scope ends, reverting to the original state.

• Low-overhead mutability: Only clone when necessary to ensure efficient memory use.

• Rust safety guarantees: Operates within Rust’s strict borrowing and ownership rules to ensure thread safety and data integrity.

• Compile-time safety: No runtime checks are required; Rust's type system ensures safe use.

Key Features

• Temporary mutation: Modify immutable data within a scope, and ensure the data reverts to its original state once the scope is dropped.
• Automatic reversion: Changes are discarded upon scope exit, making it easy to test or simulate changes without committing them.
• No runtime overhead: Reversion and data integrity are managed with compile-time guarantees.
• Non-ownership, minimal cloning: Only clone when necessary to make modifications, optimizing memory usage.
• Safety with Rust’s borrowing rules: Safely borrow and mutate data within the strict rules of Rust's ownership and borrowing system.

Use Cases

Scope-cell is useful in scenarios where you need to temporarily mutate immutable data without affecting the original state:

• Simulation: Simulate temporary changes to immutable data and automatically roll back.
• Transactional systems: Experiment with temporary changes before committing.
• Testing: Make non-persistent changes during tests that should be automatically undone.
• Concurrency: Share data across threads with safe, temporary mutability.

Example Usage

use Scope_cell::ScopeCell;

fn main() {
    let immutable_data = vec![1, 2, 3];
    {
        let mut scope = ScopeCell::new(&immutable_data);
        scope.get_mut().push(4); // Temporarily mutate the data
        assert_eq!(scope.get().len(), 4); // Verify the change within the scope
    } // Changes revert here
    assert_eq!(immutable_data.len(), 3); // The original data remains unchanged
}

## How it Works

ScopeCell operates by storing a reference to the original data and optionally cloning it into a temporary mutable version. When the ScopeCell is dropped, any changes made are discarded, and the original data remains unaffected.

Key methods:
* **get()** - Borrow the data (either original or modified).
* **get_mut()** - Mutably borrow the data, cloning the original if necessary.
* **revert()** - Explicitly discard any changes, restoring the original data.

## Installation

To use Scope-cell add the following to your Cargo.toml

```toml
[dependencies]
scope-cell = "0.1.2"

## License
This project is licensed under the MIT License.