---

yaml
---
r: 22441
b: refs/heads/master
c: 120773b
h: refs/heads/master
i:
  22439: bdddf57
v: v3

Author: msullivan

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: bf88ff52178d1703c473c4ee9461348bbf4be7a2
+refs/heads/master: 120773b2a7b6a1ca8ba859528f3e3cd9e574bf3d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/doc/tutorial.md

@@ -2320,11 +2320,11 @@ and one for values. This means that this code is valid:
 ~~~~
 mod buffalo {
     type buffalo = int;
-    fn buffalo<buffalo: copy>(buffalo: buffalo) -> buffalo { buffalo }
+    fn buffalo(buffalo: buffalo) -> buffalo { buffalo }
 }
 fn main() {
     let buffalo: buffalo::buffalo = 1;
-    buffalo::buffalo::<buffalo::buffalo>(buffalo::buffalo(buffalo));
+    buffalo::buffalo(buffalo::buffalo(buffalo));
 }
 ~~~~
 

trunk/mk/target.mk

@@ -8,9 +8,9 @@
 # (resp.  corelib), set this flag to 1.  It will cause stage1 to use
 # the snapshot runtime (resp. corelib) rather than the runtime
 # (resp. corelib) from the working directory.
-USE_SNAPSHOT_RUNTIME=0
-USE_SNAPSHOT_CORELIB=0
-USE_SNAPSHOT_STDLIB=0
+USE_SNAPSHOT_RUNTIME=1
+USE_SNAPSHOT_CORELIB=1
+USE_SNAPSHOT_STDLIB=1
 
 define TARGET_STAGE_N
 

trunk/src/etc/vim/syntax/rust.vim

@@ -66,9 +66,6 @@ syn keyword   rustConstant    STDIN_FILENO STDOUT_FILENO STDERR_FILENO
 syn match     rustModPath     "\w\(\w\)*::[^<]"he=e-3,me=e-3
 syn match     rustModPathSep  "::"
 
-syn match     rustFuncCall    "\w\(\w\)*("he=e-1,me=e-1
-syn match     rustFuncCall    "\w\(\w\)*::<"he=e-3,me=e-3 " foo::<T>();
-
 syn region    rustString      start=+L\="+ skip=+\\\\\|\\"+ end=+"+ contains=rustTodo
 
 syn region    rustAttribute   start="#\[" end="\]" contains=rustString
@@ -122,7 +119,6 @@ hi def link rustAttribute     PreProc
 " Other Suggestions:
 " hi def link rustModPathSep    Conceal
 " hi rustAssert ctermfg=yellow
-" hi rustFuncCall ctermfg=magenta
 
 syn sync minlines=200
 syn sync maxlines=500

trunk/src/libcore/arc.rs

@@ -84,7 +84,7 @@ fn clone<T: const send>(rc: &arc<T>) -> arc<T> {
 }
 
 // An arc over mutable data that is protected by a lock.
-type ex_data<T: send> = {lock: sys::lock_and_signal, mut data: T};
+type ex_data<T: send> = {lock: sys::lock_and_signal, data: T};
 type exclusive<T: send> = arc_destruct<ex_data<T>>;
 
 fn exclusive<T:send >(-data: T) -> exclusive<T> {
@@ -110,12 +110,12 @@ impl methods<T: send> for exclusive<T> {
         arc_destruct(self.data)
     }
 
-    unsafe fn with<U>(f: fn(sys::condition, x: &mut T) -> U) -> U {
+    unsafe fn with<U>(f: fn(sys::condition, x: &T) -> U) -> U {
         let ptr: ~arc_data<ex_data<T>> =
             unsafe::reinterpret_cast(self.data);
         let r = {
             let rec: &ex_data<T> = &(*ptr).data;
-            rec.lock.lock_cond(|c| f(c, &mut rec.data))
+            rec.lock.lock_cond(|c| f(c, &rec.data))
         };
         unsafe::forget(ptr);
         r

trunk/src/libcore/future.rs

@@ -12,7 +12,6 @@
  */
 
 import either::either;
-import pipes::recv;
 
 export future;
 export extensions;
@@ -61,6 +60,10 @@ fn from_value<A>(+val: A) -> future<A> {
 }
 
 fn macros() {
+    #macro[
+        [#recv[chan],
+         chan.recv()(chan)]
+    ];
     #macro[
         [#move[x],
          unsafe { let y <- *ptr::addr_of(x); y }]
@@ -74,13 +77,14 @@ fn from_port<A:send>(-port: future_pipe::client::waiting<A>) -> future<A> {
     The first time that the value is requested the task will block
     waiting for the result to be received on the port.
     "];
+    import future_pipe::client::recv;
 
     let port = ~mut some(port);
     do from_fn |move port| {
         let mut port_ = none;
         port_ <-> *port;
         let port = option::unwrap(port_);
-        alt recv(port) {
+        alt (#recv(port)) {
           future_pipe::completed(data, _next) { #move(data) }
         }
     }
@@ -133,12 +137,55 @@ fn with<A,B>(future: future<A>, blk: fn(A) -> B) -> B {
     blk(*v)
 }
 
+// The pipe protocol, generated by pipec
+/*
 proto! future_pipe {
     waiting:recv<T:send> {
         completed(T) -> terminated
     }
 
-    terminated:send { }
+    terminated { }
+}
+*/
+mod future_pipe {
+    fn init<T: send>() -> (client::waiting<T>, server::waiting<T>) {
+        { let (s, c) = pipes::entangle(); (c, s) }
+    }
+    enum waiting<T: send> { completed(T, client::terminated), }
+    enum terminated { }
+    mod client {
+        impl recv<T: send> for waiting<T> {
+            fn recv() -> extern fn(+waiting<T>) -> future_pipe::waiting<T> {
+                fn recv<T: send>(+pipe: waiting<T>) ->
+                   future_pipe::waiting<T> {
+                    option::unwrap(pipes::recv(pipe))
+                }
+                recv
+            }
+        }
+        type waiting<T: send> = pipes::recv_packet<future_pipe::waiting<T>>;
+        type terminated = pipes::send_packet<future_pipe::terminated>;
+    }
+    mod server {
+        fn completed<T: send>(+pipe: waiting<T>, +x_0: T) -> terminated {
+            {
+                let (s, c) = pipes::entangle();
+                let message = future_pipe::completed(x_0, s);
+                pipes::send(pipe, message);
+                c
+            }
+        }
+        type waiting<T: send> = pipes::send_packet<future_pipe::waiting<T>>;
+        impl recv for terminated {
+            fn recv() -> extern fn(+terminated) -> future_pipe::terminated {
+                fn recv(+pipe: terminated) -> future_pipe::terminated {
+                    option::unwrap(pipes::recv(pipe))
+                }
+                recv
+            }
+        }
+        type terminated = pipes::recv_packet<future_pipe::terminated>;
+    }
 }
 
 #[test]