---

yaml
---
r: 81059
b: refs/heads/snap-stage3
c: 5500d86
h: refs/heads/master
i:
  81057: a1fc152
  81055: c7312a0
v: v3

Author: dckc

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: d062de8aa48083439237cb338b38c25306bf6c94
+refs/heads/snap-stage3: 5500d86b457e1815941d4adb2d8bbc91f3c8c9b2
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -1469,6 +1469,34 @@ cannot be stored in data structures or returned from
 functions. Despite these limitations, stack closures are used
 pervasively in Rust code.
 
+## Managed closures
+
+When you need to store a closure in a data structure, a stack closure
+will not do, since the compiler will refuse to let you store it. For
+this purpose, Rust provides a type of closure that has an arbitrary
+lifetime, written `@fn` (boxed closure, analogous to the `@` pointer
+type described earlier). This type of closure *is* first-class.
+
+A managed closure does not directly access its environment, but merely
+copies out the values that it closes over into a private data
+structure. This means that it can not assign to these variables, and
+cannot observe updates to them.
+
+This code creates a closure that adds a given string to its argument,
+returns it from a function, and then calls it:
+
+~~~~
+fn mk_appender(suffix: ~str) -> @fn(~str) -> ~str {
+    // The compiler knows that we intend this closure to be of type @fn
+    return |s| s + suffix;
+}
+
+fn main() {
+    let shout = mk_appender(~"!");
+    println(shout(~"hey ho, let's go"));
+}
+~~~~
+
 ## Owned closures
 
 Owned closures, written `~fn` in analogy to the `~` pointer type,

branches/snap-stage3/src/libextra/c_vec.rs

@@ -36,39 +36,37 @@
  * still held if needed.
  */
 
+
+use std::option;
 use std::ptr;
