---

yaml
---
r: 145398
b: refs/heads/try2
c: 5500d86
h: refs/heads/master
v: v3

Author: dckc

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: df8231e134fbc3c5d121d48d12fa991949295711
+refs/heads/try2: 5500d86b457e1815941d4adb2d8bbc91f3c8c9b2
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial-rustpkg.md

@@ -7,7 +7,7 @@ package up your Rust code and share it with other people. This tutorial will
 get you started on all of the concepts and commands you need to give the gift
 of Rust code to someone else.
 
-# Installing External Packages
+## Installing External Packages
 
 First, let's try to use an external package somehow. I've made a sample package
 called `hello` to demonstrate how to do so.  Here's how `hello` is used:
@@ -68,7 +68,7 @@ Hello, world.
 
 Simple! That's all it takes.
 
-# Workspaces
+## Workspaces
 
 Before we can talk about how to make packages of your own, you have to
 understand the big concept with `rustpkg`: workspaces. A 'workspace' is simply
@@ -88,14 +88,14 @@ There are also default file names you'll want to follow as well:
 * `main.rs`: A file that's going to become an executable.
 * `lib.rs`: A file that's going to become a library.
 
-# Building your own Package
+## Building your own Package
 
 Now that you've got workspaces down, let's build your own copy of `hello`. Go
 to wherever you keep your personal projects, and let's make all of the
 directories we'll need. I'll refer to this personal project directory as
 `~/src` for the rest of this tutorial.
 
-## Creating our workspace
+### Creating our workspace
 
 ~~~ {.notrust}
 $ cd ~/src
@@ -150,15 +150,15 @@ pub fn world() {
 
 Put this into `src/hello/lib.rs`. Let's talk about each of these attributes:
 
-## Crate attributes for packages
+### Crate attributes for packages
 
 `license` is equally simple: the license we want this code to have. I chose MIT
 here, but you should pick whatever license makes the most sense for you.
 
 `desc` is a description of the package and what it does. This should just be a
 sentence or two.
 
-## Building your package
+### Building your package
 
 Building your package is simple:
 
@@ -206,7 +206,7 @@ note: Installed package github.com/YOUR_USERNAME/hello-0.1 to /home/yourusername
 
 That's it!
 
-# More resources
+## More resources
 
 There's a lot more going on with `rustpkg`, this is just to get you started.
 Check out [the rustpkg manual](rustpkg.html) for the full details on how to

branches/try2/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,
@@ -2995,7 +3023,7 @@ There is further documentation on the [wiki], however those tend to be even more
 [tasks]: tutorial-tasks.html
 [macros]: tutorial-macros.html
 [ffi]: tutorial-ffi.html
-[rustpkg]: tutorial-rustpkg.html
+[rustpkg]: rustpkg.html
 
 [wiki]: https://github.com/mozilla/rust/wiki/Docs
 

branches/try2/mk/docs.mk

@@ -160,16 +160,6 @@ doc/tutorial-conditions.html: tutorial-conditions.md doc/version_info.html doc/r
            --include-before-body=doc/version_info.html \
            --output=$@
 
-DOCS += doc/tutorial-rustpkg.html
-doc/tutorial-rustpkg.html: tutorial-rustpkg.md doc/version_info.html doc/rust.css
-	@$(call E, pandoc: $@)
-	$(Q)$(CFG_NODE) $(S)doc/prep.js --highlight $< | \
-          $(CFG_PANDOC) --standalone --toc \
-           --section-divs --number-sections \
-           --from=markdown --to=html --css=rust.css \
-           --include-before-body=doc/version_info.html \
-           --output=$@
-
   ifeq ($(CFG_PDFLATEX),)
     $(info cfg: no pdflatex found, omitting doc/rust.pdf)
   else

branches/try2/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/try2/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/try2/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>) {