prism3_function::functions::mutating_function

Struct ArcMutatingFunction

pub struct ArcMutatingFunction<T, R> { /* private fields */ }

Expand description

ArcMutatingFunction struct

A mutating function implementation based on Arc<dyn Fn(&mut T) -> R + Send + Sync> for thread-safe shared ownership scenarios. This type allows the function to be safely shared and used across multiple threads.

§Features

Shared Ownership: Cloneable via Arc, multiple owners allowed
Thread-Safe: Implements Send + Sync, safe for concurrent use
Stateless: Cannot modify captured environment (uses Fn not FnMut)
Chainable: Method chaining via &self (non-consuming)

§Use Cases

Choose ArcMutatingFunction when:

The function needs to be shared across multiple threads for stateless operations
Concurrent task processing (e.g., thread pools)
Thread safety is required (Send + Sync)

§Examples

use prism3_function::{MutatingFunction, ArcMutatingFunction};

let func = ArcMutatingFunction::new(|x: &mut i32| {
    *x *= 2;
    *x
});
let clone = func.clone();

let mut value = 5;
assert_eq!(func.apply(&mut value), 10);

§Author

Haixing Hu

Implementations§

Source §

impl<T, R> ArcMutatingFunction<T, R>
where T: 'static, R: 'static,

Source

pub fn new<F>(f: F) -> Self
where F: Fn(&mut T) -> R + Send + Sync + 'static,

Creates a new function.

Wraps the provided closure in the appropriate smart pointer type for this function implementation.

Source

pub fn new_with_name<F>(name: &str, f: F) -> Self
where F: Fn(&mut T) -> R + Send + Sync + 'static,

Creates a new named function.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

Source

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self
where F: Fn(&mut T) -> R + Send + Sync + 'static,

Creates a new named function with an optional name.

Wraps the provided closure and assigns it an optional name.

Source

pub fn name(&self) -> Option<&str>

Gets the name of this function.

§Returns

Returns Some(&str) if a name was set, None otherwise.

Source

pub fn set_name(&mut self, name: &str)

Sets the name of this function.

§Parameters

name - The name to set for this function

Source

pub fn when(&self, predicate: P) -> ArcConditionalMutatingFunction<T, R>
where P: Predicate<T> + Send + Sync + 'static,

Creates a conditional function that executes based on predicate result.

§Parameters

predicate - The predicate to determine whether to execute the function operation

§Returns

Returns a conditional function that only executes when the predicate returns true.

§Examples

use prism3_function::{ArcFunction, Function};
use std::sync::Arc;

let double = ArcFunction::new(|x: i32| x * 2);
let conditional = double.when(|value: &i32| *value > 0);
assert_eq!(conditional.or_else(|_| 0).apply(5), 10);  // executed
assert_eq!(conditional.or_else(|_| 0).apply(-3), 0);  // not executed

Source

pub fn and_then<S, F>(&self, after: F) -> ArcMutatingFunction<T, S>
where S: 'static, F: Function<R, S> + Send + Sync + 'static,

Chains execution with another function, executing the current function first, then the subsequent function.

§Parameters

after - The subsequent function to execute after the current function completes

§Returns

Returns a new function that executes the current function and the subsequent function in sequence.

§Examples

use prism3_function::{ArcFunction, Function};
use std::sync::Arc;

let double = ArcFunction::new(|x: i32| x * 2);
let to_string = ArcFunction::new(|x: i32| x.to_string());

let chained = double.and_then(to_string);
assert_eq!(chained.apply(5), "10".to_string());

Source §

impl<T> ArcMutatingFunction<T, T>
where T: Clone + 'static,

Source

pub fn identity() -> ArcMutatingFunction<T, T>

Creates an identity function

§Examples

/// rust /// use prism3_function::ArcMutatingFunction; /// /// let mut identity = ArcMutatingFunction::<i32, i32>::identity(); /// let mut value = 42; /// assert_eq!(identity.apply(&mut value), 42); ///