Macro stry_common::capture

macro_rules! capture {
    (@data, *$from:expr => mut $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, *$from:expr => $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, *$from:expr => mut $to:ident $(: $ty:ty)? ) => { ... };
    (@data, *$from:expr => $to:ident $(: $ty:ty)? ) => { ... };
    (@data, mut *$v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, *$v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, mut *$v:ident $(: $ty:ty)? ) => { ... };
    (@data, *$v:ident $(: $ty:ty)? ) => { ... };
    (@data, ref mut $from:expr => mut $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, ref mut $from:expr => $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, ref $from:expr => mut $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, ref $from:expr => $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, ref mut $from:expr => mut $to:ident $(: $ty:ty)? ) => { ... };
    (@data, ref mut $from:expr => $to:ident $(: $ty:ty)? ) => { ... };
    (@data, ref $from:expr => mut $to:ident $(: $ty:ty)? ) => { ... };
    (@data, ref $from:expr => $to:ident $(: $ty:ty)? ) => { ... };
    (@data, mut ref mut $v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, mut ref $v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, ref mut $v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, ref $v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, mut ref mut $v:ident $(: $ty:ty)? ) => { ... };
    (@data, mut ref $v:ident $(: $ty:ty)? ) => { ... };
    (@data, ref mut $v:ident $(: $ty:ty)? ) => { ... };
    (@data, ref $v:ident $(: $ty:ty)? ) => { ... };
    (@data, $from:expr => mut $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, $from:expr => $to:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, $from:expr => mut $to:ident $(: $ty:ty)? ) => { ... };
    (@data, $from:expr => $to:ident $(: $ty:ty)? ) => { ... };
    (@data, mut $v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, $v:ident $(: $ty:ty)?, $( $tt:tt )* ) => { ... };
    (@data, mut $v:ident $(: $ty:ty)? ) => { ... };
    (@data, $v:ident $(: $ty:ty)? ) => { ... };
    (@data,) => { ... };
    ( $( $var_tt:tt )* ) => { ... };
}

A macro that allows you to clone, reference or copy variables captured by a closure.

Clone (default)

Without any other modifiers the default action taken for arguments is to clone them.

Syntax

capture!(var)                          // let var = var.clone();
capture!(mut var)                      // let mut var = var.clone();
capture!(var1 => var2)                 // let var2 = var1.clone();
capture!(var1 => mut var2)             // let mut var2 = var1.clone();

Copy

Copying is possible my adding a * to the appropriate argument.

Syntax

capture!(*var)                         // let var = *var;
capture!(mut *var)                     // let mut var = *var;
capture!(*var1 => var2)                // let var2 = *var1;
capture!(*var1 => mut var2)            // let mut var2 = *var1;

References

You can reference a argument by adding the ref keyword to it.

Syntax

capture!(ref var)                      // let var = &var;
capture!(mut ref var)                  // let mut var = &var;
capture!(ref mut var)                  // let var = &mut var;
capture!(mut ref mut var)              // let mut var = &mut var;
capture!(ref var1 => var2)             // let var2 = &var1;
capture!(ref var1 => mut var2)         // let mut var2 = &var1;
capture!(ref mut var1 => var2)         // let var2 = &mut var1;
capture!(ref mut var1 => mut var2)     // let mut var2 = &mut var1;

Note

References’ syntax complexity increases along with you use case. The order between ref mut and mut ref matters!

Examples

use std::sync::{Arc, Mutex, atomic::{AtomicBool, Ordering}};

fn test() {
    let arc_atomic = Arc::new(AtomicBool::new(false));
    let arc_mutex = Arc::new(Mutex::new(Ordering::AcqRel));

    run({
        fenn::capture!(arc_atomic, arc_mutex => mutex);

        move || {
            let lock = mutex.lock().unwrap();

            arc_atomic.store(true, *lock);
        }
    });
}

fn run(f: impl FnOnce() -> ()) {
    f();
}