#[hackfn]

Fake implementation of std::ops::Fn for user-defined data types.

Place a #[hackfn] attribute on an impl block containing a single method to use that method as the implementation of the function call operator.

toml [dependencies] hackfn = "0.1"

Version requirement: #[hackfn] supports rustc 1.31+

Limitations

• The function must receive &self. Functions that receive &mut self or self are not supported.

• The function may not have generic parameters or where-clause.

• The Self type must implement Sized.

Examples

```rust use hackfn::hackfn;

/// Function object that adds some number to its input. struct Plus(u32);

[hackfn]

impl Plus { fn call(&self, other: u32) -> u32 { self.0 + other } }

fn main() { let plusone = Plus(1); let sum = plusone(2); assert_eq!(sum, 3); } ```

The next example is somewhat more elaborate:

• Interior mutability can be used to approximate a FnMut impl.

• Generic parameters and where-clause are permitted on the impl block (though not on the function).

• The function may take any number of arguments.

```rust use hackfn::hackfn;

use std::cell::Cell; use std::ops::Add;

/// Function object that accumulates a pair of values per call.

[derive(Default)]

struct AccumulatePairs { first: Cell, second: Cell, }

[hackfn]

impl AccumulatePairs where T: Copy + Add

{ fn call(&self, first: T, second: T) { self.first.set(self.first.get() + first); self.second.set(self.second.get() + second); } }

fn main() { let accumulate = AccumulatePairs::default(); accumulate(30, 1); accumulate(20, 2); accumulate(10, 3); asserteq!(accumulate.first.get(), 60); asserteq!(accumulate.second.get(), 6); } ```

License

<sup>Licensed under either of Apache License, Version 2.0 or MIT license at your option.</sup>

<sub>Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.</sub>