Struct OptimisticParallelWritePolicy 

pub struct OptimisticParallelWritePolicy;

Optimistic parallel write policy: Write to both simultaneously, succeed if ≥1 succeeds.

This strategy provides:

• Maximum availability (succeeds unless both fail)
• Fast writes (parallel execution)
• Weak consistency (layers may diverge)

Behavior

1. Start both write_l1(key) and write_l2(key) in parallel
2. Wait for both to complete
3. Aggregate results:
   • Both succeed: Return Ok (best case)
   • One succeeds: Return Ok with warning (partial success)
   • Both fail: Return Err

Consistency Guarantee

If this operation returns Ok(()), at least one of L1 or L2 has been updated. This could mean:

• Both updated (strong consistency)
• Only L1 updated (L2 failed)
• Only L2 updated (L1 failed)

Tradeoffs

• Pros: Highest availability, fast writes, tolerates partial failures
• Cons: Layers may diverge, need monitoring for partial failures

Use Cases

• High availability requirements
• Non-critical data where eventual consistency is acceptable
• Systems with background reconciliation
• Degraded mode operation

Implementations

impl OptimisticParallelWritePolicy

pub fn new() -> Self

Create a new optimistic parallel write policy.

Trait Implementations

impl Clone for OptimisticParallelWritePolicy

fn clone(&self) -> OptimisticParallelWritePolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CompositionWritePolicy for OptimisticParallelWritePolicy

fn execute_with<'life0, 'life1, 'async_trait, F1, F2, Fut1, Fut2, O>( &'life0 self, key: CacheKey, write_l1: F1, write_l2: F2, _offload: &'life1 O, ) -> Pin<Box<dyn Future<Output = Result<(), BackendError>> + Send + 'async_trait>>

where F1: FnOnce(CacheKey) -> Fut1 + Send + 'async_trait, F2: FnOnce(CacheKey) -> Fut2 + Send + 'async_trait, Fut1: Future<Output = Result<(), BackendError>> + Send + 'static + 'async_trait, Fut2: Future<Output = Result<(), BackendError>> + Send + 'static + 'async_trait, O: Offload<'static> + 'async_trait, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a write operation with custom write closures for each layer.

impl Debug for OptimisticParallelWritePolicy

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

Formats the value using the given formatter.

impl Default for OptimisticParallelWritePolicy

fn default() -> OptimisticParallelWritePolicy

Returns the “default value” for a type.

impl Copy for OptimisticParallelWritePolicy