Struct RcReadonlySupplier 

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

Single-threaded shared ownership read-only supplier.

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

Ownership Model

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

use prism3_function::{RcReadonlySupplier, ReadonlySupplier};

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

Examples

Shared Factory

use prism3_function::{RcReadonlySupplier, ReadonlySupplier};

let factory = RcReadonlySupplier::new(|| {
    String::from("Hello")
});

let f1 = factory.clone();
let f2 = factory.clone();
assert_eq!(f1.get(), "Hello");
assert_eq!(f2.get(), "Hello");

Reusable Transformations

use prism3_function::{RcReadonlySupplier, ReadonlySupplier};

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

assert_eq!(base.get(), 10);
assert_eq!(doubled.get(), 20);
assert_eq!(tripled.get(), 30);

Author

Haixing Hu

Implementations

impl<T> RcReadonlySupplier<T>

where T: 'static,

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

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

Creates a new RcReadonlySupplier.

Parameters

• f - The closure to wrap

Returns

A new RcReadonlySupplier<T> instance

Examples

use prism3_function::{RcReadonlySupplier, ReadonlySupplier};

let supplier = RcReadonlySupplier::new(|| 42);
assert_eq!(supplier.get(), 42);

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::{RcReadonlySupplier, ReadonlySupplier};

let constant = RcReadonlySupplier::constant(42);
assert_eq!(constant.get(), 42);
assert_eq!(constant.get(), 42);

pub fn map<U, M>(&self, mapper: M) -> RcReadonlySupplier<U>

where M: Transformer<T, U> + 'static, U: 'static,

Maps the output using a transformation function.

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

Parameters

• mapper - The transformer to apply to the output. Can be a closure, function pointer, or any type implementing Transformer<T, U>.

Returns

A new mapped RcReadonlySupplier<U>

Examples

use prism3_function::{RcReadonlySupplier, ReadonlySupplier};

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

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

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

Filters output based on a predicate.

Parameters

• predicate - The predicate to test the supplied value

Returns

A new filtered RcReadonlySupplier<Option<T>>

Examples

use prism3_function::{RcReadonlySupplier, ReadonlySupplier};

let source = RcReadonlySupplier::new(|| 42);
let filtered = source.filter(|x| x % 2 == 0);

assert_eq!(filtered.get(), Some(42));

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

where U: 'static,

Combines this supplier with another, producing a tuple.

Parameters

• other - The other supplier to combine with. Note: Passed by reference, so the original supplier remains usable.

Returns

A new RcReadonlySupplier<(T, U)>

Examples

use prism3_function::{RcReadonlySupplier, ReadonlySupplier};

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

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

assert_eq!(zipped.get(), (42, "hello"));

// Both first and second still usable
assert_eq!(first.get(), 42);
assert_eq!(second.get(), "hello");

Trait Implementations

impl<T> Clone for RcReadonlySupplier<T>

fn clone(&self) -> Self

Clones the RcReadonlySupplier.

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> ReadonlySupplier<T> for RcReadonlySupplier<T>

fn get(&self) -> T

Generates and returns a value.

fn into_box(self) -> BoxReadonlySupplier<T>

where T: 'static,

Converts to BoxReadonlySupplier.

fn into_rc(self) -> RcReadonlySupplier<T>

where T: 'static,

Converts to RcReadonlySupplier.

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

Converts to a closure implementing FnMut() -> T.

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

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

Converts to BoxReadonlySupplier by cloning.

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

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

Converts to RcReadonlySupplier by cloning.

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

where Self: Clone,

Converts to a closure by cloning.

fn into_arc(self) -> ArcReadonlySupplier<T>

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

Converts to ArcReadonlySupplier.

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

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

Converts to ArcReadonlySupplier by cloning.