Struct RcSupplier 

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

Single-threaded shared ownership supplier.

Uses Rc<RefCell<dyn FnMut() -> T>> for single-threaded shared ownership. Can be cloned but not sent across threads.

Ownership Model

Like ArcSupplier, methods borrow &self instead of consuming self:

use prism3_function::{RcSupplier, Supplier};

let source = RcSupplier::new(|| 10);
let mapped = source.map(|x| x * 2);
// source is still usable here!

Examples

Shared Counter

use prism3_function::{RcSupplier, Supplier};
use std::rc::Rc;
use std::cell::RefCell;

let counter = Rc::new(RefCell::new(0));
let counter_clone = Rc::clone(&counter);

let supplier = RcSupplier::new(move || {
    let mut c = counter_clone.borrow_mut();
    *c += 1;
    *c
});

let mut s1 = supplier.clone();
let mut s2 = supplier.clone();
assert_eq!(s1.get(), 1);
assert_eq!(s2.get(), 2);

Reusable Transformations

use prism3_function::{RcSupplier, Supplier};

let base = RcSupplier::new(|| 10);
let doubled = base.map(|x| x * 2);
let tripled = base.map(|x| x * 3);

let mut b = base;
let mut d = doubled;
let mut t = tripled;
assert_eq!(b.get(), 10);
assert_eq!(d.get(), 20);
assert_eq!(t.get(), 30);

Author

Haixing Hu

Implementations

impl<T> RcSupplier<T>

where T: 'static,

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

where F: FnMut() -> T + 'static,

Creates a new RcSupplier.

Parameters

• f - The closure to wrap

Returns

A new RcSupplier<T> instance

Examples

use prism3_function::{RcSupplier, Supplier};

let supplier = RcSupplier::new(|| 42);
let mut s = supplier;
assert_eq!(s.get(), 42);

Examples found in repository

examples/supplier_demo.rs (line 213)

fn demo_rc_supplier() {
    println!("--- RcSupplier ---");

    // Basic usage
    let supplier = RcSupplier::new(|| 42);
    let mut s = supplier;
    println!("Basic: {}", s.get());

    // Shared state
    let counter = Rc::new(RefCell::new(0));
    let counter_clone = Rc::clone(&counter);
    let supplier = RcSupplier::new(move || {
        let mut c = counter_clone.borrow_mut();
        *c += 1;
        *c
    });

    let mut s1 = supplier.clone();
    let mut s2 = supplier.clone();

    println!("First clone: {}", s1.get());
    println!("Second clone: {}", s2.get());
    println!("First clone again: {}", s1.get());

    // Reusable transformations
    let source = RcSupplier::new(|| 10);
    let doubled = source.map(|x| x * 2);
    let tripled = source.map(|x| x * 3);
    let squared = source.map(|x| x * x);

    let mut s = source;
    let mut d = doubled;
    let mut t = tripled;
    let mut sq = squared;

    println!("Source: {}", s.get());
    println!("Doubled: {}", d.get());
    println!("Tripled: {}", t.get());
    println!("Squared: {}", sq.get());
    println!();
}

fn demo_type_conversions() {
    println!("--- Type Conversions ---");

    // Closure to Box
    let closure = || 42;
    let mut boxed = Supplier::into_box(closure);
    println!("Closure -> Box: {}", boxed.get());

    // Closure to Rc
    let closure = || 100;
    let mut rc = closure.into_rc();
    println!("Closure -> Rc: {}", rc.get());

    // Closure to Arc
    let closure = || 200;
    let mut arc = closure.into_arc();
    println!("Closure -> Arc: {}", arc.get());

    // Box to Rc
    let boxed = BoxSupplier::new(|| 42);
    let mut rc = boxed.into_rc();
    println!("Box -> Rc: {}", rc.get());

    // Arc to Box
    let arc = ArcSupplier::new(|| 42);
    let mut boxed = arc.into_box();
    println!("Arc -> Box: {}", boxed.get());

    // Rc to Box
    let rc = RcSupplier::new(|| 42);
    let mut boxed = rc.into_box();
    println!("Rc -> Box: {}", boxed.get());

    println!();
}

pub fn constant(value: T) -> Self

where T: Clone + 'static,

Creates a constant supplier.

Parameters

• value - The constant value to return

Returns

A constant supplier

Examples

use prism3_function::{RcSupplier, Supplier};

let constant = RcSupplier::constant(42);
let mut s = constant;
assert_eq!(s.get(), 42);
assert_eq!(s.get(), 42);

pub fn map<U, F>(&self, mapper: F) -> RcSupplier<U>

where F: Mapper<T, U> + 'static, U: 'static,

Maps the output using a transformation function.

Borrows &self, doesn’t consume the original supplier.

Parameters

• mapper - The mapper to apply to the output. Can be:
  • A closure: |x: T| -> U
  • A function pointer: fn(T) -> U
  • A BoxMapper<T, U>, RcMapper<T, U>, ArcMapper<T, U>
  • Any type implementing Mapper<T, U>

Returns

A new mapped RcSupplier<U>

Examples

Using with closure

