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;
tag socket_event {
connected(client);
closed;
- received(u8[]);
+ received([u8]);
}
tag server_event {
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);
}
// 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);
// 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
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);
}
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;
*/
- 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);
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;
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);
}
// 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 {
} 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;
}
}
-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;
// 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]; }
}
fn create_writer(w: &ioivec::buf_writer) -> writer {
- let size_positions: uint[] = ~[];
+ let size_positions: [uint] = ~[];
ret {writer: w, mutable size_positions: size_positions};
}
// 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);
}
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] } }
}
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]; }
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;
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; }
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;
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 }
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]; } _ { } }
}
// FIXME: Seekable really should be orthogonal. We will need
// inheritance.
obj {
- fn read(uint) -> u8[] ;
+ fn read(uint) -> [u8] ;
fn read_byte() -> int ;
fn unread_byte(int) ;
fn eof() -> bool ;
fn get_buf_reader() -> buf_reader ;
fn read_byte() -> int ;
fn unread_byte(int) ;
- fn read_bytes(uint) -> u8[] ;
+ fn read_bytes(uint) -> [u8] ;
fn read_char() -> char ;
fn eof() -> bool ;
fn read_line() -> str ;
fn read_le_uint(uint) -> uint ;
fn read_le_int(uint) -> int ;
fn read_be_uint(uint) -> uint ;
- fn read_whole_stream() -> u8[] ;
+ fn read_whole_stream() -> [u8] ;
fn seek(int, seek_style) ;
fn tell() -> uint ;
};
}
obj FILE_buf_reader(f: os::libc::FILE, res: option::t[@FILE_res]) {
- fn read(len: uint) -> u8[] {
+ fn read(len: uint) -> [u8] {
let buf = ~[];
ivec::reserve[u8](buf, len);
let read = os::libc_ivec::fread(ivec::to_ptr[u8](buf), 1u, len, f);
fn get_buf_reader() -> buf_reader { ret rdr; }
fn read_byte() -> int { ret rdr.read_byte(); }
fn unread_byte(byte: int) { ret rdr.unread_byte(byte); }
- fn read_bytes(len: uint) -> u8[] { ret rdr.read(len); }
+ fn read_bytes(len: uint) -> [u8] { ret rdr.read(len); }
fn read_char() -> char {
let c0 = rdr.read_byte();
if c0 == -1 {
}
fn eof() -> bool { ret rdr.eof(); }
fn read_line() -> str {
- let buf: u8[] = ~[];
+ let buf: [u8] = ~[];
// No break yet in rustc
let go_on = true;
ret str::unsafe_from_bytes_ivec(buf);
}
fn read_c_str() -> str {
- let buf: u8[] = ~[];
+ let buf: [u8] = ~[];
let go_on = true;
while go_on {
let ch = rdr.read_byte();
}
ret val;
}
- fn read_whole_stream() -> u8[] {
- let buf: u8[] = ~[];
+ fn read_whole_stream() -> [u8] {
+ let buf: [u8] = ~[];
while !rdr.eof() { buf += rdr.read(2048u); }
ret buf;
}
// Byte buffer readers
// TODO: mutable? u8, but this fails with rustboot.
-type byte_buf = @{buf: u8[], mutable pos: uint};
+type byte_buf = @{buf: [u8], mutable pos: uint};
obj byte_buf_reader(bbuf: byte_buf) {
- fn read(len: uint) -> u8[] {
+ fn read(len: uint) -> [u8] {
let rest = ivec::len[u8](bbuf.buf) - bbuf.pos;
let to_read = len;
if rest < to_read { to_read = rest; }
fn tell() -> uint { ret bbuf.pos; }
}
-fn new_byte_buf_reader(buf: &u8[]) -> buf_reader {
+fn new_byte_buf_reader(buf: &[u8]) -> buf_reader {
ret byte_buf_reader(@{buf: buf, mutable pos: 0u});
}
// FIXME: eventually u64
obj {
- fn write(&u8[]) ;
+ fn write(&[u8]) ;
fn seek(int, seek_style) ;
fn tell() -> uint ;
};
obj FILE_writer(f: os::libc::FILE, res: option::t[@FILE_res]) {
- fn write(v: &u8[]) {
+ fn write(v: &[u8]) {
let len = ivec::len[u8](v);
let vbuf = ivec::to_ptr[u8](v);
let nout = os::libc_ivec::fwrite(vbuf, len, 1u, f);
}
obj fd_buf_writer(fd: int, res: option::t[@fd_res]) {
- fn write(v: &u8[]) {
+ fn write(v: &[u8]) {
let len = ivec::len[u8](v);
let count = 0u;
let vbuf;
}
}
-fn file_buf_writer(path: str, flags: &fileflag[]) -> buf_writer {
+fn file_buf_writer(path: str, flags: &[fileflag]) -> buf_writer {
let fflags: int =
os::libc_constants::O_WRONLY() | os::libc_constants::O_BINARY();
for f: fileflag in flags {
fn write_char(char) ;
fn write_int(int) ;
fn write_uint(uint) ;
- fn write_bytes(&u8[]) ;
+ fn write_bytes(&[u8]) ;
fn write_le_uint(uint, uint) ;
fn write_le_int(int, uint) ;
fn write_be_uint(uint, uint) ;
};
-fn uint_to_le_bytes(n: uint, size: uint) -> u8[] {
- let bytes: u8[] = ~[];
+fn uint_to_le_bytes(n: uint, size: uint) -> [u8] {
+ let bytes: [u8] = ~[];
while size > 0u { bytes += ~[n & 255u as u8]; n >>= 8u; size -= 1u; }
ret bytes;
}
-fn uint_to_be_bytes(n: uint, size: uint) -> u8[] {
- let bytes: u8[] = ~[];
+fn uint_to_be_bytes(n: uint, size: uint) -> [u8] {
+ let bytes: [u8] = ~[];
let i = size - 1u as int;
while i >= 0 { bytes += ~[n >> (i * 8 as uint) & 255u as u8]; i -= 1; }
ret bytes;
fn write_uint(n: uint) {
out.write(str::bytes_ivec(uint::to_str(n, 10u)));
}
- fn write_bytes(bytes: &u8[]) { out.write(bytes); }
+ fn write_bytes(bytes: &[u8]) { out.write(bytes); }
fn write_le_uint(n: uint, size: uint) {
out.write(uint_to_le_bytes(n, size));
}
// FIXME: Remove me once objects are exported.
fn new_writer_(out: buf_writer) -> writer { ret new_writer(out); }
-fn file_writer(path: str, flags: &fileflag[]) -> writer {
+fn file_writer(path: str, flags: &[fileflag]) -> writer {
ret new_writer(file_buf_writer(path, flags));
}
fn get_str() -> str ;
};
-type mutable_byte_buf = @{mutable buf: u8[mutable ], mutable pos: uint};
+type mutable_byte_buf = @{mutable buf: [mutable u8], mutable pos: uint};
obj byte_buf_writer(buf: mutable_byte_buf) {
- fn write(v: &u8[]) {
+ fn write(v: &[u8]) {
// Fast path.
if buf.pos == ivec::len(buf.buf) {
fn string_writer() -> str_writer {
// FIXME: yikes, this is bad. Needs fixing of mutable syntax.
- let b: u8[mutable ] = ~[mutable 0u8];
+ let b: [mutable u8] = ~[mutable 0u8];
ivec::pop(b);
let buf: mutable_byte_buf = @{mutable buf: b, mutable pos: 0u};
obj str_writer_wrap(wr: writer, buf: mutable_byte_buf) {
str::unsafe_from_bytes_ivec(read_whole_file(file))
}
-fn read_whole_file(file: &str) -> u8[] {
+fn read_whole_file(file: &str) -> [u8] {
// FIXME: There's a lot of copying here
file_reader(file).read_whole_stream()
}
type operator2[T, U, V] = fn(&T, &U) -> V ;
native "rust-intrinsic" mod rusti {
- fn ivec_len[T](v: &T[]) -> uint;
+ fn ivec_len[T](v: &[T]) -> uint;
}
native "rust" mod rustrt {
- fn ivec_reserve_shared[T](v: &mutable T[mutable? ], n: uint);
- fn ivec_on_heap[T](v: &T[]) -> uint;
- fn ivec_to_ptr[T](v: &T[]) -> *T;
- fn ivec_copy_from_buf_shared[T](v: &mutable T[mutable? ], ptr: *T,
+ fn ivec_reserve_shared[T](v: &mutable [mutable? T], n: uint);
+ fn ivec_on_heap[T](v: &[T]) -> uint;
+ fn ivec_to_ptr[T](v: &[T]) -> *T;
+ fn ivec_copy_from_buf_shared[T](v: &mutable [mutable? T], ptr: *T,
count: uint);
}
-fn from_vec[@T](v: &vec[T]) -> T[] {
- let iv: T[] = ~[];
+fn from_vec[@T](v: &vec[T]) -> [T] {
+ let iv = ~[];
for e in v {
iv += ~[e];
}
ret iv;
}
-fn to_vec[@T](iv: &T[]) -> vec[T] {
+fn to_vec[@T](iv: &[T]) -> vec[T] {
let v: vec[T] = [];
for e in iv {
v += [e];
}
/// Reserves space for `n` elements in the given vector.
-fn reserve[@T](v: &mutable T[mutable? ], n: uint) {
+fn reserve[@T](v: &mutable [mutable? T], n: uint) {
rustrt::ivec_reserve_shared(v, n);
}
-fn on_heap[T](v: &T[]) -> bool { ret rustrt::ivec_on_heap(v) != 0u; }
+fn on_heap[T](v: &[T]) -> bool { ret rustrt::ivec_on_heap(v) != 0u; }
-fn to_ptr[T](v: &T[]) -> *T { ret rustrt::ivec_to_ptr(v); }
+fn to_ptr[T](v: &[T]) -> *T { ret rustrt::ivec_to_ptr(v); }
-fn len[T](v: &T[mutable? ]) -> uint { ret rusti::ivec_len(v); }
+fn len[T](v: &[mutable? T]) -> uint { ret rusti::ivec_len(v); }
type init_op[T] = fn(uint) -> T ;
-fn init_fn[@T](op: &init_op[T], n_elts: uint) -> T[] {
+fn init_fn[@T](op: &init_op[T], n_elts: uint) -> [T] {
let v = ~[];
reserve(v, n_elts);
let i: uint = 0u;
}
// TODO: Remove me once we have slots.
-fn init_fn_mut[@T](op: &init_op[T], n_elts: uint) -> T[mutable ] {
- let v = ~[mutable ];
+fn init_fn_mut[@T](op: &init_op[T], n_elts: uint) -> [mutable T] {
+ let v = ~[mutable];
reserve(v, n_elts);
let i: uint = 0u;
while i < n_elts { v += ~[mutable op(i)]; i += 1u; }
ret v;
}
-fn init_elt[@T](t: &T, n_elts: uint) -> T[] {
+fn init_elt[@T](t: &T, n_elts: uint) -> [T] {
let v = ~[];
reserve(v, n_elts);
let i: uint = 0u;
}
// TODO: Remove me once we have slots.
-fn init_elt_mut[@T](t: &T, n_elts: uint) -> T[mutable ] {
- let v = ~[mutable ];
+fn init_elt_mut[@T](t: &T, n_elts: uint) -> [mutable T] {
+ let v = ~[mutable];
reserve(v, n_elts);
let i: uint = 0u;
while i < n_elts { v += ~[mutable t]; i += 1u; }
ret v;
}
-fn to_mut[@T](v: &T[]) -> T[mutable ] {
- let vres = ~[mutable ];
+fn to_mut[@T](v: &[T]) -> [mutable T] {
+ let vres = ~[mutable];
for t: T in v { vres += ~[mutable t]; }
ret vres;
}
-fn from_mut[@T](v: &T[mutable ]) -> T[] {
+fn from_mut[@T](v: &[mutable T]) -> [T] {
let vres = ~[];
for t: T in v { vres += ~[t]; }
ret vres;
}
// Predicates
-pred is_empty[T](v: &T[mutable? ]) -> bool {
+pred is_empty[T](v: &[mutable? T]) -> bool {
// FIXME: This would be easier if we could just call len
for t: T in v { ret false; }
ret true;
}
-pred is_not_empty[T](v: &T[mutable? ]) -> bool { ret !is_empty(v); }
+pred is_not_empty[T](v: &[mutable? T]) -> bool { ret !is_empty(v); }
// Accessors
/// Returns the first element of a vector
-fn head[@T](v: &T[mutable?]) : is_not_empty(v) -> T { ret v.(0); }
+fn head[@T](v: &[mutable? T]) : is_not_empty(v) -> T { ret v.(0); }
/// Returns all but the first element of a vector
-fn tail[@T](v: &T[mutable? ]) : is_not_empty(v) -> T[mutable?] {
+fn tail[@T](v: &[mutable? T]) : is_not_empty(v) -> [mutable? T] {
ret slice(v, 1u, len(v));
}
/// Returns the last element of `v`.
-fn last[@T](v: &T[mutable? ]) -> option::t[T] {
+fn last[@T](v: &[mutable? T]) -> option::t[T] {
if len(v) == 0u { ret none; }
ret some(v.(len(v) - 1u));
}
/// Returns a copy of the elements from [`start`..`end`) from `v`.
-fn slice[@T](v: &T[mutable? ], start: uint, end: uint) -> T[] {
+fn slice[@T](v: &[mutable? T], start: uint, end: uint) -> [T] {
assert (start <= end);
assert (end <= len(v));
let result = ~[];
}
// TODO: Remove me once we have slots.
-fn slice_mut[@T](v: &T[mutable? ], start: uint, end: uint) -> T[mutable ] {
+fn slice_mut[@T](v: &[mutable? T], start: uint, end: uint) -> [mutable T] {
assert (start <= end);
assert (end <= len(v));
- let result = ~[mutable ];
+ let result = ~[mutable];
reserve(result, end - start);
let i = start;
while i < end { result += ~[mutable v.(i)]; i += 1u; }
// Mutators
// TODO: Write this, unsafely, in a way that's not O(n).
-fn pop[@T](v: &mutable T[mutable? ]) -> T {
+fn pop[@T](v: &mutable [mutable? T]) -> T {
let ln = len(v);
assert (ln > 0u);
ln -= 1u;
// Appending
/// Expands the given vector in-place by appending `n` copies of `initval`.
-fn grow[@T](v: &mutable T[], n: uint, initval: &T) {
+fn grow[@T](v: &mutable [T], n: uint, initval: &T) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
while i < n { v += ~[initval]; i += 1u; }
}
// TODO: Remove me once we have slots.
-fn grow_mut[@T](v: &mutable T[mutable ], n: uint, initval: &T) {
+fn grow_mut[@T](v: &mutable [mutable T], n: uint, initval: &T) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
while i < n { v += ~[mutable initval]; i += 1u; }
/// Calls `f` `n` times and appends the results of these calls to the given
/// vector.
-fn grow_fn[@T](v: &mutable T[], n: uint, init_fn: fn(uint) -> T ) {
+fn grow_fn[@T](v: &mutable [T], n: uint, init_fn: fn(uint) -> T ) {
reserve(v, next_power_of_two(len(v) + n));
let i: uint = 0u;
while i < n { v += ~[init_fn(i)]; i += 1u; }
/// Sets the element at position `index` to `val`. If `index` is past the end
/// of the vector, expands the vector by replicating `initval` to fill the
/// intervening space.
-fn grow_set[@T](v: &mutable T[mutable ], index: uint, initval: &T, val: &T) {
+fn grow_set[@T](v: &mutable [mutable T], index: uint, initval: &T, val: &T) {
if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); }
v.(index) = val;
}
// Functional utilities
-fn map[@T, @U](f: fn(&T) -> U , v: &T[mutable? ]) -> U[] {
+fn map[@T, @U](f: fn(&T) -> U , v: &[mutable? T]) -> [U] {
let result = ~[];
reserve(result, len(v));
for elem: T in v {
ret result;
}
-fn filter_map[@T, @U](f: fn(&T) -> option::t[U] , v: &T[mutable? ]) -> U[] {
+fn filter_map[@T, @U](f: fn(&T) -> option::t[U] , v: &[mutable? T]) -> [U] {
let result = ~[];
for elem: T in v {
let elem2 = elem; // satisfies alias checker
ret result;
}
-fn foldl[@T, @U](p: fn(&U, &T) -> U , z: &U, v: &T[mutable? ]) -> U {
+fn foldl[@T, @U](p: fn(&U, &T) -> U , z: &U, v: &[mutable? T]) -> U {
let sz = len(v);
if sz == 0u { ret z; }
let first = v.(0);
ret p(foldl[T, U](p, z, rest), first);
}
-fn any[T](f: fn(&T) -> bool , v: &T[]) -> bool {
+fn any[T](f: fn(&T) -> bool , v: &[T]) -> bool {
for elem: T in v { if f(elem) { ret true; } }
ret false;
}
-fn all[T](f: fn(&T) -> bool , v: &T[]) -> bool {
+fn all[T](f: fn(&T) -> bool , v: &[T]) -> bool {
for elem: T in v { if !f(elem) { ret false; } }
ret true;
}
-fn member[T](x: &T, v: &T[]) -> bool {
+fn member[T](x: &T, v: &[T]) -> bool {
for elt: T in v { if x == elt { ret true; } }
ret false;
}
-fn count[T](x: &T, v: &T[mutable? ]) -> uint {
+fn count[T](x: &T, v: &[mutable? T]) -> uint {
let cnt = 0u;
for elt: T in v { if x == elt { cnt += 1u; } }
ret cnt;
}
-fn find[@T](f: fn(&T) -> bool , v: &T[]) -> option::t[T] {
+fn find[@T](f: fn(&T) -> bool , v: &[T]) -> option::t[T] {
for elt: T in v { if f(elt) { ret some[T](elt); } }
ret none[T];
}
-fn unzip[@T, @U](v: &{_0: T, _1: U}[]) -> {_0: T[], _1: U[]} {
+fn unzip[@T, @U](v: &[{_0: T, _1: U}]) -> {_0: [T], _1: [U]} {
let sz = len(v);
if sz == 0u {
ret {_0: ~[], _1: ~[]};
// FIXME make the lengths being equal a constraint
-fn zip[@T, @U](v: &T[], u: &U[]) -> {_0: T, _1: U}[] {
+fn zip[@T, @U](v: &[T], u: &[U]) -> [{_0: T, _1: U}] {
let sz = len(v);
assert (sz == len(u));
if sz == 0u {
heap_part: *mutable ivec_heap_part};
type ivec_heap_part = {mutable fill: uint};
- fn copy_from_buf[T](v: &mutable T[], ptr: *T, count: uint) {
+ fn copy_from_buf[T](v: &mutable [T], ptr: *T, count: uint) {
ret rustrt::ivec_copy_from_buf_shared(v, ptr, count);
}
- fn from_buf[T](ptr: *T, bytes: uint) -> T[] {
+ fn from_buf[T](ptr: *T, bytes: uint) -> [T] {
let v = ~[];
copy_from_buf(v, ptr, bytes);
ret v;
}
- fn set_len[T](v: &mutable T[], new_len: uint) {
+ fn set_len[T](v: &mutable [T], new_len: uint) {
let new_fill = new_len * sys::size_of[T]();
let stack_part: *mutable ivec_repr =
::unsafe::reinterpret_cast(addr_of(v));
let load_factor: util::rational = {num: 3, den: 4};
tag bucket[@K, @V] { nil; deleted; some(K, V); }
- fn make_buckets[@K, @V](nbkts: uint) -> (bucket[K, V])[mutable ] {
+ fn make_buckets[@K, @V](nbkts: uint) -> [mutable (bucket[K, V])] {
ret ivec::init_elt_mut[bucket[K, V]](nil[K, V], nbkts);
}
// Derive two hash functions from the one given by taking the upper
fn insert_common[@K,
@V](hasher: &hashfn[K], eqer: &eqfn[K],
- bkts: &(bucket[K, V])[mutable ], nbkts: uint,
+ bkts: &[mutable bucket[K, V]], nbkts: uint,
key: &K, val: &V) -> bool {
let i: uint = 0u;
let h: uint = hasher(key);
}
fn find_common[@K,
@V](hasher: &hashfn[K], eqer: &eqfn[K],
- bkts: &(bucket[K, V])[mutable ], nbkts: uint, key: &K)
+ bkts: &[mutable bucket[K, V]], nbkts: uint, key: &K)
-> option::t[V] {
let i: uint = 0u;
let h: uint = hasher(key);
}
fn rehash[@K,
@V](hasher: &hashfn[K], eqer: &eqfn[K],
- oldbkts: &(bucket[K, V])[mutable ], noldbkts: uint,
- newbkts: &(bucket[K, V])[mutable ], nnewbkts: uint) {
+ oldbkts: &[mutable bucket[K, V]], noldbkts: uint,
+ newbkts: &[mutable bucket[K, V]], nnewbkts: uint) {
for b: bucket[K, V] in oldbkts {
alt b {
some(k_, v_) {
obj hashmap[@K,
@V](hasher: hashfn[K],
eqer: eqfn[K],
- mutable bkts: (bucket[K, V])[mutable ],
+ mutable bkts: [mutable bucket[K, V]],
mutable nbkts: uint,
mutable nelts: uint,
lf: util::rational) {
native "rust" mod rustrt {
fn rust_list_files(path: str) -> vec[str];
- fn rust_list_files_ivec(path: str) -> @str[];
+ fn rust_list_files_ivec(path: str) -> @[str];
fn rust_dirent_filename(ent: os::libc::dirent) -> str;
}
-fn list_dir(path: str) -> str[] {
+fn list_dir(path: str) -> [str] {
ret *rustrt::rust_list_files_ivec(path);
// TODO ensure this is always closed
// automatically during construction
obj {
fn input(&vec[u8]) ;
- fn input_ivec(&u8[]) ;
+ fn input_ivec(&[u8]) ;
fn input_str(&str) ;
fn result() -> vec[u8] ;
- fn result_ivec() -> u8[] ;
+ fn result_ivec() -> [u8] ;
fn result_str() -> str ;
fn reset() ;
};
// Builds a sha1 object
fn mk_sha1() -> sha1 {
type sha1state =
- {h: u32[mutable ],
+ {h: [mutable u32],
mutable len_low: u32,
mutable len_high: u32,
- msg_block: u8[mutable ],
+ msg_block: [mutable u8],
mutable msg_block_idx: uint,
mutable computed: bool,
- work_buf: u32[mutable ]};
+ work_buf: [mutable u32]};
- fn add_input(st: &sha1state, msg: &u8[]) {
+ fn add_input(st: &sha1state, msg: &[u8]) {
// FIXME: Should be typestate precondition
assert (!st.computed);
fn circular_shift(bits: u32, word: u32) -> u32 {
ret word << bits | word >> 32u32 - bits;
}
- fn mk_result(st: &sha1state) -> u8[] {
+ fn mk_result(st: &sha1state) -> [u8] {
if !st.computed { pad_msg(st); st.computed = true; }
- let rs: u8[] = ~[];
+ let rs: [u8] = ~[];
for hpart: u32 in st.h {
let a = hpart >> 24u32 & 0xFFu32 as u8;
let b = hpart >> 16u32 & 0xFFu32 as u8;
for b: u8 in msg { m += ~[b]; }
add_input(st, m);
}
- fn input_ivec(msg: &u8[]) { add_input(st, msg); }
+ fn input_ivec(msg: &[u8]) { add_input(st, msg); }
fn input_str(msg: &str) { add_input(st, str::bytes_ivec(msg)); }
fn result() -> vec[u8] {
let rivec = mk_result(st);
for b: u8 in rivec { rvec += [b]; }
ret rvec;
}
- fn result_ivec() -> u8[] { ret mk_result(st); }
+ fn result_ivec() -> [u8] { ret mk_result(st); }
fn result_str() -> str {
let r = mk_result(st);
let s = "";
ret make_socket(ctx, p);
}
-fn read(c: client) -> u8[] {
+fn read(c: client) -> [u8] {
let evt: aio::socket_event;
c.evt |> evt;
alt evt {
}
}
-fn write_data(c: client, data: u8[]) -> bool {
+fn write_data(c: client, data: [u8]) -> bool {
let p: port[bool] = port();
c.ctx <| aio::write(c.client, data, chan(p));
let success: bool;
// FIXME: Should not be @; there's a bug somewhere in rustc that requires this
// to be.
-type smallintmap[T] = @{mutable v: (option::t[T])[mutable ]};
+type smallintmap[T] = @{mutable v: [mutable option::t[T]]};
fn mk[@T]() -> smallintmap[T] {
- let v: (option::t[T])[mutable ] = ~[mutable ];
+ let v: [mutable option::t[T]] = ~[mutable];
ret @{mutable v: v};
}
type lteq[T] = fn(&T, &T) -> bool ;
- fn merge_sort[@T](le: lteq[T], v: &T[]) -> T[] {
- fn merge[@T](le: lteq[T], a: &T[], b: &T[]) -> T[] {
- let rs: T[] = ~[];
+ fn merge_sort[@T](le: lteq[T], v: &[T]) -> [T] {
+ fn merge[@T](le: lteq[T], a: &[T], b: &[T]) -> [T] {
+ let rs: [T] = ~[];
let a_len: uint = ilen[T](a);
let a_ix: uint = 0u;
let b_len: uint = ilen[T](b);
let v_len: uint = ilen[T](v);
if v_len <= 1u { ret v; }
let mid: uint = v_len / 2u;
- let a: T[] = islice[T](v, 0u, mid);
- let b: T[] = islice[T](v, mid, v_len);
+ let a: [T] = islice[T](v, 0u, mid);
+ let b: [T] = islice[T](v, mid, v_len);
ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
}
- fn swap[@T](arr: &T[mutable ], x: uint, y: uint) {
+ fn swap[@T](arr: &[mutable T], x: uint, y: uint) {
let a = arr.(x);
arr.(x) = arr.(y);
arr.(y) = a;
}
- fn part[@T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
+ fn part[@T](compare_func: lteq[T], arr: &[mutable T], left: uint,
right: uint, pivot: uint) -> uint {
let pivot_value = arr.(pivot);
swap[T](arr, pivot, right);
ret storage_index;
}
- fn qsort[@T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
+ fn qsort[@T](compare_func: lteq[T], arr: &[mutable T], left: uint,
right: uint) {
if right > left {
let pivot = (left + right) / 2u;
}
}
- fn quick_sort[@T](compare_func: lteq[T], arr: &T[mutable ]) {
+ fn quick_sort[@T](compare_func: lteq[T], arr: &[mutable T]) {
if ilen[T](arr) == 0u { ret; }
qsort[T](compare_func, arr, 0u, ilen[T](arr) - 1u);
}
// 'randomly ordered keys, abstract compare' & 'small number of key
// values'
fn qsort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
- arr: &T[mutable ], left: int, right: int) {
+ arr: &[mutable T], left: int, right: int) {
if right <= left { ret; }
let v: T = arr.(right);
let i: int = left - 1;
}
fn quick_sort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
- arr: &T[mutable ]) {
+ arr: &[mutable T]) {
if ilen[T](arr) == 0u { ret; }
qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
(ilen[T](arr) as int) - 1);
fn str_vec(s: str) -> vec[u8];
fn str_byte_len(s: str) -> uint;
fn str_alloc(n_bytes: uint) -> str;
- fn str_from_ivec(b: &u8[mutable? ]) -> str;
+ fn str_from_ivec(b: &[mutable? u8]) -> str;
fn str_from_vec(b: vec[mutable? u8]) -> str;
fn str_from_cstr(cstr: sbuf) -> str;
fn str_from_buf(buf: sbuf, len: uint) -> str;
fn bytes(s: &str) -> vec[u8] { ret rustrt::str_vec(s); }
-fn bytes_ivec(s: str) -> u8[] {
+fn bytes_ivec(s: str) -> [u8] {
let sbuffer = buf(s);
let ptr = unsafe::reinterpret_cast(sbuffer);
ret ivec::unsafe::from_buf(ptr, byte_len(s));
ret rustrt::str_from_vec(v);
}
-fn unsafe_from_bytes_ivec(v: &u8[mutable? ]) -> str {
+fn unsafe_from_bytes_ivec(v: &[mutable? u8]) -> str {
ret rustrt::str_from_ivec(v);
}
ret v;
}
-fn split_ivec(s: str, sep: u8) -> str[] {
- let v: str[] = ~[];
+fn split_ivec(s: str, sep: u8) -> [str] {
+ let v: [str] = ~[];
let accum: str = "";
let ends_with_sep: bool = false;
for c: u8 in s {
ret s;
}
-fn connect_ivec(v: &str[], sep: str) -> str {
+fn connect_ivec(v: &[str], sep: str) -> str {
let s: str = "";
let first: bool = true;
for ss: str in v {
// The default console test runner. It accepts the command line
// arguments and a vector of test_descs (generated at compile time).
-fn test_main(args: &vec[str], tests: &test_desc[]) {
+fn test_main(args: &vec[str], tests: &[test_desc]) {
let ivec_args =
{ let iargs = ~[]; for arg: str in args { iargs += ~[arg] } iargs };
check (ivec::is_not_empty(ivec_args));
type opt_res = either::t[test_opts, str];
// Parses command line arguments into test options
-fn parse_opts(args: &str[]) : ivec::is_not_empty(args) -> opt_res {
+fn parse_opts(args: &[str]) : ivec::is_not_empty(args) -> opt_res {
// FIXME (#649): Shouldn't have to check here
check (ivec::is_not_empty(args));
type test_to_task = fn(&fn()) -> task ;
// A simple console test runner
-fn run_tests_console(opts: &test_opts, tests: &test_desc[]) -> bool {
+fn run_tests_console(opts: &test_opts, tests: &[test_desc]) -> bool {
run_tests_console_(opts, tests, default_test_to_task)
}
-fn run_tests_console_(opts: &test_opts, tests: &test_desc[],
+fn run_tests_console_(opts: &test_opts, tests: &[test_desc],
to_task: &test_to_task) -> bool {
type test_state = @{
mutable passed: uint,
mutable failed: uint,
mutable ignored: uint,
- mutable failures: test_desc[]
+ mutable failures: [test_desc]
};
fn callback(event: testevent, st: test_state) {
}
tag testevent {
- te_filtered(test_desc[]);
+ te_filtered([test_desc]);
te_wait(test_desc);
te_result(test_desc, test_result);
}
-fn run_tests(opts: &test_opts, tests: &test_desc[],
+fn run_tests(opts: &test_opts, tests: &[test_desc],
to_task: &test_to_task, callback: fn(testevent)) {
let filtered_tests = filter_tests(opts, tests);
fn get_concurrency() -> uint { rustrt::sched_threads() }
-fn filter_tests(opts: &test_opts, tests: &test_desc[]) -> test_desc[] {
+fn filter_tests(opts: &test_opts, tests: &[test_desc]) -> [test_desc] {
let filtered = tests;
// Remove tests that don't match the test filter
type ufind = {mutable nodes: vec[mutable node]};
-fn make() -> ufind { ret {mutable nodes: [mutable ]}; }
+fn make() -> ufind { ret {mutable nodes: [mutable]}; }
fn make_set(ufnd: &ufind) -> uint {
let idx = vec::len(ufnd.nodes);
// than the node itself.
type node = option::t[uint];
-type ufind = {mutable nodes: node[mutable ]};
+type ufind = {mutable nodes: [mutable node]};
-fn make() -> ufind { ret {mutable nodes: ~[mutable ]}; }
+fn make() -> ufind { ret {mutable nodes: ~[mutable]}; }
fn make_set(ufnd: &ufind) -> uint {
let idx = ivec::len(ufnd.nodes);
native "rust" mod rustrt {
fn rust_list_files(path: str) -> vec[str];
- fn rust_list_files_ivec(path: str) -> @str[];
+ fn rust_list_files_ivec(path: str) -> @[str];
fn rust_file_is_dir(path: str) -> int;
}
-fn list_dir(path: str) -> str[] {
+fn list_dir(path: str) -> [str] {
ret *rustrt::rust_list_files_ivec(path + "*");
}
projects / rust.git / commitdiff