---

yaml
---
r: 115424
b: refs/heads/try
c: b580964
h: refs/heads/master
v: v3

Author: mdinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: bee4e6adac17f87b1cdc26ab69f8c0f5d82575a3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
-refs/heads/try: ad0cdd7081bf78c4b7a00344f6f2b2f113cf0957
+refs/heads/try: b5809644ad6ee87dc28afd8200fa8e12213f4f29
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/tutorial.md

@@ -1719,19 +1719,41 @@ environment). For example, you couldn't write the following:
 ~~~~ {.ignore}
 let foo = 10;
 
-fn bar() -> int {
-   return foo; // `bar` cannot refer to `foo`
-}
+// `bar` cannot refer to `foo`
+fn bar() -> () { println!("{}", foo); }
 ~~~~
 
 Rust also supports _closures_, functions that can access variables in
-the enclosing scope.
+the enclosing scope.  Compare `foo` in these:
+
+~~~~
+fn            bar() -> () { println!("{}", foo) }; // cannot reach enclosing scope
+let closure = |foo| -> () { println!("{}", foo) }; // can reach enclosing scope
+~~~~
+
+Closures can be utilized in this fashion:
 
 ~~~~
-fn call_closure_with_ten(b: |int|) { b(10); }
+// Create a nameless function and assign it to `closure`.
+// It's sole argument is a yet unknown `foo` to be supplied
+// by the caller.
+let closure = |foo| -> () { println!("{}", foo) };
+
+// Define `call_closure_with_ten` to take one argument and return null `()`.
+// `fun` is a function which takes one `int` argument `|int|` and also returns
+// null `()`.  `|int|` defines the `fun` to be of type _closure_
+fn call_closure_with_ten(fun: |int| -> ()) -> () { fun(10); }
 
-let captured_var = 20;
-let closure = |arg| println!("captured_var={}, arg={}", captured_var, arg);
+// The caller supplies `10` to the closure
+// which prints out the value
+call_closure_with_ten(closure);
+~~~~
+
+This can be simplified by removing null arguments:
+
+~~~~
+let closure = |foo| println!("{}", foo);
+fn call_closure_with_ten(fun: |int|) { fun(10); }
 
 call_closure_with_ten(closure);
 ~~~~