---

yaml
---
r: 4735
b: refs/heads/master
c: f764f9a
h: refs/heads/master
i:
  4733: 90ca6ff
  4731: 25f879b
  4727: e6805d1
  4719: 03827ba
  4703: 0c01df6
  4671: 4350ee3
  4607: 90c3a45
v: v3

Author: erickt

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 8043788e3a71a951892577cbcb623ac94b908677
+refs/heads/master: f764f9a8cf52e686ba6e54b594e6bbbdd5bc7b32

trunk/src/lib/aio.rs

@@ -15,11 +15,11 @@ native "rust" mod rustrt {
     fn aio_init();
     fn aio_run();
     fn aio_stop();
-    fn aio_connect(host: *u8, port: int, connected: &_chan[socket]);
-    fn aio_serve(host: *u8, port: int, acceptChan: &_chan[socket]) -> server;
-    fn aio_writedata(s: socket, buf: *u8, size: uint, status: &_chan[bool]);
-    fn aio_read(s: socket, reader: &_chan[[u8]]);
-    fn aio_close_server(s: server, status: &_chan[bool]);
+    fn aio_connect(host: *u8, port: int, connected: &_chan<socket>);
+    fn aio_serve(host: *u8, port: int, acceptChan: &_chan<socket>) -> server;
+    fn aio_writedata(s: socket, buf: *u8, size: uint, status: &_chan<bool>);
+    fn aio_read(s: socket, reader: &_chan<[u8]>);
+    fn aio_close_server(s: server, status: &_chan<bool>);
     fn aio_close_socket(s: socket);
     fn aio_is_null_client(s: socket) -> bool;
 }
@@ -40,36 +40,36 @@ tag socket_event {
 }
 
 tag server_event {
-    pending(_chan[_chan[socket_event]]);
+    pending(_chan<_chan<socket_event>>);
 }
 
 tag request {
     quit;
-    connect(pending_connection,_chan[socket_event]);
-    serve(net::ip_addr,int,_chan[server_event],_chan[server]);
-    write(client,[u8],_chan[bool]);
-    close_server(server, _chan[bool]);
+    connect(pending_connection,_chan<socket_event>);
+    serve(net::ip_addr,int,_chan<server_event>,_chan<server>);
+    write(client,[u8],_chan<bool>);
+    close_server(server, _chan<bool>);
     close_client(client);
 }
 
-type ctx = _chan[request];
+type ctx = _chan<request>;
 
 fn ip_to_sbuf(ip: net::ip_addr) -> *u8 {
     vec::to_ptr(str::bytes(net::format_addr(ip)))
 }
 
