helper_fn

A macro to create closure-like helper functions.

Usage

This attribute can be applied to a function item to allow it to inherit variables from the parent scope. The helper function must be declared before its usage and after the variables it inherits. ```rust use helperfn::helperfn;

let mut num = 5;

[helper_fn(num: i32)] // captures num from the surrounding scope

fn get_num() -> i32 { num }

asserteq!(getnum!(), 5); // note that this is a macro invocation, not a function call ```

Variables can be captured by value (using move or copy semantics), by reference, or by mutable reference: ```text

[helperfn(copied: i32, moved: Vec, &byref: Foo, &mut bymutref: Bar)]

```

If there are scoping issues, you can use the use_helper_fn macro: ```rust use helperfn::{helperfn, usehelperfn};

let mut num = 5;

// hoist the definitions usehelperfn! { getnum(num), getnumtimestwo(num) as getnumtimes2, incrementnum(&mut num), };

asserteq!(getnum!(), 5); asserteq!(getnumtimes2!(), 10); incrementnum!(); asserteq!(getnum!(), 6); asserteq!(getnumtimes_2!(), 12);

[helper_fn(num: i32)]

fn get_num() -> i32 { num }

[helper_fn(num: i32)]

fn getnumtimestwo() -> i32 { // reuse the definition from the parent scope // has to be a different name to avoid conflict usehelperfn!(getnum(num) as getnum); getnum!() * 2 }

[helper_fn(&mut num: i32)]

fn increment_num() { *num += 1; } ```

Rationale

Closures are often used as helper functions that require the surrounding scope; here's a simple example: ```rust let mut num = 5;

let get_num = || { // Lots of complex stuff num };

asserteq!(getnum(), 5); This works just fine, but if you mutate `num` in between calls, it won't compile: rust compile_fail let mut num = 5;

let get_num = || { // Lots of complex stuff num };

asserteq!(getnum(), 5); num += 1; // cannot assign to num because it is borrowed asserteq!(getnum(), 6); One workaround is to use a local `fn` item and pass variables in: rust let mut num = 5;

fn get_num(num: i32) -> i32 { // Lots of complex stuff num }

asserteq!(getnum(num), 5); num += 1; // this is ok asserteq!(getnum(num), 6); ``` This can work, but it can become quite verbose with multiple variables.

With helper_fn, you can get the best of both worlds: ```rust use helperfn::helperfn;

let mut num = 5;

[helper_fn(num: i32)]

fn get_num() -> i32 { num }

asserteq!(getnum!(), 5); // you don't need to pass in num num += 1; // this is ok asserteq!(getnum!(), 6); // note that these calls are macro invocations ```