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.

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 ..)

use partial_application::partial;

// When you're using the 2015 edition of Rust, you need to import the macro like this
#[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, 42, 10, 10);
    assert_eq!(
        foo(15, 15, 10, 42, 10, 10),
        bar(15, 15)
    );
}