use prism3_function::{RcSupplier, Supplier};

let source = RcSupplier::new(|| 10);
let mapped = source.map(|x| x * 2);
// source is still usable
let mut s = mapped;
assert_eq!(s.get(), 20);

Using with Mapper object

use prism3_function::{RcSupplier, RcMapper, Supplier, Mapper};

let mapper = RcMapper::new(|x: i32| x * 2);
let source = RcSupplier::new(|| 10);
let mut supplier = source.map(mapper);
assert_eq!(supplier.get(), 20);

Examples found in repository

examples/supplier_demo.rs (line 235)

fn demo_rc_supplier() {
    println!("--- RcSupplier ---");

    // Basic usage
    let supplier = RcSupplier::new(|| 42);
    let mut s = supplier;
    println!("Basic: {}", s.get());

    // Shared state
    let counter = Rc::new(RefCell::new(0));
    let counter_clone = Rc::clone(&counter);
    let supplier = RcSupplier::new(move || {
        let mut c = counter_clone.borrow_mut();
        *c += 1;
        *c
    });

    let mut s1 = supplier.clone();
    let mut s2 = supplier.clone();

    println!("First clone: {}", s1.get());
    println!("Second clone: {}", s2.get());
    println!("First clone again: {}", s1.get());

    // Reusable transformations
    let source = RcSupplier::new(|| 10);
    let doubled = source.map(|x| x * 2);
    let tripled = source.map(|x| x * 3);
    let squared = source.map(|x| x * x);

    let mut s = source;
    let mut d = doubled;
    let mut t = tripled;
    let mut sq = squared;

    println!("Source: {}", s.get());
    println!("Doubled: {}", d.get());
    println!("Tripled: {}", t.get());
    println!("Squared: {}", sq.get());
    println!();
}

pub fn filter<P>(&self, predicate: P) -> RcSupplier<Option<T>>

where P: FnMut(&T) -> bool + 'static,

Filters output based on a predicate.

Parameters

• predicate - The predicate to test the supplied value

Returns

A new filtered RcSupplier<Option<T>>

Examples

use prism3_function::{RcSupplier, Supplier};
use std::rc::Rc;
use std::cell::RefCell;

let counter = Rc::new(RefCell::new(0));
let counter_clone = Rc::clone(&counter);
let source = RcSupplier::new(move || {
    let mut c = counter_clone.borrow_mut();
    *c += 1;
    *c
});
let filtered = source.filter(|x| x % 2 == 0);

let mut s = filtered;
assert_eq!(s.get(), None);     // 1 is odd
assert_eq!(s.get(), Some(2));  // 2 is even

pub fn zip<U>(&self, other: &RcSupplier<U>) -> RcSupplier<(T, U)>

where U: 'static,

Combines this supplier with another, producing a tuple.

Parameters

• other - The other supplier to combine with. Note: This parameter is passed by reference, so the original supplier remains usable. Can be:
  • An RcSupplier<U> (passed by reference)
  • Any type implementing Supplier<U>

Returns

A new RcSupplier<(T, U)>

Examples

use prism3_function::{RcSupplier, Supplier};

let first = RcSupplier::new(|| 42);
let second = RcSupplier::new(|| "hello");

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

let mut z = zipped;
assert_eq!(z.get(), (42, "hello"));

// Both first and second still usable
let mut f = first;
let mut s = second;
assert_eq!(f.get(), 42);
assert_eq!(s.get(), "hello");

pub fn memoize(&self) -> RcSupplier<T>

where T: Clone + 'static,

Creates a memoizing supplier.

Returns

A new memoized RcSupplier<T>

Examples

use prism3_function::{RcSupplier, Supplier};
use std::rc::Rc;
use std::cell::RefCell;

let call_count = Rc::new(RefCell::new(0));
let call_count_clone = Rc::clone(&call_count);
let source = RcSupplier::new(move || {
    let mut c = call_count_clone.borrow_mut();
    *c += 1;
    42
});
let memoized = source.memoize();

let mut s = memoized;
assert_eq!(s.get(), 42); // Calls underlying function
assert_eq!(s.get(), 42); // Returns cached value
assert_eq!(*call_count.borrow(), 1);

Trait Implementations

impl<T> Clone for RcSupplier<T>

fn clone(&self) -> Self

Clones the RcSupplier.

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

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

Performs copy-assignment from source.

impl<T> Supplier<T> for RcSupplier<T>

fn get(&mut self) -> T

Generates and returns the next value.

fn into_box(self) -> BoxSupplier<T>

where T: 'static,

Converts to BoxSupplier.

fn into_rc(self) -> RcSupplier<T>

where T: 'static,

Converts to RcSupplier.

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

Converts to a closure FnMut() -> T.

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

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

Creates a BoxSupplier from a cloned supplier.

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

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

Creates an RcSupplier from a cloned supplier.

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

where Self: Clone + Sized,

Creates a closure from a cloned supplier.

fn into_arc(self) -> ArcSupplier<T>

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

Converts to ArcSupplier.

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

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

Creates an ArcSupplier from a cloned supplier.