Struct BoxConsumerOnce 

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

BoxConsumerOnce struct

One-time consumer implementation based on Box<dyn FnOnce(&T)> for single ownership scenarios. This is the simplest consumer type for truly one-time use.

Features

• Single Ownership: Not cloneable, transfers ownership on use
• Zero Overhead: No reference counting or lock overhead
• One-time Use: Consumes self on first call
• Builder Pattern: Method chaining naturally consumes self

Use Cases

Choose BoxConsumerOnce when:

• Consumer is truly used only once
• Building pipelines where ownership flows naturally
• Consumer captures values that should be consumed
• Performance critical and cannot accept shared overhead

Performance

BoxConsumerOnce has the best performance:

• No reference counting overhead
• No lock acquisition or runtime borrow checking
• Direct function call through vtable
• Minimal memory footprint (single pointer)

Examples

use qubit_function::{ConsumerOnce, BoxConsumerOnce};

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

Implementations

impl<T> BoxConsumerOnce<T>

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

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

Creates a new consumer.

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

Examples found in repository

examples/consumers/consumer_once_demo.rs (lines 32-35)

fn main() {
    println!("=== ConsumerOnce Demo ===\n");

    // 1. BoxConsumerOnce - Single ownership, one-time use
    println!("1. BoxConsumerOnce - Single ownership");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 2. BoxConsumerOnce - Method chaining
    println!("2. BoxConsumerOnce - Method chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let l3 = log.clone();
        let chained = BoxConsumerOnce::new(move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock()
                .expect("mutex should not be poisoned")
                .push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 3. BoxConsumerOnce - Factory methods
    println!("3. BoxConsumerOnce - Factory methods");
    {
        // No-op consumer
        let noop = BoxConsumerOnce::<i32>::noop();
        noop.accept(&42);
        println!("  No-op consumer executed (no output)");

        // Print consumer
        print!("  Print consumer: ");
        let print = BoxConsumerOnce::new(|x: &i32| println!("{}", x));
        print.accept(&42);

        // Print with prefix
        print!("  Print with prefix: ");
        let print_with = BoxConsumerOnce::new(|x: &i32| println!("Value: {}", x));
        print_with.accept(&42);

        // Conditional consumer
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&5);
        println!(
            "  Conditional (positive): {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );

        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&-5);
        println!(
            "  Conditional (negative): {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 4. Closure usage
    println!("4. Closure usage");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 5. Closure chaining
    println!("5. Closure chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let chained = (move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 6. Type conversions
    println!("6. Type conversions");
    {
        let log = Arc::new(Mutex::new(Vec::new()));

        // Closure to BoxConsumerOnce
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
        };
        let box_consumer = closure.into_box();
        box_consumer.accept(&1);
        println!(
            "  BoxConsumerOnce: {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 7. Using with iterators (BoxConsumerOnce)
    println!("7. Using with iterators");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        });
        // Note: This will panic because BoxConsumerOnce can only be called once
        // vec![1, 2, 3, 4, 5].iter().for_each(consumer.into_fn());
        consumer.accept(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    println!("=== Demo Complete ===");
}

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

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

Creates a new named consumer.

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: FnOnce(&T) + 'static,

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

Returns

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

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

Sets the name of this consumer.

Parameters

• name - The name to set for this consumer

pub fn clear_name(&mut self)

Clears the name of this consumer.

pub fn noop() -> Self

Creates a no-operation consumer.

Creates a consumer that does nothing when called. Useful for default values or placeholder implementations.

Returns

Returns a new consumer instance that performs no operation.

Examples found in repository

examples/consumers/consumer_once_demo.rs (line 79)

fn main() {
    println!("=== ConsumerOnce Demo ===\n");

    // 1. BoxConsumerOnce - Single ownership, one-time use
    println!("1. BoxConsumerOnce - Single ownership");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 2. BoxConsumerOnce - Method chaining
    println!("2. BoxConsumerOnce - Method chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let l3 = log.clone();
        let chained = BoxConsumerOnce::new(move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock()
                .expect("mutex should not be poisoned")
                .push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 3. BoxConsumerOnce - Factory methods
    println!("3. BoxConsumerOnce - Factory methods");
    {
        // No-op consumer
        let noop = BoxConsumerOnce::<i32>::noop();
        noop.accept(&42);
        println!("  No-op consumer executed (no output)");

        // Print consumer
        print!("  Print consumer: ");
        let print = BoxConsumerOnce::new(|x: &i32| println!("{}", x));
        print.accept(&42);

        // Print with prefix
        print!("  Print with prefix: ");
        let print_with = BoxConsumerOnce::new(|x: &i32| println!("Value: {}", x));
        print_with.accept(&42);

        // Conditional consumer
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&5);
        println!(
            "  Conditional (positive): {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );

        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&-5);
        println!(
            "  Conditional (negative): {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 4. Closure usage
    println!("4. Closure usage");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 5. Closure chaining
    println!("5. Closure chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let chained = (move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 6. Type conversions
    println!("6. Type conversions");
    {
        let log = Arc::new(Mutex::new(Vec::new()));

        // Closure to BoxConsumerOnce
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
        };
        let box_consumer = closure.into_box();
        box_consumer.accept(&1);
        println!(
            "  BoxConsumerOnce: {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 7. Using with iterators (BoxConsumerOnce)
    println!("7. Using with iterators");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        });
        // Note: This will panic because BoxConsumerOnce can only be called once
        // vec![1, 2, 3, 4, 5].iter().for_each(consumer.into_fn());
        consumer.accept(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    println!("=== Demo Complete ===");
}

pub fn when<P>(self, predicate: P) -> BoxConditionalConsumerOnce<T>

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

Creates a conditional consumer that executes based on predicate result.

Parameters

• predicate - The predicate to determine whether to execute the consumption operation

Returns

Returns a conditional consumer that only executes when the predicate returns true.

Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use qubit_function::consumers::*;

let counter = Arc::new(AtomicI32::new(0));
let consumer = BoxConsumer::new({
    let counter = Arc::clone(&counter);
    move |value: &i32| {
        counter.fetch_add(*value, Ordering::SeqCst);
    }
});

let conditional = consumer.when(|value: &i32| *value > 0);
conditional.accept(&1);  // counter = 1
conditional.accept(&-1); // not executed, counter remains 1

Examples found in repository

examples/consumers/consumer_once_demo.rs (line 99)

fn main() {
    println!("=== ConsumerOnce Demo ===\n");

    // 1. BoxConsumerOnce - Single ownership, one-time use
    println!("1. BoxConsumerOnce - Single ownership");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 2. BoxConsumerOnce - Method chaining
    println!("2. BoxConsumerOnce - Method chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let l3 = log.clone();
        let chained = BoxConsumerOnce::new(move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock()
                .expect("mutex should not be poisoned")
                .push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 3. BoxConsumerOnce - Factory methods
    println!("3. BoxConsumerOnce - Factory methods");
    {
        // No-op consumer
        let noop = BoxConsumerOnce::<i32>::noop();
        noop.accept(&42);
        println!("  No-op consumer executed (no output)");

        // Print consumer
        print!("  Print consumer: ");
        let print = BoxConsumerOnce::new(|x: &i32| println!("{}", x));
        print.accept(&42);

        // Print with prefix
        print!("  Print with prefix: ");
        let print_with = BoxConsumerOnce::new(|x: &i32| println!("Value: {}", x));
        print_with.accept(&42);

        // Conditional consumer
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&5);
        println!(
            "  Conditional (positive): {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );

        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&-5);
        println!(
            "  Conditional (negative): {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 4. Closure usage
    println!("4. Closure usage");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 5. Closure chaining
    println!("5. Closure chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let chained = (move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 6. Type conversions
    println!("6. Type conversions");
    {
        let log = Arc::new(Mutex::new(Vec::new()));

        // Closure to BoxConsumerOnce
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
        };
        let box_consumer = closure.into_box();
        box_consumer.accept(&1);
        println!(
            "  BoxConsumerOnce: {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 7. Using with iterators (BoxConsumerOnce)
    println!("7. Using with iterators");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        });
        // Note: This will panic because BoxConsumerOnce can only be called once
        // vec![1, 2, 3, 4, 5].iter().for_each(consumer.into_fn());
        consumer.accept(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    println!("=== Demo Complete ===");
}

pub fn and_then<C>(self, after: C) -> BoxConsumerOnce<T>

where Self: Sized + 'static, T: 'static, C: ConsumerOnce<T> + 'static,

Chains execution with another consumer, executing the current consumer first, then the subsequent consumer.

Parameters

• after - The subsequent consumer to execute after the current consumer completes

Returns

Returns a new consumer that executes the current consumer and the subsequent consumer in sequence.

Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use qubit_function::consumers::*;

let counter1 = Arc::new(AtomicI32::new(0));
let counter2 = Arc::new(AtomicI32::new(0));

let consumer1 = BoxConsumer::new({
    let counter = Arc::clone(&counter1);
    move |value: &i32| {
        counter.fetch_add(*value, Ordering::SeqCst);
    }
});

let consumer2 = BoxConsumer::new({
    let counter = Arc::clone(&counter2);
    move |value: &i32| {
        counter.fetch_add(*value * 2, Ordering::SeqCst);
    }
});

let chained = consumer1.and_then(consumer2);
chained.accept(&5);
// counter1 = 5, counter2 = 10

Examples found in repository

examples/consumers/consumer_once_demo.rs (lines 56-61)

fn main() {
    println!("=== ConsumerOnce Demo ===\n");

    // 1. BoxConsumerOnce - Single ownership, one-time use
    println!("1. BoxConsumerOnce - Single ownership");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 2. BoxConsumerOnce - Method chaining
    println!("2. BoxConsumerOnce - Method chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let l3 = log.clone();
        let chained = BoxConsumerOnce::new(move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock()
                .expect("mutex should not be poisoned")
                .push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 3. BoxConsumerOnce - Factory methods
    println!("3. BoxConsumerOnce - Factory methods");
    {
        // No-op consumer
        let noop = BoxConsumerOnce::<i32>::noop();
        noop.accept(&42);
        println!("  No-op consumer executed (no output)");

        // Print consumer
        print!("  Print consumer: ");
        let print = BoxConsumerOnce::new(|x: &i32| println!("{}", x));
        print.accept(&42);

        // Print with prefix
        print!("  Print with prefix: ");
        let print_with = BoxConsumerOnce::new(|x: &i32| println!("Value: {}", x));
        print_with.accept(&42);

        // Conditional consumer
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&5);
        println!(
            "  Conditional (positive): {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );

        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let conditional = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        })
        .when(|x: &i32| *x > 0);
        conditional.accept(&-5);
        println!(
            "  Conditional (negative): {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 4. Closure usage
    println!("4. Closure usage");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept(&42);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 5. Closure chaining
    println!("5. Closure chaining");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l1 = log.clone();
        let l2 = log.clone();
        let chained = (move |x: &i32| {
            l1.lock()
                .expect("mutex should not be poisoned")
                .push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock()
                .expect("mutex should not be poisoned")
                .push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept(&5);
        println!(
            "  Log: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 6. Type conversions
    println!("6. Type conversions");
    {
        let log = Arc::new(Mutex::new(Vec::new()));

        // Closure to BoxConsumerOnce
        let l = log.clone();
        let closure = move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x);
        };
        let box_consumer = closure.into_box();
        box_consumer.accept(&1);
        println!(
            "  BoxConsumerOnce: {:?}",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    // 7. Using with iterators (BoxConsumerOnce)
    println!("7. Using with iterators");
    {
        let log = Arc::new(Mutex::new(Vec::new()));
        let l = log.clone();
        let consumer = BoxConsumerOnce::new(move |x: &i32| {
            l.lock().expect("mutex should not be poisoned").push(*x * 2);
        });
        // Note: This will panic because BoxConsumerOnce can only be called once
        // vec![1, 2, 3, 4, 5].iter().for_each(consumer.into_fn());
        consumer.accept(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().expect("mutex should not be poisoned")
        );
    }

    println!("=== Demo Complete ===");
}

Trait Implementations

impl<T> ConsumerOnce<T> for BoxConsumerOnce<T>

fn accept(self, value: &T)

Execute one-time consumption operation

fn into_box(self) -> BoxConsumerOnce<T>

Convert to BoxConsumerOnce

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

Convert to closure

impl<T> Debug for BoxConsumerOnce<T>

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

Formats the value using the given formatter.

impl<T> Display for BoxConsumerOnce<T>

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

Formats the value using the given formatter.