Struct Dirty 

pub struct Dirty<const N: usize> { /* private fields */ }

Dirty bitmap type state - bitmap has pending mutations not yet committed.

De-duplication and Cancellation

The dirty state de-duplicates during operations, not at commit time.

Operations that cancel out are handled automatically:

Example 1: push + pop = no-op
  push(true)  → appended_bits=[true], projected_len=11
  pop()       → appended_bits=[], projected_len=10
  Result: dirty state unchanged from base

Example 2: set_bit + set_bit = last write wins
  set_bit(5, true)   → modified_bits={5: true}
  set_bit(5, false)  → modified_bits={5: false}
  Result: only final value recorded

Example 3: set_bit + pop = cancels modification
  set_bit(9, true)  → modified_bits={9: true}
  pop()             → modified_bits={} (removed), projected_len=9
  Result: bit 9 no longer exists, modification discarded

Key Invariants

1. Base immutability: base_len and base_pruned_chunks never change
2. Appended region: Always occupies [projected_len - appended_bits.len(), projected_len)
3. Modified region: modified_bits only contains offsets in [0, projected_len - appended_bits.len())
   • These are modifications to the base bitmap, never to appended bits
   • Appended bits are modified by directly updating the appended_bits vector
4. No overlap: A bit is either in modified_bits OR appended_bits, never both

Trait Implementations

impl<const N: usize> Clone for Dirty<N>

fn clone(&self) -> Dirty<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for Dirty<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> State for Dirty<N>