-fn connect_task(ip: net::ip_addr, portnum: int, evt: _chan[socket_event]) {
-    let connecter: _port[client] = mk_port();
+fn connect_task(ip: net::ip_addr, portnum: int, evt: _chan<socket_event>) {
+    let connecter: _port<client> = mk_port();
     rustrt::aio_connect(ip_to_sbuf(ip), portnum, connecter.mk_chan());
     let client = connecter.recv();
     new_client(client, evt);
 }
 
-fn new_client(client: client, evt: _chan[socket_event]) {
+fn new_client(client: client, evt: _chan<socket_event>) {
     // Start the read before notifying about the connect.  This avoids a race
     // condition where the receiver can close the socket before we start
     // reading.
-    let reader: _port[[u8]] = mk_port();
+    let reader: _port<[u8]> = mk_port();
     rustrt::aio_read(client, reader.mk_chan());
 
     send(evt, connected(client));
@@ -92,18 +92,18 @@ fn new_client(client: client, evt: _chan[socket_event]) {
     log "close message sent";
 }
 
-fn accept_task(client: client, events: _chan[server_event]) {
+fn accept_task(client: client, events: _chan<server_event>) {
     log "accept task was spawned";
-    let p: _port[_chan[socket_event]] = mk_port();
+    let p: _port<_chan<socket_event>> = mk_port();
     send(events, pending(p.mk_chan()));
     let evt = p.recv();
     new_client(client, evt);
     log "done accepting";
 }
 
-fn server_task(ip: net::ip_addr, portnum: int, events: _chan[server_event],
-               server: _chan[server]) {
-    let accepter: _port[client] = mk_port();
+fn server_task(ip: net::ip_addr, portnum: int, events: _chan<server_event>,
+               server: _chan<server>) {
+    let accepter: _port<client> = mk_port();
     send(server, rustrt::aio_serve(ip_to_sbuf(ip), portnum,
                                    accepter.mk_chan()));
 
@@ -120,9 +120,9 @@ fn server_task(ip: net::ip_addr, portnum: int, events: _chan[server_event],
     }
 }
 
-fn request_task(c: _chan[ctx]) {
+fn request_task(c: _chan<ctx>) {
     // Create a port to accept IO requests on
-    let p: _port[request] = mk_port();
+    let p: _port<request> = mk_port();
     // Hand of its channel to our spawner
     send(c, p.mk_chan());
     log "uv run task spawned";
@@ -160,7 +160,7 @@ fn request_task(c: _chan[ctx]) {
     }
 }
 
-fn iotask(c: _chan[ctx]) {
+fn iotask(c: _chan<ctx>) {
     log "io task spawned";
     // Initialize before accepting requests
     rustrt::aio_init();
@@ -178,7 +178,7 @@ fn iotask(c: _chan[ctx]) {
 }
 
 fn new() -> ctx {
-    let p: _port[ctx] = mk_port();
+    let p: _port<ctx> = mk_port();
     task::_spawn(bind iotask(p.mk_chan()));
     ret p.recv();
 }

trunk/src/lib/comm.rs

@@ -59,7 +59,7 @@ obj _port[~T](raw_port : @port_ptr) {
     }
 }
 
-fn mk_port[~T]() -> _port[T] {
+fn mk_port[~T]() -> _port<T> {
     _port(@port_ptr(rustrt::new_port(sys::size_of[T]())))
 }
 

trunk/src/lib/deque.rs

@@ -16,8 +16,8 @@ type t[T] =
         fn get(int) -> T ;
     };
 
-fn create[@T]() -> t[T] {
-    type cell[T] = option::t[T];
+fn create[@T]() -> t<T> {
+    type cell[T] = option::t<T>;
 
     let initial_capacity: uint = 32u; // 2^5
      /**
@@ -26,8 +26,8 @@ fn create[@T]() -> t[T] {
       */
 
 
-    fn grow[@T](nelts: uint, lo: uint, elts: &[mutable cell[T]]) ->
-       [mutable cell[T]] {
+    fn grow[@T](nelts: uint, lo: uint, elts: &[mutable cell<T>]) ->
+       [mutable cell<T>] {
         assert (nelts == vec::len(elts));
         let rv = ~[mutable];
 
@@ -42,22 +42,22 @@ fn create[@T]() -> t[T] {
 
         ret rv;
     }
-    fn get[@T](elts: &[mutable cell[T]], i: uint) -> T {
+    fn get[@T](elts: &[mutable cell<T>], i: uint) -> T {
         ret alt elts.(i) { option::some(t) { t } _ { fail } };
     }
     obj deque[@T](mutable nelts: uint,
                   mutable lo: uint,
                   mutable hi: uint,
-                  mutable elts: [mutable cell[T]]) {
+                  mutable elts: [mutable cell<T>]) {
         fn size() -> uint { ret nelts; }
         fn add_front(t: &T) {
             let oldlo: uint = lo;
             if lo == 0u {
-                lo = vec::len[cell[T]](elts) - 1u;
+                lo = vec::len[cell<T>](elts) - 1u;
             } else { lo -= 1u; }
             if lo == hi {
                 elts = grow[T](nelts, oldlo, elts);
-                lo = vec::len[cell[T]](elts) - 1u;
+                lo = vec::len[cell<T>](elts) - 1u;
                 hi = nelts;
             }
             elts.(lo) = option::some[T](t);
@@ -70,7 +70,7 @@ fn create[@T]() -> t[T] {
                 hi = nelts;
             }
             elts.(hi) = option::some[T](t);
-            hi = (hi + 1u) % vec::len[cell[T]](elts);
+            hi = (hi + 1u) % vec::len[cell<T>](elts);
             nelts += 1u;
         }
 
@@ -81,13 +81,13 @@ fn create[@T]() -> t[T] {
         fn pop_front() -> T {
             let t: T = get[T](elts, lo);
             elts.(lo) = option::none[T];
-            lo = (lo + 1u) % vec::len[cell[T]](elts);
+            lo = (lo + 1u) % vec::len[cell<T>](elts);
             nelts -= 1u;
             ret t;
         }
         fn pop_back() -> T {
             if hi == 0u {
-                hi = vec::len[cell[T]](elts) - 1u;
+                hi = vec::len[cell<T>](elts) - 1u;
             } else { hi -= 1u; }
             let t: T = get[T](elts, hi);
             elts.(hi) = option::none[T];
@@ -97,11 +97,11 @@ fn create[@T]() -> t[T] {
         fn peek_front() -> T { ret get[T](elts, lo); }
         fn peek_back() -> T { ret get[T](elts, hi - 1u); }
         fn get(i: int) -> T {
-            let idx: uint = (lo + (i as uint)) % vec::len[cell[T]](elts);
+            let idx: uint = (lo + (i as uint)) % vec::len[cell<T>](elts);
             ret get[T](elts, idx);
         }
     }
-    let v: [mutable cell[T]] =
+    let v: [mutable cell<T>] =
         vec::init_elt_mut(option::none, initial_capacity);
     ret deque[T](0u, 0u, 0u, v);
 }

trunk/src/lib/ebml.rs

@@ -50,7 +50,7 @@ fn doc_at(data: &@[u8], start: uint) -> doc {
     ret {data: data, start: elt_size.next, end: end};
 }
 
-fn maybe_get_doc(d: doc, tg: uint) -> option::t[doc] {
+fn maybe_get_doc(d: doc, tg: uint) -> option::t<doc> {
     let pos = d.start;
     while pos < d.end {
         let elt_tag = vint_at(*d.data, pos);

trunk/src/lib/either.rs

@@ -6,30 +6,30 @@ import option::none;
 tag t[T, U] { left(T); right(U); }
 
 fn either[T, U, V](f_left: &block(&T) -> V, f_right: &block(&U) -> V,
-                   value: &t[T, U]) -> V {
+                   value: &t<T, U>) -> V {
     alt value { left(l) { f_left(l) } right(r) { f_right(r) } }
 }
 
-fn lefts[T, U](eithers: &[t[T, U]]) -> [T] {
+fn lefts[T, U](eithers: &[t<T, U>]) -> [T] {
     let result: [T] = ~[];
-    for elt: t[T, U] in eithers {
+    for elt: t<T, U> in eithers {
         alt elt { left(l) { result += ~[l] } _ {/* fallthrough */ } }
     }
     ret result;
 }
 
-fn rights[T, U](eithers: &[t[T, U]]) -> [U] {
+fn rights[T, U](eithers: &[t<T, U>]) -> [U] {
     let result: [U] = ~[];
-    for elt: t[T, U] in eithers {
+    for elt: t<T, U> in eithers {
         alt elt { right(r) { result += ~[r] } _ {/* fallthrough */ } }
     }
     ret result;
 }
 
-fn partition[T, U](eithers: &[t[T, U]]) -> {lefts: [T], rights: [U]} {
+fn partition[T, U](eithers: &[t<T, U>]) -> {lefts: [T], rights: [U]} {
     let lefts: [T] = ~[];
     let rights: [U] = ~[];
-    for elt: t[T, U] in eithers {
+    for elt: t<T, U> in eithers {
         alt elt { left(l) { lefts += ~[l] } right(r) { rights += ~[r] } }
     }
     ret {lefts: lefts, rights: rights};

trunk/src/lib/extfmt.rs

@@ -60,7 +60,7 @@ mod ct {
 
     // A formatted conversion from an expression to a string
     type conv =
-        {param: option::t[int],
+        {param: option::t<int>,
          flags: [flag],
          width: count,
          precision: count,
@@ -105,7 +105,7 @@ mod ct {
         ret pieces;
     }
     fn peek_num(s: str, i: uint, lim: uint) ->
-       option::t[{num: uint, next: uint}] {
+       option::t<{num: uint, next: uint}> {
         if i >= lim { ret none; }
         let c = s.(i);
         if !('0' as u8 <= c && c <= '9' as u8) { ret option::none; }
@@ -135,7 +135,7 @@ mod ct {
              next: ty.next};
     }
     fn parse_parameter(s: str, i: uint, lim: uint) ->
-       {param: option::t[int], next: uint} {
+       {param: option::t<int>, next: uint} {
         if i >= lim { ret {param: none, next: i}; }
         let num = peek_num(s, i, lim);
         ret alt num {

trunk/src/lib/generic_os.rs

@@ -3,7 +3,7 @@ import str::sbuf;
 
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "macos")]
-fn getenv(n: str) -> option::t[str] {
+fn getenv(n: str) -> option::t<str> {
     let s = os::libc::getenv(str::buf(n));
     ret if s as int == 0 {
             option::none[str]
@@ -19,7 +19,7 @@ fn setenv(n: str, v: str) {
 }
 
 #[cfg(target_os = "win32")]
-fn getenv(n: str) -> option::t[str] {
+fn getenv(n: str) -> option::t<str> {
     let nbuf = str::buf(n);
     let nsize = 256u;
     while true {

trunk/src/lib/getopts.rs

@@ -75,7 +75,7 @@ fn name_str(nm: name) -> str {
     ret alt nm { short(ch) { str::from_char(ch) } long(s) { s } };
 }
 
-fn find_opt(opts: &[opt], nm: name) -> option::t[uint] {
+fn find_opt(opts: &[opt], nm: name) -> option::t<uint> {
     let i = 0u;
     let l = vec::len[opt](opts);
     while i < l { if opts.(i).name == nm { ret some[uint](i); } i += 1u; }
@@ -224,7 +224,7 @@ fn opt_strs(m: &match, nm: str) -> [str] {
     ret acc;
 }
 
-fn opt_maybe_str(m: &match, nm: str) -> option::t[str] {
+fn opt_maybe_str(m: &match, nm: str) -> option::t<str> {
     let vals = opt_vals(m, nm);
     if vec::len[optval](vals) == 0u { ret none[str]; }
     ret alt vals.(0) { val(s) { some[str](s) } _ { none[str] } };
@@ -234,7 +234,7 @@ fn opt_maybe_str(m: &match, nm: str) -> option::t[str] {
 /// Returns none if the option was not present, `def` if the option was
 /// present but no argument was provided, and the argument if the option was
 /// present and an argument was provided.
-fn opt_default(m: &match, nm: str, def: str) -> option::t[str] {
+fn opt_default(m: &match, nm: str, def: str) -> option::t<str> {
     let vals = opt_vals(m, nm);
     if vec::len[optval](vals) == 0u { ret none[str]; }
     ret alt vals.(0) { val(s) { some[str](s) } _ { some[str](def) } }

trunk/src/lib/io.rs

@@ -59,7 +59,7 @@ resource FILE_res(f: os::libc::FILE) {
     os::libc::fclose(f);
 }
 
-obj FILE_buf_reader(f: os::libc::FILE, res: option::t[@FILE_res]) {
+obj FILE_buf_reader(f: os::libc::FILE, res: option::t<@FILE_res>) {
     fn read(len: uint) -> [u8] {
         let buf = ~[];
         vec::reserve[u8](buf, len);
@@ -243,7 +243,7 @@ type buf_writer =
         fn tell() -> uint ;
     };
 
-obj FILE_writer(f: os::libc::FILE, res: option::t[@FILE_res]) {
+obj FILE_writer(f: os::libc::FILE, res: option::t<@FILE_res>) {
     fn write(v: &[u8]) {
         let len = vec::len[u8](v);
         let vbuf = vec::to_ptr[u8](v);
@@ -262,7 +262,7 @@ resource fd_res(fd: int) {
     os::libc::close(fd);
 }
 
-obj fd_buf_writer(fd: int, res: option::t[@fd_res]) {
+obj fd_buf_writer(fd: int, res: option::t<@fd_res>) {
     fn write(v: &[u8]) {
         let len = vec::len[u8](v);
         let count = 0u;