Struct ArcSupplier 

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

Thread-safe shared ownership read-only supplier.

Uses Arc<dyn Fn() -> T + Send + Sync> for thread-safe shared ownership. Lock-free - no Mutex needed! Can be cloned and sent across threads with excellent concurrent performance.

Ownership Model

Methods borrow &self instead of consuming self. The original supplier remains usable after method calls:

use qubit_function::{ArcSupplier, Supplier};

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

Lock-Free Performance

Unlike ArcSupplier, this implementation doesn’t need Mutex. Multiple threads can call get() concurrently without lock contention, making it ideal for high-concurrency scenarios.

Examples

Thread-safe Factory

use qubit_function::{ArcSupplier, Supplier};
use std::thread;

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

let f1 = factory.clone();
let f2 = factory.clone();

let h1 = thread::spawn(move || f1.get());
let h2 = thread::spawn(move || f2.get());

assert_eq!(h1.join().unwrap(), "Hello");
assert_eq!(h2.join().unwrap(), "Hello");

Reusable Transformations

use qubit_function::{ArcSupplier, Supplier};

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

// All remain usable
assert_eq!(base.get(), 10);
assert_eq!(doubled.get(), 20);
assert_eq!(tripled.get(), 30);

Author

Haixing Hu

Implementations

impl<T> ArcSupplier<T>

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

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

Creates a new supplier.

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

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

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

Creates a new named supplier.

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() -> T + Send + Sync + 'static,

Creates a new named supplier 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 supplier.

Returns

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

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

Sets the name of this supplier.

Parameters

• name - The name to set for this supplier

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

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

Maps the output using a transformation function.

Parameters

• mapper - The transformation function to apply

Returns

A new $struct_name<U> with the mapped output

Examples

use qubit_function::{$struct_name, $supplier_trait};

let source = $struct_name::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) -> ArcSupplier<Option<T>>

where T: 'static, P: Predicate<T> + Send + Sync + 'static,

Filters output based on a predicate.

Parameters

• predicate - The predicate to test the supplied value

Returns

A new filtered $struct_name<Option<$t>>

Examples

use qubit_function::{$struct_name, $supplier_trait};

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

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

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

where T: 'static, S: Supplier<U> + Send + Sync + 'static, U: 'static,

Combines this supplier with another, producing a tuple.

Parameters

• other - The other supplier to combine with

Returns

A new $struct_name<($t, U)>

Examples

use qubit_function::{$struct_name, $supplier_trait};

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

let zipped = first.zip(second);

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

impl<T> ArcSupplier<T>

pub fn constant(value: T) -> Self

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

Creates a supplier that returns a constant value.

Creates a supplier that always returns the same value. Useful for default values or placeholder implementations.

Note: This method requires T: Sync because the constant value is captured by a Fn closure which needs to be Sync for Arc.

Parameters

• value - The constant value to return

Returns

Returns a new supplier instance that returns the constant value.

Examples

use qubit_function::{ArcSupplier, Supplier};

let supplier = ArcSupplier::constant(42);
assert_eq!(supplier.get(), 42);
assert_eq!(supplier.get(), 42); // Can be called multiple times

Trait Implementations

impl<T> Clone for ArcSupplier<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ArcSupplier<T>

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

Formats the value using the given formatter.

impl<T> Display for ArcSupplier<T>

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

Formats the value using the given formatter.

impl<T> Supplier<T> for ArcSupplier<T>

fn get(&self) -> T

Generates and returns a 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_arc(self) -> ArcSupplier<T>

Converts to ArcSupplier.

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

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

fn into_once(self) -> BoxSupplierOnce<T>

where T: 'static,

Converts to BoxSupplierOnce.

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

where T: 'static,

Converts to BoxSupplier by cloning.

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

where T: 'static,

Converts to RcSupplier by cloning.

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

Converts to ArcSupplier by cloning.

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

Converts to a closure by cloning.

fn to_once(&self) -> BoxSupplierOnce<T>

where T: 'static,

Converts to BoxSupplierOnce without consuming self