Struct boxfnonce::BoxFnOnce

pub struct BoxFnOnce<Arguments, Result = ()>(_);

BoxFnOnce boxes any FnOnce function up to a certain number of arguments (10 as of now).

As Box<FnOnce()> doesn't work yet, and Box<FnBox()> will not be available in stable rust, BoxFnOnce tries to provide a safe implementation.

Instead of Box<FnOnce(Args...) -> Result> (or Box<FnBox(Args...) -> Result>) the box type is BoxFnOnce<(Args...,), Result> (the arguments are always given as tuple type). If the function doesn't return a value (i.e. the empty tuple) Result can be ommitted: BoxFnOnce<(Args...,)>.

Internally it is implemented similar to Box<FnBox()>, but there is no FnOnce implementation for BoxFnOnce.

You can build boxes for diverging functions too, but specifying the type (like BoxFnOnce<(), !>) is not possible as the ! type is experimental.

If you need to send the FnOnce use SendBoxFnOnce instead.

Examples

Move value into closure and box it:

use boxfnonce::BoxFnOnce;
let s = String::from("foo");
let f : BoxFnOnce<()> = BoxFnOnce::from(|| {
    println!("Got called: {}", s);
    drop(s);
});
f.call();

Move value into closure to return it, and box the closure:

use boxfnonce::BoxFnOnce;
let s = String::from("foo");
let f : BoxFnOnce<(), String> = BoxFnOnce::from(|| {
    println!("Got called: {}", s);
    s
});
assert_eq!(f.call(), "foo".to_string());

Methods

impl<Args, Result> BoxFnOnce<Args, Result>

fn call_tuple(self, args: Args) -> Result

call inner function, consumes the box.

call_tuple can be used if the arguments are available as tuple. Each usable instance of BoxFnOnce<(...), Result> has a separate call method for passing arguments "untupled".

fn new<F>(func: F) -> Self where
    Self: From<F>, 

BoxFnOnce::new is an alias for BoxFnOnce::from.

impl<Result> BoxFnOnce<(), Result>

fn call(self) -> Result

call inner function, consumes the box.

impl<A1, Result> BoxFnOnce<(A1,), Result>

fn call(self, a1: A1) -> Result

call inner function, consumes the box.

impl<A1, A2, Result> BoxFnOnce<(A1, A2), Result>

fn call(self, a1: A1, a2: A2) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, Result> BoxFnOnce<(A1, A2, A3), Result>

fn call(self, a1: A1, a2: A2, a3: A3) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, A4, Result> BoxFnOnce<(A1, A2, A3, A4), Result>

fn call(self, a1: A1, a2: A2, a3: A3, a4: A4) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, A4, A5, Result> BoxFnOnce<(A1, A2, A3, A4, A5), Result>

fn call(self, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, A4, A5, A6, Result> BoxFnOnce<(A1, A2, A3, A4, A5, A6), Result>

fn call(self, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, A4, A5, A6, A7, Result> BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7), Result>

fn call(self, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, A4, A5, A6, A7, A8, Result> BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7, A8), Result>

fn call(
    self,
    a1: A1,
    a2: A2,
    a3: A3,
    a4: A4,
    a5: A5,
    a6: A6,
    a7: A7,
    a8: A8
) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, Result> BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7, A8, A9), Result>

fn call(
    self,
    a1: A1,
    a2: A2,
    a3: A3,
    a4: A4,
    a5: A5,
    a6: A6,
    a7: A7,
    a8: A8,
    a9: A9
) -> Result

call inner function, consumes the box.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Result> BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), Result>

fn call(
    self,
    a1: A1,
    a2: A2,
    a3: A3,
    a4: A4,
    a5: A5,
    a6: A6,
    a7: A7,
    a8: A8,
    a9: A9,
    a10: A10
) -> Result

call inner function, consumes the box.

Trait Implementations

impl<Result, F: 'static + FnOnce() -> Result> From<F> for BoxFnOnce<(), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, Result, F: 'static + FnOnce(A1) -> Result> From<F> for BoxFnOnce<(A1,), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, Result, F: 'static + FnOnce(A1, A2) -> Result> From<F> for BoxFnOnce<(A1, A2), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, Result, F: 'static + FnOnce(A1, A2, A3) -> Result> From<F> for BoxFnOnce<(A1, A2, A3), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, A4, Result, F: 'static + FnOnce(A1, A2, A3, A4) -> Result> From<F> for BoxFnOnce<(A1, A2, A3, A4), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, A4, A5, Result, F: 'static + FnOnce(A1, A2, A3, A4, A5) -> Result> From<F> for BoxFnOnce<(A1, A2, A3, A4, A5), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, A4, A5, A6, Result, F: 'static + FnOnce(A1, A2, A3, A4, A5, A6) -> Result> From<F> for BoxFnOnce<(A1, A2, A3, A4, A5, A6), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, A4, A5, A6, A7, Result, F: 'static + FnOnce(A1, A2, A3, A4, A5, A6, A7) -> Result> From<F> for BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, A4, A5, A6, A7, A8, Result, F: 'static + FnOnce(A1, A2, A3, A4, A5, A6, A7, A8) -> Result> From<F> for BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7, A8), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, Result, F: 'static + FnOnce(A1, A2, A3, A4, A5, A6, A7, A8, A9) -> Result> From<F> for BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7, A8, A9), Result>

fn from(func: F) -> Self

Performs the conversion.

impl<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Result, F: 'static + FnOnce(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> Result> From<F> for BoxFnOnce<(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), Result>

fn from(func: F) -> Self

Performs the conversion.