Convert impls to new syntax

Author: brson

src/compiletest/errors.rs

@@ -1,5 +1,3 @@
-import io::reader_util;
-
 import common::config;
 
 export load_errors;

src/compiletest/header.rs

@@ -1,6 +1,5 @@
 import option;
 import str;
-import io::reader_util;
 
 import common::config;
 

src/compiletest/procsrv.rs

@@ -1,5 +1,5 @@
 import run::spawn_process;
-import io::{writer_util, reader_util};
+import io::writer_util;
 import libc::{c_int, pid_t};
 
 import pipes::chan;

src/libcore/arc.rs

@@ -3,8 +3,6 @@
  * share immutable data between tasks.
  */
 
-import sys::methods;
-
 export arc, get, clone;
 
 export exclusive, methods;
@@ -96,7 +94,7 @@ fn exclusive<T:send >(-data: T) -> exclusive<T> {
     }
 }
 
-impl methods<T: send> for exclusive<T> {
+impl<T: send> exclusive<T> {
     /// Duplicate an exclusive ARC. See arc::clone.
     fn clone() -> exclusive<T> {
         unsafe {
@@ -142,7 +140,6 @@ impl methods<T: send> for exclusive<T> {
 #[cfg(test)]
 mod tests {
     import comm::*;
-    import future::extensions;
 
     #[test]
     fn manually_share_arc() {

src/libcore/at_vec.rs

@@ -123,15 +123,15 @@ pure fn from_elem<T: copy>(n_elts: uint, t: T) -> @[T] {
     }
 }
 
-impl extensions<T: copy> of vec_concat<T> for @[T] {
+impl<T: copy> @[T]: vec_concat<T> {
     #[inline(always)]
     pure fn +(rhs: &[const T]) -> @[T] {
         append(self, rhs)
     }
 }
 
 #[cfg(notest)]
-impl extensions<T: copy> of add<&[const T],@[T]> for @[T] {
+impl<T: copy> @[T]: add<&[const T],@[T]> {
     #[inline(always)]
     pure fn add(rhs: &[const T]) -> @[T] {
         append(self, rhs)

src/libcore/comm.rs

@@ -70,7 +70,7 @@ fn port<T: send>() -> port<T> {
     port_t(@port_ptr(rustrt::new_port(sys::size_of::<T>() as size_t)))
 }
 
-impl methods<T: send> for port<T> {
+impl<T: send> port<T> {
 
     fn chan() -> chan<T> { chan(self) }
     fn send(+v: T) { self.chan().send(v) }
@@ -79,7 +79,7 @@ impl methods<T: send> for port<T> {
 
 }
 
-impl methods<T: send> for chan<T> {
+impl<T: send> chan<T> {
 
     fn chan() -> chan<T> { self }
     fn send(+v: T) { send(self, v) }

src/libcore/core.rs

@@ -5,31 +5,13 @@
 import option::{some, none};
 import option = option::option;
 import path = path::path;
-import tuple::{extensions, tuple_ops, extended_tuple_ops};
-import str::{extensions, str_slice, unique_str};
-import vec::extensions;
+import tuple::{tuple_ops, extended_tuple_ops};
+import str::{str_slice, unique_str};
 import vec::{const_vector, copyable_vector, immutable_vector};
 import vec::{immutable_copyable_vector, iter_trait_extensions, vec_concat};
 import iter::{base_iter, extended_iter, copyable_iter, times, timesi};
-import option::extensions;
-import option_iter::extensions;
-import ptr::{extensions, ptr};
-import rand::extensions;
-import result::extensions;
-import int::{num, times, timesi};
-import i8::{num, times, timesi};
-import i16::{num, times, timesi};
-import i32::{num, times, timesi};
-import i64::{num, times, timesi};
-import uint::{num, times, timesi};
-import u8::{num, times, timesi};
-import u16::{num, times, timesi};
-import u32::{num, times, timesi};
-import u64::{num, times, timesi};
-import float::num;
-import f32::num;
-import f64::num;
 import num::num;
+import ptr::ptr;
 
 export path, option, some, none, unreachable;
 export extensions;

src/libcore/dlist.rs

@@ -4,8 +4,6 @@
  * Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
  */
 
-import dlist_iter::extensions;
-
 export dlist, dlist_node;
 export new_dlist, from_elem, from_vec, extensions;
 
@@ -24,7 +22,7 @@ enum dlist<T> = @{
     mut tl:   dlist_link<T>,
 };
 
-impl private_methods<T> for dlist_node<T> {
+priv impl<T> dlist_node<T> {
     pure fn assert_links() {
         match self.next {
             some(neighbour) => match neighbour.prev {
@@ -47,7 +45,7 @@ impl private_methods<T> for dlist_node<T> {
     }
 }
 
-impl extensions<T> for dlist_node<T> {
+impl<T> dlist_node<T> {
     /// Get the next node in the list, if there is one.
     pure fn next_link() -> option<dlist_node<T>> {
         self.assert_links();
@@ -109,7 +107,7 @@ fn concat<T>(lists: dlist<dlist<T>>) -> dlist<T> {
     result
 }
 
-impl private_methods<T> for dlist<T> {
+priv impl<T> dlist<T> {
     pure fn new_link(-data: T) -> dlist_link<T> {
         some(dlist_node(@{data: data, mut linked: true,
                           mut prev: none, mut next: none}))
@@ -184,7 +182,7 @@ impl private_methods<T> for dlist<T> {
     }
 }
 
-impl extensions<T> for dlist<T> {
+impl<T> dlist<T> {
     /// Get the size of the list. O(1).
     pure fn len()          -> uint { self.size }
     /// Returns true if the list is empty. O(1).
@@ -413,7 +411,7 @@ impl extensions<T> for dlist<T> {
     }
 }
 
-impl extensions<T: copy> for dlist<T> {
+impl<T: copy> dlist<T> {
     /// Remove data from the head of the list. O(1).
     fn pop()       -> option<T> { self.pop_n().map       (|nobe| nobe.data) }
     /// Remove data from the tail of the list. O(1).

src/libcore/dvec.rs

@@ -5,9 +5,8 @@
 //
 // Note that recursive use is not permitted.
 
-import dvec_iter::extensions;
 import unsafe::reinterpret_cast;
-import ptr::{null, extensions};
+import ptr::null;
 
 export dvec;
 export from_elem;
@@ -75,7 +74,7 @@ fn unwrap<A>(-d: dvec<A>) -> ~[mut A] {
     return v;
 }
 
-impl private_methods<A> for dvec<A> {
+priv impl<A> dvec<A> {
     pure fn check_not_borrowed() {
         unsafe {
             let data: *() = unsafe::reinterpret_cast(self.data);
@@ -107,7 +106,7 @@ impl private_methods<A> for dvec<A> {
 // In theory, most everything should work with any A, but in practice
 // almost nothing works without the copy bound due to limitations
 // around closures.
-impl extensions<A> for dvec<A> {
+impl<A> dvec<A> {
     /// Reserves space for N elements
     fn reserve(count: uint) {
         vec::reserve(self.data, count)
@@ -188,7 +187,7 @@ impl extensions<A> for dvec<A> {
     }
 }
 
-impl extensions<A:copy> for dvec<A> {
+impl<A: copy> dvec<A> {
     /**
      * Append all elements of a vector to the end of the list
      *
@@ -311,7 +310,7 @@ impl extensions<A:copy> for dvec<A> {
     }
 }
 
-impl extensions<A:copy> of index<uint,A> for dvec<A> {
+impl<A:copy> dvec<A>: index<uint,A> {
     pure fn index(&&idx: uint) -> A {
         self.get_elt(idx)
     }

src/libcore/f32.rs

@@ -167,7 +167,7 @@ pure fn log2(n: f32) -> f32 {
     return ln(n) / consts::ln_2;
 }
 
-impl num of num::num for f32 {
+impl f32: num::num {
     pure fn add(&&other: f32)    -> f32 { return self + other; }
     pure fn sub(&&other: f32)    -> f32 { return self - other; }
     pure fn mul(&&other: f32)    -> f32 { return self * other; }

src/libcore/f64.rs

@@ -194,7 +194,7 @@ pure fn log2(n: f64) -> f64 {
     return ln(n) / consts::ln_2;
 }
 
-impl num of num::num for f64 {
+impl f64: num::num {
     pure fn add(&&other: f64)    -> f64 { return self + other; }
     pure fn sub(&&other: f64)    -> f64 { return self - other; }
     pure fn mul(&&other: f64)    -> f64 { return self * other; }

src/libcore/float.rs

@@ -409,7 +409,7 @@ pure fn sin(x: float) -> float { f64::sin(x as f64) as float }
 pure fn cos(x: float) -> float { f64::cos(x as f64) as float }
 pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
 
-impl num of num::num for float {
+impl float: num::num {
     pure fn add(&&other: float)    -> float { return self + other; }
     pure fn sub(&&other: float)    -> float { return self - other; }
     pure fn mul(&&other: float)    -> float { return self * other; }

src/libcore/future.rs

@@ -32,7 +32,7 @@ enum future<A> = {
 };
 
 /// Methods on the `future` type
-impl extensions<A:copy send> for future<A> {
+impl<A:copy send> future<A> {
 
     fn get() -> A {
         //! Get the value of the future

src/libcore/int-template.rs

@@ -62,20 +62,20 @@ pure fn abs(i: T) -> T {
     if is_negative(i) { -i } else { i }
 }
 
-impl ord of ord for T {
+impl T: ord {
     pure fn lt(&&other: T) -> bool {
         return self < other;
     }
 }
 
-impl eq of eq for T {
+impl T: eq {
     pure fn eq(&&other: T) -> bool {
         return self == other;
     }
 }
 
 
-impl num of num::num for T {
+impl T: num::num {
     pure fn add(&&other: T)    -> T { return self + other; }
     pure fn sub(&&other: T)    -> T { return self - other; }
     pure fn mul(&&other: T)    -> T { return self * other; }
@@ -87,7 +87,7 @@ impl num of num::num for T {
     pure fn from_int(n: int) -> T   { return n as T;      }
 }
 
-impl times of iter::times for T {
+impl T: iter::times {
     #[inline(always)]
     #[doc = "A convenience form for basic iteration. Given a variable `x` \
         of any numeric type, the expression `for x.times { /* anything */ }` \
@@ -107,7 +107,7 @@ impl times of iter::times for T {
     }
 }
 
-impl timesi of iter::timesi for T {
+impl T: iter::timesi {
     #[inline(always)]
     /// Like `times`, but provides an index
     fn timesi(it: fn(uint) -> bool) {

src/libcore/io.rs

@@ -6,7 +6,7 @@ Basic input/output
 
 import result::result;
 
-import dvec::{dvec, extensions};
+import dvec::dvec;
 import libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t};
 import libc::consts::os::posix88::*;
 import libc::consts::os::extra::*;
@@ -42,7 +42,7 @@ trait reader {
 
 // Generic utility functions defined on readers
 
-impl reader_util for reader {
+impl reader {
     fn read_bytes(len: uint) -> ~[u8] {
         let mut buf = ~[mut];
         vec::reserve(buf, len);
@@ -203,7 +203,7 @@ fn convert_whence(whence: seek_style) -> i32 {
     };
 }
 
-impl of reader for *libc::FILE {
+impl *libc::FILE: reader {
     fn read(buf: &[mut u8], len: uint) -> uint {
         do vec::as_buf(buf) |buf_p, buf_len| {
             assert buf_len <= len;
@@ -227,7 +227,7 @@ impl of reader for *libc::FILE {
 // A forwarding impl of reader that also holds on to a resource for the
 // duration of its lifetime.
 // FIXME there really should be a better way to do this // #2004
-impl <T: reader, C> of reader for {base: T, cleanup: C} {
+impl<T: reader, C> {base: T, cleanup: C}: reader {
     fn read(buf: &[mut u8], len: uint) -> uint { self.base.read(buf, len) }
     fn read_byte() -> int { self.base.read_byte() }
     fn unread_byte(byte: int) { self.base.unread_byte(byte); }
@@ -273,7 +273,7 @@ fn file_reader(path: ~str) -> result<reader, ~str> {
 
 type byte_buf = {buf: ~[const u8], mut pos: uint, len: uint};
 
-impl of reader for byte_buf {
+impl byte_buf: reader {
     fn read(buf: &[mut u8], len: uint) -> uint {
         let count = uint::min(len, self.len - self.pos);
 
@@ -343,15 +343,15 @@ trait writer {
     fn get_type() -> writer_type;
 }
 
-impl <T: writer, C> of writer for {base: T, cleanup: C} {
+impl<T: writer, C> {base: T, cleanup: C}: writer {
     fn write(bs: &[const u8]) { self.base.write(bs); }
     fn seek(off: int, style: seek_style) { self.base.seek(off, style); }
     fn tell() -> uint { self.base.tell() }
     fn flush() -> int { self.base.flush() }
     fn get_type() -> writer_type { file }
 }
 
-impl of writer for *libc::FILE {
+impl *libc::FILE: writer {
     fn write(v: &[const u8]) {
         do vec::as_const_buf(v) |vbuf, len| {
             let nout = libc::fwrite(vbuf as *c_void, len as size_t,
@@ -384,7 +384,7 @@ fn FILE_writer(f: *libc::FILE, cleanup: bool) -> writer {
     }
 }
 
-impl of writer for fd_t {
+impl fd_t: writer {
     fn write(v: &[const u8]) {
         let mut count = 0u;
         do vec::as_const_buf(v) |vbuf, len| {
@@ -658,7 +658,7 @@ fn println(s: &str) { stdout().write_line(s); }
 
 type mem_buffer = @{buf: dvec<u8>, mut pos: uint};
 
-impl of writer for mem_buffer {
+impl mem_buffer: writer {
     fn write(v: &[const u8]) {
         // Fast path.
         let vlen = vec::len(v);