---

yaml
---
r: 4498
b: refs/heads/master
c: 50f97cb
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: bf84d20f7cfba43abb7c895f31b3da23c1fd4a9a
+refs/heads/master: 50f97cb368954937662f17b8bddab81206e4ab07

trunk/src/lib/aio.rs

@@ -10,7 +10,7 @@ native "rust" mod rustrt {
     fn aio_connect(host: sbuf, port: int, connected: chan[socket]);
     fn aio_serve(host: sbuf, 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_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;
@@ -26,7 +26,7 @@ tag pending_connection {
 tag socket_event {
     connected(client);
     closed;
-    received(u8[]);
+    received([u8]);
 }
 
 tag server_event {
@@ -37,7 +37,7 @@ tag request {
     quit;
     connect(pending_connection,chan[socket_event]);
     serve(str,int,chan[server_event],chan[server]);
-    write(client,u8[],chan[bool]);
+    write(client,[u8],chan[bool]);
     close_server(server, chan[bool]);
     close_client(client);
 }
@@ -56,14 +56,14 @@ 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[]] = port();
+    let reader: port[[u8]] = port();
     rustrt::aio_read(client, chan(reader));
 
     evt <| connected(client);
 
     while (true) {
         log "waiting for bytes";
-        let data: u8[];
+        let data: [u8];
         reader |> data;
         log "got some bytes";
         log ivec::len[u8](data);

trunk/src/lib/bitv.rs

@@ -24,7 +24,7 @@ export eq_vec;
 //        an optimizing version of this module that produces a different obj
 //        for the case where nbits <= 32.
 
-type t = @{storage: uint[mutable ], nbits: uint};
+type t = @{storage: [mutable uint], nbits: uint};
 
 
 // FIXME: this should be a constant once they work
@@ -150,7 +150,7 @@ fn to_vec(v: &t) -> vec[uint] {
     ret vec::init_fn[uint](sub, v.nbits);
 }
 
-fn to_ivec(v: &t) -> uint[] {
+fn to_ivec(v: &t) -> [uint] {
     let sub = bind init_to_vec(v, _);
     ret ivec::init_fn[uint](sub, v.nbits);
 }
@@ -178,7 +178,7 @@ fn eq_vec(v0: &t, v1: &vec[uint]) -> bool {
     ret true;
 }
 
-fn eq_ivec(v0: &t, v1: &uint[]) -> bool {
+fn eq_ivec(v0: &t, v1: &[uint]) -> bool {
     assert (v0.nbits == ivec::len[uint](v1));
     let len = v0.nbits;
     let i = 0u;

trunk/src/lib/deque.rs

@@ -26,10 +26,10 @@ fn create[@T]() -> t[T] {
       */
 
 
-    fn grow[@T](nelts: uint, lo: uint, elts: &(cell[T])[mutable ]) ->
-       (cell[T])[mutable ] {
+    fn grow[@T](nelts: uint, lo: uint, elts: &[mutable cell[T]]) ->
+       [mutable cell[T]] {
         assert (nelts == ivec::len(elts));
-        let rv = ~[mutable ];
+        let rv = ~[mutable];
 
         let i = 0u;
         let nalloc = uint::next_power_of_two(nelts + 1u);
@@ -42,13 +42,13 @@ fn create[@T]() -> t[T] {
 
         ret rv;
     }
-    fn get[@T](elts: &(cell[T])[mutable ], 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: (cell[T])[mutable ]) {
+                  mutable elts: [mutable cell[T]]) {
         fn size() -> uint { ret nelts; }
         fn add_front(t: &T) {
             let oldlo: uint = lo;
@@ -101,7 +101,7 @@ fn create[@T]() -> t[T] {
             ret get[T](elts, idx);
         }
     }
-    let v: (cell[T])[mutable ] =
+    let v: [mutable cell[T]] =
         ivec::init_elt_mut(option::none, initial_capacity);
     ret deque[T](0u, 0u, 0u, v);
 }

trunk/src/lib/ebml.rs

@@ -15,9 +15,9 @@ type ebml_state = {ebml_tag: ebml_tag, tag_pos: uint, data_pos: uint};
 // modules within this file.
 
 // ebml reading
-type doc = {data: @u8[], start: uint, end: uint};
+type doc = {data: @[u8], start: uint, end: uint};
 
-fn vint_at(data: &u8[], start: uint) -> {val: uint, next: uint} {
+fn vint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
     let a = data.(start);
     if a & 0x80u8 != 0u8 { ret {val: a & 0x7fu8 as uint, next: start + 1u}; }
     if a & 0x40u8 != 0u8 {
@@ -39,11 +39,11 @@ fn vint_at(data: &u8[], start: uint) -> {val: uint, next: uint} {
     } else { log_err "vint too big"; fail; }
 }
 
-fn new_doc(data: &@u8[]) -> doc {
+fn new_doc(data: &@[u8]) -> doc {
     ret {data: data, start: 0u, end: ivec::len[u8](*data)};
 }
 
-fn doc_at(data: &@u8[], start: uint) -> doc {
+fn doc_at(data: &@[u8], start: uint) -> doc {
     let elt_tag = vint_at(*data, start);
     let elt_size = vint_at(*data, elt_tag.next);
     let end = elt_size.next + elt_size.val;
@@ -96,9 +96,9 @@ iter tagged_docs(d: doc, tg: uint) -> doc {
     }
 }
 
-fn doc_data(d: doc) -> u8[] { ret ivec::slice[u8](*d.data, d.start, d.end); }
+fn doc_data(d: doc) -> [u8] { ret ivec::slice[u8](*d.data, d.start, d.end); }
 
-fn be_uint_from_bytes(data: &@u8[], start: uint, size: uint) -> uint {
+fn be_uint_from_bytes(data: &@[u8], start: uint, size: uint) -> uint {
     let sz = size;
     assert (sz <= 4u);
     let val = 0u;
@@ -117,10 +117,10 @@ fn doc_as_uint(d: doc) -> uint {
 
 
 // ebml writing
-type writer = {writer: ioivec::buf_writer, mutable size_positions: uint[]};
+type writer = {writer: ioivec::buf_writer, mutable size_positions: [uint]};
 
 fn write_sized_vint(w: &ioivec::buf_writer, n: uint, size: uint) {
-    let buf: u8[];
+    let buf: [u8];
     alt size {
       1u { buf = ~[0x80u8 | (n as u8)]; }
       2u { buf = ~[0x40u8 | (n >> 8u as u8), n & 0xffu as u8]; }
@@ -149,7 +149,7 @@ fn write_vint(w: &ioivec::buf_writer, n: uint) {
 }
 
 fn create_writer(w: &ioivec::buf_writer) -> writer {
-    let size_positions: uint[] = ~[];
+    let size_positions: [uint] = ~[];
     ret {writer: w, mutable size_positions: size_positions};
 }
 
@@ -162,7 +162,7 @@ fn start_tag(w: &writer, tag_id: uint) {
     // Write a placeholder four-byte size.
 
     w.size_positions += ~[w.writer.tell()];
-    let zeroes: u8[] = ~[0u8, 0u8, 0u8, 0u8];
+    let zeroes: [u8] = ~[0u8, 0u8, 0u8, 0u8];
     w.writer.write(zeroes);
 }
 

trunk/src/lib/either.rs

@@ -13,25 +13,25 @@ fn either[T, U,
     alt value { left(l) { f_left(l) } right(r) { f_right(r) } }
 }
 
-fn lefts[T, U](eithers: &(t[T, U])[]) -> T[] {
-    let result: T[] = ~[];
+fn lefts[T, U](eithers: &[t[T, U]]) -> [T] {
+    let result: [T] = ~[];
     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[] {
-    let result: U[] = ~[];
+fn rights[T, U](eithers: &[t[T, U]]) -> [U] {
+    let result: [U] = ~[];
     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[]} {
-    let lefts: T[] = ~[];
-    let 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 {
         alt elt { left(l) { lefts += ~[l] } right(r) { rights += ~[r] } }
     }

trunk/src/lib/fs.rs

@@ -44,10 +44,10 @@ fn connect(pre: path, post: path) -> path {
 
 fn file_is_dir(p: path) -> bool { ret rustrt::rust_file_is_dir(p) != 0; }
 
-fn list_dir(p: path) -> str[] {
+fn list_dir(p: path) -> [str] {
     let pl = str::byte_len(p);
     if pl == 0u || p.(pl - 1u) as char != os_fs::path_sep { p += path_sep(); }
-    let full_paths: str[] = ~[];
+    let full_paths: [str] = ~[];
     for filename: str  in os_fs::list_dir(p) {
         if !str::eq(filename, ".") {
             if !str::eq(filename, "..") { full_paths += ~[p + filename]; }

trunk/src/lib/getopts.rs

@@ -66,7 +66,7 @@ fn optmulti(name: str) -> opt {
 
 tag optval { val(str); given; }
 
-type match = {opts: opt[], vals: optval[][mutable ], free: vec[str]};
+type match = {opts: [opt], vals: [mutable [optval]], free: vec[str]};
 
 fn is_arg(arg: str) -> bool {
     ret str::byte_len(arg) > 1u && arg.(0) == '-' as u8;
@@ -76,7 +76,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 = ivec::len[opt](opts);
     while i < l { if opts.(i).name == nm { ret some[uint](i); } i += 1u; }
@@ -116,10 +116,10 @@ fn getopts(args: vec[str], opts: vec[opt]) -> result {
     ret getopts_ivec(args_ivec, opts_ivec);
 }
 
-fn getopts_ivec(args: &str[], opts: &opt[]) -> result {
+fn getopts_ivec(args: &[str], opts: &[opt]) -> result {
     let n_opts = ivec::len[opt](opts);
-    fn f(x: uint) -> optval[] { ret ~[]; }
-    let vals = ivec::init_fn_mut[optval[]](f, n_opts);
+    fn f(x: uint) -> [optval] { ret ~[]; }
+    let vals = ivec::init_fn_mut[[optval]](f, n_opts);
     let free: vec[str] = [];
     let l = ivec::len[str](args);
     let i = 0u;
@@ -209,7 +209,7 @@ fn getopts_ivec(args: &str[], opts: &opt[]) -> result {
     ret success({opts: opts, vals: vals, free: free});
 }
 
-fn opt_vals(m: &match, nm: str) -> optval[] {
+fn opt_vals(m: &match, nm: str) -> [optval] {
     ret alt find_opt(m.opts, mkname(nm)) {
           some(id) { m.vals.(id) }
           none. { log_err "No option '" + nm + "' defined."; fail }
@@ -234,8 +234,8 @@ fn opt_strs(m: &match, nm: str) -> vec[str] {
     ret acc;
 }
 
-fn opt_strs_ivec(m: &match, nm: str) -> str[] {
-    let acc: str[] = ~[];
+fn opt_strs_ivec(m: &match, nm: str) -> [str] {
+    let acc: [str] = ~[];
     for v: optval  in opt_vals(m, nm) {
         alt v { val(s) { acc += ~[s]; } _ { } }
     }