-use std::routine::Runnable;
-use std::util;
 
 /**
  * The type representing a foreign chunk of memory
+ *
  */
 pub struct CVec<T> {
     priv base: *mut T,
     priv len: uint,
-    priv rsrc: @DtorRes,
+    priv rsrc: @DtorRes
 }
 
 struct DtorRes {
-    dtor: Option<~Runnable>,
+  dtor: Option<@fn()>,
 }
 
 #[unsafe_destructor]
 impl Drop for DtorRes {
     fn drop(&mut self) {
-        let dtor = util::replace(&mut self.dtor, None);
-        match dtor {
-            None => (),
-            Some(f) => f.run()
+        match self.dtor {
+            option::None => (),
+            option::Some(f) => f()
         }
     }
 }
 
-impl DtorRes {
-    fn new(dtor: Option<~Runnable>) -> DtorRes {
-        DtorRes {
-            dtor: dtor,
-        }
+fn DtorRes(dtor: Option<@fn()>) -> DtorRes {
+    DtorRes {
+        dtor: dtor
     }
 }
 
@@ -85,10 +83,10 @@ impl DtorRes {
  * * len - The number of elements in the buffer
  */
 pub unsafe fn CVec<T>(base: *mut T, len: uint) -> CVec<T> {
-    return CVec {
+    return CVec{
         base: base,
         len: len,
-        rsrc: @DtorRes::new(None)
+        rsrc: @DtorRes(option::None)
     };
 }
 
@@ -103,12 +101,12 @@ pub unsafe fn CVec<T>(base: *mut T, len: uint) -> CVec<T> {
  * * dtor - A function to run when the value is destructed, useful
  *          for freeing the buffer, etc.
  */
-pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: ~Runnable)
-                                 -> CVec<T> {
+pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: @fn())
+  -> CVec<T> {
     return CVec{
         base: base,
         len: len,
-        rsrc: @DtorRes::new(Some(dtor))
+        rsrc: @DtorRes(option::Some(dtor))
     };
 }
 
@@ -155,20 +153,6 @@ mod tests {
 
     use std::libc::*;
     use std::libc;
-    use std::routine::Runnable;
-
-    struct LibcFree {
-        mem: *c_void,
-    }
-
-    impl Runnable for LibcFree {
-        #[fixed_stack_segment]
-        fn run(~self) {
-            unsafe {
-                libc::free(self.mem)
-            }
-        }
-    }
 
     fn malloc(n: size_t) -> CVec<u8> {
         #[fixed_stack_segment];
@@ -179,11 +163,12 @@ mod tests {
 
             assert!(mem as int != 0);
 
-            return c_vec_with_dtor(mem as *mut u8,
-                                   n as uint,
-                                   ~LibcFree {
-                                    mem: mem,
-                                   } as ~Runnable);
+            return c_vec_with_dtor(mem as *mut u8, n as uint, || f(mem));
+        }
+
+        fn f(mem: *c_void) {
+            #[fixed_stack_segment]; #[inline(never)];
+            unsafe { libc::free(mem) }
         }
     }
 

branches/snap-stage3/src/libextra/rl.rs

@@ -30,7 +30,7 @@ pub mod rustrt {
 
 macro_rules! locked {
     ($expr:expr) => {
-        {
+        unsafe {
             // FIXME #9105: can't use a static mutex in pure Rust yet.
             rustrt::rust_take_linenoise_lock();
             let x = $expr;
@@ -43,46 +43,35 @@ macro_rules! locked {
 /// Add a line to history
 pub fn add_history(line: &str) -> bool {
     do line.with_c_str |buf| {
-        unsafe {
-            (locked!(rustrt::linenoiseHistoryAdd(buf))) == 1 as c_int
-        }
+        (locked!(rustrt::linenoiseHistoryAdd(buf))) == 1 as c_int
     }
 }
 
 /// Set the maximum amount of lines stored
 pub fn set_history_max_len(len: int) -> bool {
-    unsafe {
-        (locked!(rustrt::linenoiseHistorySetMaxLen(len as c_int))) == 1
-            as c_int
-    }
+    (locked!(rustrt::linenoiseHistorySetMaxLen(len as c_int))) == 1 as c_int
 }
 
 /// Save line history to a file
 pub fn save_history(file: &str) -> bool {
     do file.with_c_str |buf| {
         // 0 on success, -1 on failure
-        unsafe {
-            (locked!(rustrt::linenoiseHistorySave(buf))) == 0 as c_int
-        }
+        (locked!(rustrt::linenoiseHistorySave(buf))) == 0 as c_int
     }
 }
 
 /// Load line history from a file
 pub fn load_history(file: &str) -> bool {
     do file.with_c_str |buf| {
         // 0 on success, -1 on failure
-        unsafe {
-            (locked!(rustrt::linenoiseHistoryLoad(buf))) == 0 as c_int
-        }
+        (locked!(rustrt::linenoiseHistoryLoad(buf))) == 0 as c_int
     }
 }
 
 /// Print out a prompt and then wait for input and return it
 pub fn read(prompt: &str) -> Option<~str> {
     do prompt.with_c_str |buf| {
-        let line = unsafe {
-            locked!(rustrt::linenoise(buf))
-        };
+        let line = locked!(rustrt::linenoise(buf));
 
         if line.is_null() { None }
         else {
@@ -99,36 +88,35 @@ pub fn read(prompt: &str) -> Option<~str> {
     }
 }
 
-/// The callback used to perform completions.
-pub trait CompletionCb {
-    /// Performs a completion.
-    fn complete(&self, line: ~str, suggestion: &fn(~str));
-}
+pub type CompletionCb = @fn(~str, @fn(~str));
 
-local_data_key!(complete_key: @CompletionCb)
+local_data_key!(complete_key: CompletionCb)
 
 /// Bind to the main completion callback in the current task.
 ///
 /// The completion callback should not call any `extra::rl` functions
 /// other than the closure that it receives as its second
 /// argument. Calling such a function will deadlock on the mutex used
 /// to ensure that the calls are thread-safe.
-pub unsafe fn complete(cb: @CompletionCb) {
+pub fn complete(cb: CompletionCb) {
     local_data::set(complete_key, cb);
 
-    extern fn callback(line: *c_char, completions: *()) {
+    extern fn callback(c_line: *c_char, completions: *()) {
         do local_data::get(complete_key) |opt_cb| {
             // only fetch completions if a completion handler has been
             // registered in the current task.
             match opt_cb {
-                None => {}
+                None => {},
                 Some(cb) => {
-                    unsafe {
-                        do cb.complete(str::raw::from_c_str(line))
-                                |suggestion| {
-                            do suggestion.with_c_str |buf| {
-                                rustrt::linenoiseAddCompletion(completions,
-                                                               buf);
+                    let line = unsafe { str::raw::from_c_str(c_line) };
+                    do (*cb)(line) |suggestion| {
+                        do suggestion.with_c_str |buf| {
+                            // This isn't locked, because `callback` gets
+                            // called inside `rustrt::linenoise`, which
+                            // *is* already inside the mutex, so
+                            // re-locking would be a deadlock.
+                            unsafe {
+                                rustrt::linenoiseAddCompletion(completions, buf);
                             }
                         }
                     }

branches/snap-stage3/src/libextra/test.rs

@@ -807,6 +807,11 @@ pub fn filter_tests(
     }
 }
 
+struct TestFuture {
+    test: TestDesc,
+    wait: @fn() -> TestResult,
+}
+
 pub fn run_test(force_ignore: bool,
                 test: TestDescAndFn,
                 monitor_ch: SharedChan<MonitorMsg>) {