Anonymous Functions
Sometimes it gets tedious to define separate functions only to dispatch them via single function pointers. This scenario is especially common when simulating object-oriented programming (OOP).
#![allow(unused)] fn main() { // Define object let obj = #{ data: 42, increment: Fn("inc_obj"), // use function pointers to decrement: Fn("dec_obj"), // refer to method functions print: Fn("print_obj") }; // Define method functions one-by-one fn inc_obj(x) { this.data += x; } fn dec_obj(x) { this.data -= x; } fn print_obj() { print(this.data); } }
The above can be replaced by using anonymous functions which have the same syntax as Rust’s closures (but they are NOT real closures, merely syntactic sugar):
#![allow(unused)] fn main() { let obj = #{ data: 42, increment: |x| this.data += x, // one-liner decrement: |x| this.data -= x, print_obj: || { print(this.data); } // full function body }; }
The anonymous functions will be hoisted into separate functions in the global namespace. The above is equivalent to:
#![allow(unused)] fn main() { let obj = #{ data: 42, increment: Fn("anon_fn_1000"), decrement: Fn("anon_fn_1001"), print: Fn("anon_fn_1002") }; fn anon_fn_1000(x) { this.data += x; } fn anon_fn_1001(x) { this.data -= x; } fn anon_fn_1002() { print this.data; } }
WARNING – NOT Real Closures
Remember: anonymous functions, though having the same syntax as Rust closures, are themselves not real closures.
In particular, they capture their execution environment via automatic currying
(disabled via no_closure
).