---

yaml
---
r: 31739
b: refs/heads/dist-snap
c: f110e8f
h: refs/heads/master
i:
  31737: 861736b
  31735: 7bbbef4
v: v3

Author: pcwalton

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: a76e4334b39a2287b039f858c3bd3d5f5d6e2449
+refs/heads/dist-snap: f110e8f21c707cb4bbb5e54b45f4458987920322
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/doc/tutorial.md

@@ -196,7 +196,7 @@ When complete, `make install` will place the following programs into
 `/usr/local/bin`:
 
   * `rustc`, the Rust compiler
-  * `rustdoc`, the API-documentation tool
+  * `rustdoc`, the API-documentation tool 
   * `cargo`, the Rust package manager
 
 [wiki-get-started]: https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust
@@ -2960,11 +2960,7 @@ do spawn {
 ~~~~
 
 This child will perform the expensive computation send the result
-over the channel.  (Under the hood, `chan` was captured by the
-closure that forms the body of the child task.  This capture is
-allowed because channels are sendable.)
-
-Finally, the parent continues by performing
+over the channel.  Finally, the parent continues by performing
 some other expensive computation and then waiting for the child's result
 to arrive on the port:
 
@@ -2982,10 +2978,10 @@ let result = port.recv();
 
 A very common thing to do is to spawn a child task where the parent
 and child both need to exchange messages with each
-other. The function `task::spawn_conversation()` supports this pattern.
-We'll look briefly at how it is used.
+other. The function `task::spawn_listener()` supports this pattern. We'll look
+briefly at how it is used.
 
-To see how `spawn_conversation()` works, we will create a child task
+To see how `spawn_listener()` works, we will create a child task
 that receives `uint` messages, converts them to a string, and sends
 the string in response.  The child terminates when `0` is received.
 Here is the function that implements the child task:
@@ -3010,11 +3006,11 @@ loops, reading from the `from_parent` port and then sending its
 response to the `to_parent` channel.  The actual response itself is
 simply the strified version of the received value,
 `uint::to_str(value)`.
-
+ 
 Here is the code for the parent task:
 
 ~~~~
-# import task::{spawn_conversation};
+# import task::{spawn_listener};
 # import comm::{chan, port, methods};
 # fn stringifier(from_parent: comm::port<uint>,
 #                to_parent: comm::chan<~str>) {
@@ -3024,30 +3020,32 @@ Here is the code for the parent task:
 # }
 # fn main() {
 
-let (from_child, to_child) = do spawn_conversation |from_parent, to_parent| {
+let from_child = port();
+let to_parent = from_child.chan();
+let to_child = do spawn_listener |from_parent| {
     stringifier(from_parent, to_parent);
 };
 
 to_child.send(22u);
 assert from_child.recv() == ~"22";
 
 to_child.send(23u);
-to_child.send(0u);
-
 assert from_child.recv() == ~"23";
+
+to_child.send(0u);
 assert from_child.recv() == ~"0";
 
 # }
 ~~~~
 
-The parent task calls `spawn_conversation` with a function that takes
-a `from_parent` port and a `to_parent` channel.  In return, it gets a
-`from_child` channel and a `to_child` port.  As a result, both parent
-and child can send and receive data to and from the other.
-
-`spawn_conversation`
-will create two port/channel pairs, passing one set to the child task
-and returning the other set to the caller.
+The parent first sets up a port to receive data from and a channel
+that the child can use to send data to that port. The call to
+`spawn_listener()` will spawn the child task, providing it with a port
+on which to receive data from its parent, and returning to the parent
+the associated channel. Finally, the closure passed to
+`spawn_listener()` that forms the body of the child task captures the
+`to_parent` channel in its environment, so both parent and child
+can send and receive data to and from the other.
 
 # Testing
 

branches/dist-snap/src/libcore/priv.rs

@@ -40,8 +40,9 @@ unsafe fn chan_from_global_ptr<T: send>(
         log(debug,~"is probably zero...");
         // There's no global channel. We must make it
 
-        let (setup_po, setup_ch) = do task_fn().spawn_conversation
-            |setup_po, setup_ch| {
+        let setup_po = comm::port();
+        let setup_ch = comm::chan(setup_po);
+        let setup_ch = do task_fn().spawn_listener |setup_po| {
             let po = comm::port::<T>();
             let ch = comm::chan(po);
             comm::send(setup_ch, ch);

branches/dist-snap/src/libcore/task.rs

@@ -52,7 +52,6 @@ export spawn_unlinked;
 export spawn_supervised;
 export spawn_with;
 export spawn_listener;
-export spawn_conversation;
 export spawn_sched;
 export try;
 
@@ -377,20 +376,6 @@ impl task_builder for task_builder {
         comm::recv(setup_po)
     }
 
-    /**
-     * Runs a new task, setting up communication in both directions
-     */
-    fn spawn_conversation<A: send, B: send>
-        (+f: fn~(comm::port<A>, comm::chan<B>))
-        -> (comm::port<B>, comm::chan<A>) {
-        let from_child = comm::port();
-        let to_parent = comm::chan(from_child);
-        let to_child = do self.spawn_listener |from_parent| {
-            f(from_parent, to_parent)
-        };
-        (from_child, to_child)
-    }
-
     /**
      * Execute a function in another task and return either the return value
      * of the function or result::err.
@@ -489,24 +474,31 @@ fn spawn_listener<A:send>(+f: fn~(comm::port<A>)) -> comm::chan<A> {
     /*!
      * Runs a new task while providing a channel from the parent to the child
      *
+     * Sets up a communication channel from the current task to the new
+     * child task, passes the port to child's body, and returns a channel
+     * linked to the port to the parent.
+     *
+     * This encapsulates some boilerplate handshaking logic that would
+     * otherwise be required to establish communication from the parent
+     * to the child.
+     *
+     * The simplest way to establish bidirectional communication between
+     * a parent in child is as follows:
+     *
+     *     let po = comm::port();
+     *     let ch = comm::chan(po);
+     *     let ch = do spawn_listener |po| {
+     *         // Now the child has a port called 'po' to read from and
+     *         // an environment-captured channel called 'ch'.
+     *     };
+     *     // Likewise, the parent has both a 'po' and 'ch'
+     *
      * This function is equivalent to `task().spawn_listener(f)`.
      */
 
     task().spawn_listener(f)
 }
 
-fn spawn_conversation<A: send, B: send>
-    (+f: fn~(comm::port<A>, comm::chan<B>))
-    -> (comm::port<B>, comm::chan<A>) {
-    /*!
-     * Runs a new task, setting up communication in both directions
-     *
-     * This function is equivalent to `task().spawn_conversation(f)`.
-     */
-
-    task().spawn_conversation(f)
-}
-
 fn spawn_sched(mode: sched_mode, +f: fn~()) {
     /*!
      * Creates a new scheduler and executes a task on it
@@ -1724,17 +1716,6 @@ fn test_spawn_listiner_bidi() {
     assert res == ~"pong";
 }
 
-#[test]
-fn test_spawn_conversation() {
-    let (recv_str, send_int) = do spawn_conversation |recv_int, send_str| {
-        let input = comm::recv(recv_int);
-        let output = int::str(input);
-        comm::send(send_str, output);
-    };
-    comm::send(send_int, 1);
-    assert comm::recv(recv_str) == ~"1";
-}
-
 #[test]
 fn test_try_success() {
     match do try {

branches/dist-snap/src/libsyntax/ast.rs

@@ -636,7 +636,8 @@ type variant_arg = {ty: @ty, id: node_id};
 #[auto_serialize]
 enum variant_kind {
     tuple_variant_kind(~[variant_arg]),
-    struct_variant_kind(@struct_def)
+    struct_variant_kind(@struct_def),
+    enum_variant_kind(~[variant])
 }
 
 #[auto_serialize]

branches/dist-snap/src/libsyntax/ext/auto_serialize.rs

@@ -913,7 +913,9 @@ fn deser_enum(cx: ext_ctxt, tps: deser_tps_map, e_name: ast::ident,
                 };
             }
             ast::struct_variant_kind(*) =>
-                fail ~"struct variants unimplemented"
+                fail ~"struct variants unimplemented",
+            ast::enum_variant_kind(*) =>
+                fail ~"enum variants unimplemented"
         }
 
         {pats: ~[@{id: cx.next_id(),

branches/dist-snap/src/libsyntax/fold.rs

@@ -564,6 +564,11 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
                 dtor: dtor
             })
         }
+
+        enum_variant_kind(variants) => {
+            let variants = vec::map(variants, |x| fld.fold_variant(x));
+            kind = enum_variant_kind(variants);
+        }
     }
 
     let fold_attribute = |x| fold_attribute_(x, fld);

branches/dist-snap/src/libsyntax/parse/parser.rs

@@ -17,28 +17,27 @@ import dvec::{dvec, extensions};
 import vec::{push};
 import ast::{_mod, add, alt_check, alt_exhaustive, arg, arm, attribute,
              bind_by_ref, bind_by_implicit_ref, bind_by_value,
-             bitand, bitor, bitxor, blk,
-             blk_check_mode, bound_const, bound_copy, bound_send, bound_trait,
-             bound_owned, box, by_copy, by_move, by_mutbl_ref, by_ref, by_val,
-             capture_clause, capture_item, cdir_dir_mod, cdir_src_mod,
-             cdir_view_item, class_immutable, class_member, class_method,
-             class_mutable, crate, crate_cfg, crate_directive, decl,
-             decl_item, decl_local, default_blk, deref, div, expl, expr,
-             expr_, expr_addr_of, expr_match, expr_again, expr_assert,
-             expr_assign, expr_assign_op, expr_binary, expr_block, expr_break,
-             expr_call, expr_cast, expr_copy, expr_do_body,
-             expr_fail, expr_field, expr_fn, expr_fn_block, expr_if,
-             expr_index, expr_lit, expr_log, expr_loop,
-             expr_loop_body, expr_mac, expr_move, expr_path, expr_rec,
-             expr_repeat, expr_ret, expr_swap, expr_struct, expr_tup,
-             expr_unary, expr_unary_move, expr_vec, expr_vstore, expr_while,
-             extern_fn, field, fn_decl, foreign_item, foreign_item_fn,
-             foreign_mod, ident, impure_fn, infer, inherited, init_assign,
-             init_move, initializer, instance_var, item, item_, item_class,
-             item_const, item_enum, item_fn, item_foreign_mod, item_impl,
-             item_mac, item_mod, item_trait, item_ty, lit, lit_, lit_bool,
-             lit_float, lit_int, lit_int_unsuffixed, lit_nil, lit_str,
-             lit_uint, local, m_const, m_imm, m_mutbl, mac_, mac_aq,
+             bitand, bitor, bitxor, blk, blk_check_mode, bound_const,
+             bound_copy, bound_send, bound_trait, bound_owned, box, by_copy,
+             by_move, by_mutbl_ref, by_ref, by_val, capture_clause,
+             capture_item, cdir_dir_mod, cdir_src_mod, cdir_view_item,
+             class_immutable, class_member, class_method, class_mutable,
+             crate, crate_cfg, crate_directive, decl, decl_item, decl_local,
+             default_blk, deref, div, enum_variant_kind, expl, expr, expr_,
+             expr_addr_of, expr_match, expr_again, expr_assert, expr_assign,
+             expr_assign_op, expr_binary, expr_block, expr_break, expr_call,
+             expr_cast, expr_copy, expr_do_body, expr_fail, expr_field,
+             expr_fn, expr_fn_block, expr_if, expr_index, expr_lit, expr_log,
+             expr_loop, expr_loop_body, expr_mac, expr_move, expr_path,
+             expr_rec, expr_repeat, expr_ret, expr_swap, expr_struct,
+             expr_tup, expr_unary, expr_unary_move, expr_vec, expr_vstore,
+             expr_while, extern_fn, field, fn_decl, foreign_item,
+             foreign_item_fn, foreign_mod, ident, impure_fn, infer, inherited,
+             init_assign, init_move, initializer, instance_var, item, item_,
+             item_class, item_const, item_enum, item_fn, item_foreign_mod,
+             item_impl, item_mac, item_mod, item_trait, item_ty, lit, lit_,
+             lit_bool, lit_float, lit_int, lit_int_unsuffixed, lit_nil,
+             lit_str, lit_uint, local, m_const, m_imm, m_mutbl, mac_, mac_aq,
              mac_ellipsis, mac_invoc, mac_invoc_tt, mac_var, matcher,
              match_nonterminal, match_seq, match_tok, method, mode, mt, mul,
              mutability, neg, noreturn, not, pat, pat_box, pat_enum,
@@ -2842,30 +2841,8 @@ class parser {
         }
     }
 
-    fn parse_item_enum() -> item_info {
-        let id = self.parse_ident();
-        self.parse_region_param();
-        let ty_params = self.parse_ty_params();
+    fn parse_enum_body(ty_params: ~[ast::ty_param]) -> ~[ast::variant] {
         let mut variants: ~[variant] = ~[];
-        // Newtype syntax
-        if self.token == token::EQ {
-            self.check_restricted_keywords_(*id);
-            self.bump();
-            let ty = self.parse_ty(false);
-            self.expect(token::SEMI);
-            let variant =
-                spanned(ty.span.lo, ty.span.hi,
-                        {name: id,
-                         attrs: ~[],
-                         kind: tuple_variant_kind
-                            (~[{ty: ty, id: self.get_id()}]),
-                         id: self.get_id(),
-                         disr_expr: none,
-                         vis: public});
-            return (id, item_enum(~[variant], ty_params), none);
-        }
-        self.expect(token::LBRACE);
-
         let mut all_nullary = true, have_disr = false;
 
         while self.token != token::RBRACE {
@@ -2954,6 +2931,34 @@ class parser {
             self.fatal(~"discriminator values can only be used with a c-like \
                         enum");
         }
+
+        return variants;
+    }
+
+    fn parse_item_enum() -> item_info {
+        let id = self.parse_ident();
+        self.parse_region_param();
+        let ty_params = self.parse_ty_params();
+        // Newtype syntax
+        if self.token == token::EQ {
+            self.check_restricted_keywords_(*id);
+            self.bump();
+            let ty = self.parse_ty(false);
+            self.expect(token::SEMI);
+            let variant =
+                spanned(ty.span.lo, ty.span.hi,
+                        {name: id,
+                         attrs: ~[],
+                         kind: tuple_variant_kind
+                            (~[{ty: ty, id: self.get_id()}]),
+                         id: self.get_id(),
+                         disr_expr: none,
+                         vis: public});
+            return (id, item_enum(~[variant], ty_params), none);
+        }
+        self.expect(token::LBRACE);
+
+        let variants = self.parse_enum_body(ty_params);
         (id, item_enum(variants, ty_params), none)
     }