Struct ArcConditionalMutator 

pub struct ArcConditionalMutator<T> { /* private fields */ }

ArcConditionalMutator struct

A thread-safe conditional mutator that only executes when a predicate is satisfied. Uses ArcMutator and ArcPredicate for shared ownership across threads.

This type is typically created by calling ArcMutator::when() and is designed to work with the or_else() method to create if-then-else logic.

Features

• Shared Ownership: Cloneable via Arc, multiple owners allowed
• Thread-Safe: Implements Send + Sync, safe for concurrent use
• Conditional Execution: Only mutates when predicate returns true
• Chainable: Can add or_else branch to create if-then-else logic

Examples

use prism3_function::{Mutator, ArcMutator};

let conditional = ArcMutator::new(|x: &mut i32| *x *= 2)
    .when(|x: &i32| *x > 0);

let conditional_clone = conditional.clone();

let mut value = 5;
let mut m = conditional;
m.mutate(&mut value);
assert_eq!(value, 10);

Author

Haixing Hu

Implementations

impl<T> ArcConditionalMutator<T>

where T: Send + 'static,

pub fn or_else<C>(&self, else_mutator: C) -> ArcMutator<T>

where C: Mutator<T> + Send + 'static, T: Send + Sync,

Adds an else branch (thread-safe version)

Executes the original mutator when the condition is satisfied, otherwise executes else_mutator.

Parameters

• else_mutator - The mutator for the else branch. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original mutator, clone it first (if it implements Clone). Must be Send, can be:
  • A closure: |x: &mut T| (must be Send)
  • An ArcMutator<T>
  • A BoxMutator<T>
  • Any type implementing Mutator<T> + Send

Returns

Returns the composed ArcMutator<T>

Examples

Using a closure (recommended)

use prism3_function::{Mutator, ArcMutator};

let mut mutator = ArcMutator::new(|x: &mut i32| *x *= 2)
    .when(|x: &i32| *x > 0)
    .or_else(|x: &mut i32| *x -= 1);

let mut positive = 5;
mutator.mutate(&mut positive);
assert_eq!(positive, 10);

let mut negative = -5;
mutator.mutate(&mut negative);
assert_eq!(negative, -6);

Trait Implementations

impl<T> Clone for ArcConditionalMutator<T>

fn clone(&self) -> Self

Clones the conditional mutator

Creates a new instance that shares the underlying mutator and predicate with the original instance.

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

Performs copy-assignment from source.

impl<T> Mutator<T> for ArcConditionalMutator<T>

where T: Send + 'static,

fn mutate(&mut self, value: &mut T)

Performs the mutation operation

fn into_box(self) -> BoxMutator<T>

where T: 'static,

Convert this mutator into a BoxMutator<T>.

fn into_rc(self) -> RcMutator<T>

where T: 'static,

Convert this mutator into an RcMutator<T>.

fn into_arc(self) -> ArcMutator<T>

where T: Send + 'static,

Convert this mutator into an ArcMutator<T>.

fn into_fn(self) -> impl FnMut(&mut T)

where T: 'static,

Consume the mutator and return an FnMut(&mut T) closure.

fn to_box(&self) -> BoxMutator<T>

where Self: Sized + 'static, T: 'static,

Create a non-consuming BoxMutator<T> that forwards to self.

fn to_rc(&self) -> RcMutator<T>

where Self: Sized + 'static, T: 'static,

Create a non-consuming RcMutator<T> that forwards to self.

fn to_arc(&self) -> ArcMutator<T>

where Self: Sized + 'static, T: 'static,

Create a non-consuming ArcMutator<T> that forwards to self.

fn to_fn(&self) -> impl FnMut(&mut T)

where Self: Sized + 'static, T: 'static,

Create a boxed FnMut(&mut T) closure that forwards to self.