prism3_function::mutators::stateful_mutator

Struct BoxConditionalStatefulMutator

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

Expand description

BoxConditionalMutator struct

A conditional mutator that only executes when a predicate is satisfied. Uses BoxMutator and BoxPredicate for single ownership semantics.

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

§Features

Single Ownership: Not cloneable, consumes self on use
Conditional Execution: Only mutates when predicate returns true
Chainable: Can add or_else branch to create if-then-else logic
Implements Mutator: Can be used anywhere a Mutator is expected

§Examples

§Basic Conditional Execution

use prism3_function::{Mutator, BoxMutator};

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

let mut positive = 5;
conditional.apply(&mut positive);
assert_eq!(positive, 10); // Executed

let mut negative = -5;
conditional.apply(&mut negative);
assert_eq!(negative, -5); // Not executed

§With or_else Branch

use prism3_function::{Mutator, BoxMutator};

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

let mut positive = 5;
mutator.apply(&mut positive);
assert_eq!(positive, 10); // when branch executed

let mut negative = -5;
mutator.apply(&mut negative);
assert_eq!(negative, -6); // or_else branch executed

§Author

Haixing Hu

Implementations§

Source §

impl<T> BoxConditionalStatefulMutator<T>
where T: 'static,

Source

pub fn and_then<M>(self, next: M) -> BoxStatefulMutator<T>
where M: StatefulMutator<T> + 'static,

Chains another mutator in sequence

Combines the current conditional mutator with another mutator into a new mutator that implements the following semantics:

When the returned mutator is called with an argument:

First, it checks the predicate of this conditional mutator
If the predicate is satisfied, it executes the internal mutator of this conditional mutator
Then, regardless of whether the predicate was satisfied, it unconditionally executes the next mutator

In other words, this creates a mutator that conditionally executes the first action (based on the predicate), and then always executes the second action.

§Parameters

next - The next mutator to execute (always executed)

§Returns

Returns a new combined mutator

§Examples

use std::sync::atomic::{AtomicI32, Ordering};

let result = AtomicI32::new(0);

let mutator1 = BoxMutator::new(|x: &mut i32| {
    *x += 1;
});

let mutator2 = BoxMutator::new(|x: &mut i32| {
    *x += 2;
});

let conditional = mutator1.when(|x| *x > 0);
let chained = conditional.and_then(mutator2);

let mut val = 5;
chained.apply(&mut val);  // val = 5 + 1 + 2 = 8
let mut val2 = -1;
chained.apply(&mut val2); // val2 = -1 + 2 = 1 (not -1 + 1 + 2!)