Struct boxfnonce::BoxFnOnce
[−]
[src]
pub struct BoxFnOnce<'a, 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 + 'a>
(or
Box<FnBox(Args...) -> Result> + 'a
) the box type is BoxFnOnce<'a, (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 omitted: BoxFnOnce<'a, (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<'a, (), !>
) 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<'a, Args, Result> BoxFnOnce<'a, Args, Result>
[src]
fn call_tuple(self, args: Args) -> Result
[src]
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>,
[src]
Self: From<F>,
BoxFnOnce::new
is an alias for BoxFnOnce::from
.
impl<'a, Result> BoxFnOnce<'a, (), Result>
[src]
impl<'a, A1, Result> BoxFnOnce<'a, (A1,), Result>
[src]
impl<'a, A1, A2, Result> BoxFnOnce<'a, (A1, A2), Result>
[src]
impl<'a, A1, A2, A3, Result> BoxFnOnce<'a, (A1, A2, A3), Result>
[src]
impl<'a, A1, A2, A3, A4, Result> BoxFnOnce<'a, (A1, A2, A3, A4), Result>
[src]
impl<'a, A1, A2, A3, A4, A5, Result> BoxFnOnce<'a, (A1, A2, A3, A4, A5), Result>
[src]
fn call(self, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) -> Result
[src]
call inner function, consumes the box.
impl<'a, A1, A2, A3, A4, A5, A6, Result> BoxFnOnce<'a, (A1, A2, A3, A4, A5, A6), Result>
[src]
fn call(self, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6) -> Result
[src]
call inner function, consumes the box.
impl<'a, A1, A2, A3, A4, A5, A6, A7, Result> BoxFnOnce<'a, (A1, A2, A3, A4, A5, A6, A7), Result>
[src]
fn call(self, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7) -> Result
[src]
call inner function, consumes the box.
impl<'a, A1, A2, A3, A4, A5, A6, A7, A8, Result> BoxFnOnce<'a, (A1, A2, A3, A4, A5, A6, A7, A8), Result>
[src]
fn call(
self,
a1: A1,
a2: A2,
a3: A3,
a4: A4,
a5: A5,
a6: A6,
a7: A7,
a8: A8
) -> Result
[src]
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<'a, A1, A2, A3, A4, A5, A6, A7, A8, A9, Result> BoxFnOnce<'a, (A1, A2, A3, A4, A5, A6, A7, A8, A9), Result>
[src]
fn call(
self,
a1: A1,
a2: A2,
a3: A3,
a4: A4,
a5: A5,
a6: A6,
a7: A7,
a8: A8,
a9: A9
) -> Result
[src]
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<'a, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, Result> BoxFnOnce<'a, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), Result>
[src]
fn call(
self,
a1: A1,
a2: A2,
a3: A3,
a4: A4,
a5: A5,
a6: A6,
a7: A7,
a8: A8,
a9: A9,
a10: A10
) -> Result
[src]
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.