Struct RcReadonlyConsumer 

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

RcReadonlyConsumer struct

Readonly consumer implementation based on Rc<dyn Fn(&T)> for single-threaded shared ownership scenarios. No RefCell needed because operations are readonly.

Features

• Shared Ownership: Cloneable through Rc, allows multiple owners
• Single-threaded: Not thread-safe, cannot be sent across threads
• No Interior Mutability Overhead: No RefCell needed because it’s readonly
• Non-consuming API: and_then borrows &self, original object remains usable

Use Cases

Choose RcReadonlyConsumer when:

• Need to share readonly consumer within a single thread
• Pure observation operations, performance critical
• Event handling in single-threaded UI frameworks

Performance Advantages

RcReadonlyConsumer has neither Arc’s atomic operation overhead nor RefCell’s runtime borrow checking overhead, making it the most performant of the three readonly consumers.

Examples

use prism3_function::{ReadonlyConsumer, RcReadonlyConsumer};

let consumer = RcReadonlyConsumer::new(|x: &i32| {
    println!("Observed: {}", x);
});
let clone = consumer.clone();

consumer.accept(&5);
clone.accept(&10);

Author

Hu Haixing

Implementations

impl<T> RcReadonlyConsumer<T>

where T: 'static,

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

where F: Fn(&T) + 'static,

Create a new RcReadonlyConsumer

Type Parameters

• F - Closure type

Parameters

• f - Closure to wrap

Returns

Returns a new RcReadonlyConsumer<T> instance

Examples

use prism3_function::{ReadonlyConsumer, RcReadonlyConsumer};

let consumer = RcReadonlyConsumer::new(|x: &i32| {
    println!("Value: {}", x);
});
consumer.accept(&5);

pub fn noop() -> Self

Create a no-op consumer

Returns

Returns a no-op consumer

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

Get the consumer’s name

pub fn set_name(&mut self, name: impl Into<String>)

Set the consumer’s name

pub fn and_then(&self, next: &RcReadonlyConsumer<T>) -> RcReadonlyConsumer<T>

Sequentially chain another RcReadonlyConsumer

Returns a new consumer that executes the current operation first, then the next operation. Borrows &self, does not consume the original consumer.

Parameters

• next - Consumer to execute after the current operation. Note: This parameter is passed by reference, so the original consumer remains usable. Can be:
  • An RcReadonlyConsumer<T> (passed by reference)
  • Any type implementing ReadonlyConsumer<T>

Returns

Returns a new combined RcReadonlyConsumer<T>

Examples

use prism3_function::{ReadonlyConsumer, RcReadonlyConsumer};

let first = RcReadonlyConsumer::new(|x: &i32| {
    println!("First: {}", x);
});
let second = RcReadonlyConsumer::new(|x: &i32| {
    println!("Second: {}", x);
});

// second is passed by reference, so it remains usable
let chained = first.and_then(&second);

// first and second remain usable after chaining
chained.accept(&5);
first.accept(&3); // Still usable
second.accept(&7); // Still usable

Trait Implementations

impl<T> Clone for RcReadonlyConsumer<T>

fn clone(&self) -> Self

Clone RcReadonlyConsumer

Creates a new RcReadonlyConsumer that shares the underlying function with the original instance.

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

Performs copy-assignment from source.

impl<T> Debug for RcReadonlyConsumer<T>

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

Formats the value using the given formatter.

impl<T> Display for RcReadonlyConsumer<T>

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

Formats the value using the given formatter.

impl<T> ReadonlyConsumer<T> for RcReadonlyConsumer<T>

fn accept(&self, value: &T)

Execute readonly consumption operation

fn into_box(self) -> BoxReadonlyConsumer<T>

where T: 'static,

Convert to BoxReadonlyConsumer

fn into_rc(self) -> RcReadonlyConsumer<T>

where T: 'static,

Convert to RcReadonlyConsumer

fn into_fn(self) -> impl Fn(&T)

where T: 'static,

Convert to closure

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

where T: 'static,

Non-consuming conversion to BoxReadonlyConsumer

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

where T: 'static,

Non-consuming conversion to RcReadonlyConsumer

fn to_fn(&self) -> impl Fn(&T)

where T: 'static,

Non-consuming conversion to a boxed closure

fn into_arc(self) -> ArcReadonlyConsumer<T>

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

Convert to ArcReadonlyConsumer

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

where Self: Clone + Send + Sync + 'static, T: Send + Sync + 'static,

Non-consuming conversion to ArcReadonlyConsumer