Support for anonymous functions.

doc/src/language/fn-ptr.md

@@ -163,4 +163,59 @@ x == 42;
 Beware that this only works for _method-call_ style.  Normal function-call style cannot bind
 the `this` pointer (for syntactic reasons).
 
-Therefore, obviously, binding the `this` pointer is unsupported under [`no_function`].
+Therefore, obviously, binding the `this` pointer is unsupported under [`no_object`].
+
+
+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]).
+
+```rust
+// 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** closures, merely syntactic sugar):
+
+```rust
+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 expanded into separate functions in the global namespace:
+
+```rust
+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 Closures
+
+Remember: anonymous functions, though having the same syntax as Rust _closures_, are themselves
+**not** closures.  In particular, they do not capture their running environment.  They are more like
+Rust's function pointers.