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 prism3_function::{ConsumerOnce, BoxConsumerOnce};

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

Author

Hu Haixing

Implementations

impl<T> BoxConsumerOnce<T>

where T: 'static,

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

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

Create a new BoxConsumerOnce

Type Parameters

• F - Closure type

Parameters

• f - Closure to be wrapped

Returns

Returns a new BoxConsumerOnce<T> instance

Examples

use prism3_function::{ConsumerOnce, BoxConsumerOnce};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxConsumerOnce::new(move |x: &i32| {
    l.lock().unwrap().push(*x + 1);
});
consumer.accept_once(&5);
assert_eq!(*log.lock().unwrap(), vec![6]);

Examples found in repository

examples/consumer_once_demo.rs (lines 24-27)

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().unwrap().push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock().unwrap().push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

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

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

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

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

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

    // 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().unwrap().push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x);
        };
        let box_consumer = closure.into_box_once();
        box_consumer.accept_once(&1);
        println!("  BoxConsumerOnce: {:?}", *log.lock().unwrap());
    }

    // 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().unwrap().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_once());
        consumer.accept_once(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().unwrap()
        );
    }

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

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

Get the consumer’s name

Returns the optional name associated with this consumer. Used for debugging and logging purposes.

Returns

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

Examples

use prism3_function::BoxConsumerOnce;

let mut consumer = BoxConsumerOnce::new(|x: &i32| {
    println!("{}", x);
});
assert_eq!(consumer.name(), None);
consumer.set_name("my_consumer");
assert_eq!(consumer.name(), Some("my_consumer"));

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

Set the consumer’s name

Assigns a name to this consumer for debugging and logging purposes. The name can be any type that converts to String.

Parameters

• name - The name to set, can be &str or String

Examples

use prism3_function::BoxConsumerOnce;

let mut consumer = BoxConsumerOnce::new(|x: &i32| {
    println!("{}", x);
});
consumer.set_name("my_consumer");
assert_eq!(consumer.name(), Some("my_consumer"));

pub fn and_then<C>(self, next: C) -> Self

where C: ConsumerOnce<T> + 'static,

Sequentially chain another one-time consumer

Returns a new consumer that executes the current operation first, then the next operation. Consumes self.

Type Parameters

• C - Type of the next consumer

Parameters

• next - Consumer to execute after the current operation. Note: This parameter is passed by value and will transfer ownership. Since BoxConsumerOnce cannot be cloned, the parameter will be consumed. Can be:
  • A closure: |x: &T|
  • A BoxConsumerOnce<T>
  • Any type implementing ConsumerOnce<T>

Returns

Returns a new combined BoxConsumerOnce<T>

Examples

use prism3_function::{ConsumerOnce, BoxConsumerOnce};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let first = BoxConsumerOnce::new(move |x: &i32| {
    l1.lock().unwrap().push(*x * 2);
});
let second = BoxConsumerOnce::new(move |x: &i32| {
    l2.lock().unwrap().push(*x + 10);
});

// Both first and second are moved and consumed
let chained = first.and_then(second);
chained.accept_once(&5);
assert_eq!(*log.lock().unwrap(), vec![10, 15]);
// first.accept_once(&3); // Would not compile - moved
// second.accept_once(&3); // Would not compile - moved

Examples found in repository

examples/consumer_once_demo.rs (lines 43-46)

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().unwrap().push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock().unwrap().push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

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

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

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

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

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

    // 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().unwrap().push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x);
        };
        let box_consumer = closure.into_box_once();
        box_consumer.accept_once(&1);
        println!("  BoxConsumerOnce: {:?}", *log.lock().unwrap());
    }

    // 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().unwrap().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_once());
        consumer.accept_once(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().unwrap()
        );
    }

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

pub fn noop() -> Self

Create a no-op consumer

Returns

Returns a no-op consumer

Examples

use prism3_function::{ConsumerOnce, BoxConsumerOnce};

let noop = BoxConsumerOnce::<i32>::noop();
noop.accept_once(&42);
// Value unchanged

Examples found in repository

examples/consumer_once_demo.rs (line 59)

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().unwrap().push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock().unwrap().push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

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

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

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

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

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

    // 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().unwrap().push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x);
        };
        let box_consumer = closure.into_box_once();
        box_consumer.accept_once(&1);
        println!("  BoxConsumerOnce: {:?}", *log.lock().unwrap());
    }

    // 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().unwrap().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_once());
        consumer.accept_once(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().unwrap()
        );
    }

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

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

where P: Predicate<T> + 'static,

Creates a conditional consumer

Returns a consumer that only executes when a predicate is satisfied.

Parameters

• predicate - The condition to check, can be:
  • Closure: |x: &T| -> bool
  • Function pointer: fn(&T) -> bool
  • BoxPredicate<T>
  • Any type implementing Predicate<T>

Returns

Returns BoxConditionalConsumerOnce<T>

Examples

use prism3_function::{ConsumerOnce, BoxConsumerOnce};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxConsumerOnce::new(move |x: &i32| {
    l.lock().unwrap().push(*x);
});
let conditional = consumer.when(|x: &i32| *x > 0);

conditional.accept_once(&5);
assert_eq!(*log.lock().unwrap(), vec![5]);

Examples found in repository

examples/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().unwrap().push(*x);
            println!("  BoxConsumerOnce consumed: {}", x);
        });
        consumer.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Step 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Step 2: {} + 10 = {}", x, x + 10);
        })
        .and_then(move |x: &i32| {
            l3.lock().unwrap().push(*x - 1);
            println!("  Step 3: {} - 1 = {}", x, x - 1);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

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

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

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

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

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

    // 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().unwrap().push(*x * 2);
            println!("  Closure consumed: {}", x);
        };
        closure.accept_once(&42);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x * 2);
            println!("  Closure 1: {} * 2 = {}", x, x * 2);
        })
        .and_then(move |x: &i32| {
            l2.lock().unwrap().push(*x + 10);
            println!("  Closure 2: {} + 10 = {}", x, x + 10);
        });
        chained.accept_once(&5);
        println!("  Log: {:?}\n", *log.lock().unwrap());
    }

    // 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().unwrap().push(*x);
        };
        let box_consumer = closure.into_box_once();
        box_consumer.accept_once(&1);
        println!("  BoxConsumerOnce: {:?}", *log.lock().unwrap());
    }

    // 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().unwrap().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_once());
        consumer.accept_once(&1);
        println!(
            "  BoxConsumerOnce with single value: {:?}\n",
            *log.lock().unwrap()
        );
    }

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

Trait Implementations

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

fn accept_once(self, value: &T)

Execute one-time consumption operation

fn into_box_once(self) -> BoxConsumerOnce<T>

where T: 'static,

Convert to BoxConsumerOnce

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

where T: 'static,

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.