---

yaml
---
r: 22453
b: refs/heads/master
c: 63df248
h: refs/heads/master
i:
  22451: c1cd28f
v: v3

Author: graydon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b9aa9def858cfc66d411972b10ce3d98479acd78
+refs/heads/master: 63df2484146a3f2e34aa743ac600eb82620cb70a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/RELEASES.txt

@@ -1,7 +1,7 @@
-Version 0.3  (July 2012) - not yet!
------------------------------------
+Version 0.3  (July 2012)
+------------------------
 
-   * ~1500 changes, numerous bugfixes
+   * ~1900 changes, numerous bugfixes
 
    * New coding conveniences
       * Integer-literal suffix inference
@@ -33,7 +33,7 @@ Version 0.3  (July 2012) - not yet!
 
    * Removal of various obsolete features
       * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind',
-        	  'crust', 'native' (now 'extern')
+                 'crust', 'native' (now 'extern'), 'cont' (now 'again')
 
       * Constructs: do-while loops ('do' repurposed), fn binding,
       	            resources (replaced by destructors)

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/src/cargo/cargo.rc

@@ -11,7 +11,7 @@
 // End:
 
 #[link(name = "cargo",
-       vers = "0.2",
+       vers = "0.3",
        uuid = "9ff87a04-8fed-4295-9ff8-f99bb802650b",
        url = "https://github.com/mozilla/rust/tree/master/src/cargo")];
 
@@ -21,10 +21,10 @@
 
 #[warn(no_non_implicitly_copyable_typarams,no_vecs_not_implicitly_copyable)];
 
-use core(vers = "0.2");
-use std(vers = "0.2");
-use rustc(vers = "0.2");
-use syntax(vers = "0.2");
+use core(vers = "0.3");
+use std(vers = "0.3");
+use rustc(vers = "0.3");
+use syntax(vers = "0.3");
 
 import core::*;
 

trunk/src/compiletest/compiletest.rc

@@ -4,8 +4,8 @@
 
 #[warn(no_vecs_not_implicitly_copyable)];
 
-use core(vers = "0.2");
-use std(vers = "0.2");
+use core(vers = "0.3");
+use std(vers = "0.3");
 
 import core::*;
 

trunk/src/etc/pkg/rust.iss

@@ -5,7 +5,7 @@
 SetupIconFile=rust-logo.ico
 AppName=Rust
 AppVersion={#CFG_VERSION}
-AppCopyright=Copyright (C) 2006-2011 Mozilla Foundation, MIT license
+AppCopyright=Copyright (C) 2006-2012 Mozilla Foundation, MIT license
 AppPublisher=Mozilla Foundation
 AppPublisherURL=http://www.rust-lang.org
 VersionInfoVersion={#CFG_VERSION}

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/fuzzer/fuzzer.rc

@@ -6,9 +6,9 @@
 
 #[warn(no_vecs_not_implicitly_copyable)];
 
-use core(vers = "0.2");
-use std(vers = "0.2");
-use syntax(vers = "0.2");
+use core(vers = "0.3");
+use std(vers = "0.3");
+use syntax(vers = "0.3");
 
 import core::*;
 

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/core.rc

@@ -1,5 +1,5 @@
 #[link(name = "core",
-       vers = "0.2",
+       vers = "0.3",
        uuid = "c70c24a7-5551-4f73-8e37-380b11d80be8",
        url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
 

trunk/src/libcore/core.rs

@@ -59,7 +59,7 @@ mod core {
 // Similar to above. Some magic to make core testable.
 #[cfg(test)]
 mod std {
-    use std(vers = "0.2");
+    use std(vers = "0.3");
     import std::test;
 }
 

trunk/src/libcore/dvec.rs

@@ -46,32 +46,28 @@ export unwrap;
  * pointers achieved about 103 million pushes/second.  Using an option
  * type could only produce 47 million pushes/second.
  */
-type dvec_<A> = {
+type dvec<A> = {
     mut data: ~[mut A]
 };
 
-enum dvec<A> {
-    dvec_(dvec_<A>)
-}
-
 /// Creates a new, empty dvec
 fn dvec<A>() -> dvec<A> {
-    dvec_({mut data: ~[mut]})
+    {mut data: ~[mut]}
 }
 
 /// Creates a new dvec with a single element
 fn from_elem<A>(+e: A) -> dvec<A> {
-    dvec_({mut data: ~[mut e]})
+    {mut data: ~[mut e]}
 }
 
 /// Creates a new dvec with the contents of a vector
 fn from_vec<A>(+v: ~[mut A]) -> dvec<A> {
-    dvec_({mut data: v})
+    {mut data: v}
 }
 
 /// Consumes the vector and returns its contents
 fn unwrap<A>(-d: dvec<A>) -> ~[mut A] {
-    let dvec_({data: v}) <- d;
+    let {data: v} <- d;
     ret v;
 }
 

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]

trunk/src/libcore/iter-trait.rs

@@ -21,7 +21,7 @@ impl extensions<A> of iter::base_iter<A> for IMPL_T<A> {
     }
 }
 
-impl extensions<A:copy> of iter::copyable_iter<A> for IMPL_T<A> {
+impl extensions<A:copy> for IMPL_T<A> {
     fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] {
         iter::filter_to_vec(self, pred)
     }

trunk/src/libcore/iter.rs

@@ -7,15 +7,6 @@ iface times {
     fn times(it: fn() -> bool);
 }
 
-trait copyable_iter<A:copy> {
-    fn filter_to_vec(pred: fn(A) -> bool) -> ~[A];
-    fn map_to_vec<B>(op: fn(A) -> B) -> ~[B];
-    fn to_vec() -> ~[A];
-    fn min() -> A;
-    fn max() -> A;
-    fn find(p: fn(A) -> bool) -> option<A>;
-}
-
 fn eachi<A,IA:base_iter<A>>(self: IA, blk: fn(uint, A) -> bool) {
     let mut i = 0u;
     for self.each |a| {