---

yaml
---
r: 81075
b: refs/heads/snap-stage3
c: 5e6a8ea
h: refs/heads/master
i:
  81073: d83441b
  81071: 905e9c5
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 10a583ce1ac28a8cbf34b0f4274285f33bdfce29
+refs/heads/snap-stage3: 5e6a8eabc5dcd5ab2f91e62f6c67b1a1e938d444
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/RELEASES.txt

@@ -31,7 +31,6 @@ Version 0.8 (October 2013)
       * `ref` bindings in irrefutable patterns work correctly now.
       * `char` is now prevented from containing invalid code points.
       * Casting to `bool` is no longer allowed.
-      * `\0` is now accepted as an escape in chars and strings.
       * `yield` is a reserved keyword.
       * `typeof` is a reserved keyword.
       * Crates may be imported by URL with `extern mod foo = "url";`.
@@ -112,9 +111,6 @@ Version 0.8 (October 2013)
         the `MutableSet` and `MutableMap` traits. `Container::is_empty`,
         `Map::contains_key`, `MutableMap::insert`, and `MutableMap::remove` have
         default implementations.
-      * std: Various `from_str` functions were removed in favor of a generic
-        `from_str` which is available in the prelude.
-      * std: `util::unreachable` removed in favor of the `unreachable!` macro.
       * extra: `dlist`, the doubly-linked list was modernized.
       * extra: Added a `hex` module with `ToHex` and `FromHex` traits.
       * extra: Added `glob` module, replacing `std::os::glob`.
@@ -129,9 +125,6 @@ Version 0.8 (October 2013)
       * extra: `semver` updated to SemVer 2.0.0.
       * extra: `term` handles more terminals correctly.
       * extra: `dbg` module removed.
-      * extra: `par` module removed.
-      * extra: `future` was cleaned up, with some method renames.
-      * extra: Most free functions in `getopts` were converted to methods.
 
    * Other
       * rustc's debug info generation (`-Z debug-info`) is greatly improved.
@@ -212,7 +205,6 @@ Version 0.7 (July 2013)
       * std: Many old internal vector and string iterators,
         incl. `any`, `all`. removed.
       * std: The `finalize` method of `Drop` renamed to `drop`.
-      * std: The `drop` method now takes `&mut self` instead of `&self`.
       * std: The prelude no longer reexports any modules, only types and traits.
       * std: Prelude additions: `print`, `println`, `FromStr`, `ApproxEq`, `Equiv`,
         `Iterator`, `IteratorUtil`, many numeric traits, many tuple traits.

branches/snap-stage3/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/snap-stage3/doc/tutorial-tasks.md

@@ -423,7 +423,7 @@ do_some_work();
 While it isn't possible for a task to recover from failure, tasks may notify
 each other of failure. The simplest way of handling task failure is with the
 `try` function, which is similar to `spawn`, but immediately blocks waiting
-for the child task to finish. `try` returns a value of type `Result<T,
+for the child task to finish. `try` returns a value of type `Result<int,
 ()>`. `Result` is an `enum` type with two variants: `Ok` and `Err`. In this
 case, because the type arguments to `Result` are `int` and `()`, callers can
 pattern-match on a result to check whether it's an `Ok` result with an `int`

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,
@@ -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/snap-stage3/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/snap-stage3/src/libextra/arc.rs

@@ -162,7 +162,7 @@ struct MutexArcInner<T> { priv lock: Mutex, priv failed: bool, priv data: T }
 
 /// An Arc with mutable data protected by a blocking mutex.
 #[no_freeze]
-pub struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
+struct MutexArc<T> { priv x: UnsafeArc<MutexArcInner<T>> }
 
 
 impl<T:Send> Clone for MutexArc<T> {
@@ -343,7 +343,7 @@ struct RWArcInner<T> { priv lock: RWLock, priv failed: bool, priv data: T }
  * Unlike mutex_arcs, rw_arcs are safe, because they cannot be nested.
  */
 #[no_freeze]
-pub struct RWArc<T> {
+struct RWArc<T> {
     priv x: UnsafeArc<RWArcInner<T>>,
 }
 

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) }
         }
     }