Struct RcBiMutatingFunction 

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

RcBiMutatingFunction - single-threaded bi-mutating-function wrapper

A single-threaded, clonable bi-mutating-function wrapper optimized for scenarios that require sharing without thread-safety overhead.

Features

• Based on: Rc<dyn Fn(&mut T, &mut U) -> R>
• Ownership: Shared ownership via reference counting (non-atomic)
• Reusability: Can be called multiple times (borrows inputs mutably each time)
• Thread Safety: Not thread-safe (no Send + Sync)
• Clonable: Cheap cloning via Rc::clone

Author

Haixing Hu

Implementations

impl<T, U, R> RcBiMutatingFunction<T, U, R>

where T: 'static, U: 'static, R: 'static,

pub fn new<F>(f: F) -> Self

where F: Fn(&mut T, &mut U) -> R + 'static,

Creates a new bi-function.

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

pub fn new_with_name<F>(name: &str, f: F) -> Self

where F: Fn(&mut T, &mut U) -> R + 'static,

Creates a new named bi-function.

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

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self

where F: Fn(&mut T, &mut U) -> R + 'static,

Creates a new named bi-function with an optional name.

Wraps the provided closure and assigns it an optional name.

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

Gets the name of this bi-function.

Returns

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

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

Sets the name of this bi-function.

Parameters

• name - The name to set for this bi-function

pub fn when<P>(&self, predicate: P) -> RcConditionalBiMutatingFunction<T, U, R>

where P: BiPredicate<T, U> + 'static,

Creates a conditional two-parameter function that executes based on bi-predicate result.

Parameters

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

Returns

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

Examples

use prism3_function::{ArcBiFunction, BiFunction};
use std::sync::Arc;

let add = ArcBiFunction::new(|x: i32, y: i32| x + y);
let conditional = add.when(|x: &i32, y: &i32| *x > 0 && *y > 0);
assert_eq!(conditional.or_else(|_, _| 0).apply(2, 3), 5);  // executed
assert_eq!(conditional.or_else(|_, _| 0).apply(-1, 3), 0); // not executed

pub fn and_then<S, F>(&self, after: F) -> RcBiMutatingFunction<T, U, S>

where S: 'static, F: MutatingFunction<R, S> + 'static,

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

Parameters

• after - The subsequent two-parameter function to execute after the current function completes

Returns

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

Examples

use prism3_function::{ArcBiFunction, BiFunction};
use std::sync::Arc;

let add = ArcBiFunction::new(|x: i32, y: i32| x + y);
let multiply_by_two = ArcBiFunction::new(|x: i32, y: i32| x * y * 2);

let chained = add.and_then(multiply_by_two);
assert_eq!(chained.apply(2, 3), 10); // (2+3) * 2 = 10

impl<T, U, R> RcBiMutatingFunction<T, U, R>

where T: 'static, U: 'static, R: Clone + 'static,

pub fn constant(value: R) -> RcBiMutatingFunction<T, U, R>

Creates a constant function

Examples

/// rust /// use prism3_function::{RcBiMutatingFunction, BiFunction}; /// /// let constant = RcBiMutatingFunction::constant("hello"); /// assert_eq!(constant.apply(123, "test"), "hello"); ///

Trait Implementations

impl<T, U, R> BiMutatingFunction<T, U, R> for RcBiMutatingFunction<T, U, R>

fn apply(&self, first: &mut T, second: &mut U) -> R

Applies the bi-mutating-function to two mutable references and returns a result

fn into_box(self) -> BoxBiMutatingFunction<T, U, R>

where T: 'static, U: 'static, R: 'static,

Converts to BoxBiMutatingFunction

fn into_rc(self) -> RcBiMutatingFunction<T, U, R>

where T: 'static, U: 'static, R: 'static,

Converts to RcBiMutatingFunction

fn into_fn(self) -> impl Fn(&mut T, &mut U) -> R

Converts bi-mutating-function to a closure

fn to_box(&self) -> BoxBiMutatingFunction<T, U, R>

where T: 'static, U: 'static, R: 'static,

Non-consuming conversion to BoxBiMutatingFunction using &self.

fn to_rc(&self) -> RcBiMutatingFunction<T, U, R>

where T: 'static, U: 'static, R: 'static,

Non-consuming conversion to RcBiMutatingFunction using &self.

fn to_fn(&self) -> impl Fn(&mut T, &mut U) -> R

Non-consuming conversion to a boxed function using &self.

fn into_once(self) -> BoxBiMutatingFunctionOnce<T, U, R>

where T: 'static, U: 'static, R: 'static,

Converts to BiMutatingFunctionOnce

fn to_once(&self) -> BoxBiMutatingFunctionOnce<T, U, R>

where T: 'static, U: 'static, R: 'static,

Convert to BiMutatingFunctionOnce without consuming self

fn into_arc(self) -> ArcBiMutatingFunction<T, U, R>

where Self: Sized + Send + Sync + 'static, T: Send + Sync + 'static, U: Send + Sync + 'static, R: Send + Sync + 'static,

Converts to ArcBiMutatingFunction

fn to_arc(&self) -> ArcBiMutatingFunction<T, U, R>

where Self: Sized + Clone + Send + Sync + 'static, T: Send + Sync + 'static, U: Send + Sync + 'static, R: Send + Sync + 'static,

Non-consuming conversion to ArcBiMutatingFunction using &self.

impl<T, U, R> Clone for RcBiMutatingFunction<T, U, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, U, R> Debug for RcBiMutatingFunction<T, U, R>

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

Formats the value using the given formatter.

impl<T, U, R> Display for RcBiMutatingFunction<T, U, R>

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

Formats the value using the given formatter.