[][src]Crate partial_application

The partial! macro allows for partial application of a function.

partial!(some_fn => arg0, _, arg2, _) returns the closure |x1, x3| some_fn(arg0, x1, arg2, x3).
Move closures are created by adding move in front of the function: partial!(move ..)

#[macro_use]
extern crate partial_application;

fn foo(a: i32, b: i32, c: i32, d: i32, mul: i32, off: i32) -> i32 {
    (a + b*b + c.pow(3) + d.pow(4)) * mul - off
}

fn main() {
    let bar = partial!(foo => _, _, 10, _, 10, 10);
    assert_eq!(
        foo(15, 15, 10, 42, 10, 10),
        bar(15, 15,     42)
    );
}

The expressions used to fix an argument are reevaluated on every call of the new function because of the straightforward translation behind the macro.

fn identity(x: u32) -> u32 { x }

let mut n = 0;
let mut f = partial!(identity => { n += 1; n});
assert_eq!(f(), 1);
assert_eq!(f(), 2);

Pre-compute arguments to be fixed in a local variable, if their creation is expensive or has unwanted side-effects.

You can also use a comma (,) or semicolon (;) instead of the arrow (=>). This strange syntax choice is due to limitations imposed on us by the macro system. No other tokens may follow the expression token for the function.

Macros

partial

The macro that creates a wrapping closure for a partially applied function