---

yaml
---
r: 4738
b: refs/heads/master
c: 4c9049c
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 21f46a1655f2a026546792546b07dec9e039ec54
+refs/heads/master: 4c9049c50c5c32f556eaefbcc50209ef8ee353d0

trunk/src/lib/box.rs

@@ -1,8 +1,8 @@
 
 export ptr_eq;
 
-fn ptr_eq[T](a: &@T, b: &@T) -> bool {
+fn ptr_eq<T>(a: &@T, b: &@T) -> bool {
     let a_ptr: uint = unsafe::reinterpret_cast(a);
     let b_ptr: uint = unsafe::reinterpret_cast(b);
     ret a_ptr == b_ptr;
-}
+}

trunk/src/lib/comm.rs

@@ -20,7 +20,7 @@ native "rust" mod rustrt {
     fn take_chan(ch : *rust_chan);
     fn drop_chan(ch : *rust_chan);
     fn chan_send(ch: *rust_chan, v : *void);
-    fn chan_id_send[~T](target_task : task_id, target_port : port_id,
+    fn chan_id_send<~T>(target_task : task_id, target_port : port_id,
                         data : -T);
 
     fn new_port(unit_sz : uint) -> *rust_port;
@@ -30,12 +30,12 @@ native "rust" mod rustrt {
 }
 
 native "rust-intrinsic" mod rusti {
-    fn recv[~T](port : *rustrt::rust_port) -> T;
+    fn recv<~T>(port : *rustrt::rust_port) -> T;
 }
 
 type port_id = int;
 
-type _chan[~T] = {
+type _chan<~T> = {
     task : task_id,
     port : port_id
 };
@@ -45,9 +45,9 @@ resource port_ptr(po: *rustrt::rust_port) {
     rustrt::del_port(po);
 }
 
-obj _port[~T](raw_port : @port_ptr) {
+obj _port<~T>(raw_port : @port_ptr) {
     // FIXME: rename this to chan once chan is not a keyword.
-    fn mk_chan() -> _chan[T] {
+    fn mk_chan() -> _chan<T> {
         {
             task: task::get_task_id(),
             port: rustrt::get_port_id(**raw_port)
@@ -59,10 +59,10 @@ 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]())))
 }
 
-fn send[~T](ch : _chan[T], data : -T) {
+fn send<~T>(ch : _chan<T>, data : -T) {
     rustrt::chan_id_send(ch.task, ch.port, data);
 }

trunk/src/lib/dbg.rs

@@ -12,23 +12,23 @@
 const const_refcount: uint = 0x7bad_face_u;
 
 native "rust" mod rustrt {
-    fn debug_tydesc[T]();
-    fn debug_opaque[T](x: &T);
-    fn debug_box[T](x: @T);
-    fn debug_tag[T](x: &T);
-    fn debug_obj[T](x: &T, nmethods: uint, nbytes: uint);
-    fn debug_fn[T](x: &T);
-    fn debug_ptrcast[T, U](x: @T) -> @U;
+    fn debug_tydesc<T>();
+    fn debug_opaque<T>(x: &T);
+    fn debug_box<T>(x: @T);
+    fn debug_tag<T>(x: &T);
+    fn debug_obj<T>(x: &T, nmethods: uint, nbytes: uint);
+    fn debug_fn<T>(x: &T);
+    fn debug_ptrcast<T, U>(x: @T) -> @U;
     fn debug_trap(msg: str);
 }
 
 fn debug_tydesc[T]() { rustrt::debug_tydesc[T](); }
 
-fn debug_opaque[T](x: &T) { rustrt::debug_opaque[T](x); }
+fn debug_opaque<T>(x: &T) { rustrt::debug_opaque[T](x); }
 
-fn debug_box[T](x: @T) { rustrt::debug_box[T](x); }
+fn debug_box<T>(x: @T) { rustrt::debug_box[T](x); }
 
-fn debug_tag[T](x: &T) { rustrt::debug_tag[T](x); }
+fn debug_tag<T>(x: &T) { rustrt::debug_tag[T](x); }
 
 
 /**
@@ -40,13 +40,13 @@ fn debug_tag[T](x: &T) { rustrt::debug_tag[T](x); }
  * this to at least be 4u, since an implicit captured tydesc pointer sits in
  * the front of any obj's data tuple.x
  */
-fn debug_obj[T](x: &T, nmethods: uint, nbytes: uint) {
+fn debug_obj<T>(x: &T, nmethods: uint, nbytes: uint) {
     rustrt::debug_obj[T](x, nmethods, nbytes);
 }
 
-fn debug_fn[T](x: &T) { rustrt::debug_fn[T](x); }
+fn debug_fn<T>(x: &T) { rustrt::debug_fn[T](x); }
 
-fn ptr_cast[T, U](x: @T) -> @U { ret rustrt::debug_ptrcast[T, U](x); }
+fn ptr_cast<T, U>(x: @T) -> @U { ret rustrt::debug_ptrcast[T, U](x); }
 
 fn trap(s: str) { rustrt::debug_trap(s); }
 // Local Variables:

trunk/src/lib/deque.rs

@@ -4,7 +4,7 @@
 /**
  * A deque, for fun.  Untested as of yet.  Likely buggy.
  */
-type t[T] =
+type t<T> =
     obj {
         fn size() -> uint ;
         fn add_front(&T) ;
@@ -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,7 +26,7 @@ fn create[@T]() -> t<T> {
       */
 
 
-    fn grow[@T](nelts: uint, lo: uint, elts: &[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,10 +42,10 @@ 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,
+    obj deque<@T>(mutable nelts: uint,
                   mutable lo: uint,
                   mutable hi: uint,
                   mutable elts: [mutable cell<T>]) {

trunk/src/lib/either.rs

@@ -3,30 +3,30 @@ import option;
 import option::some;
 import option::none;
 
-tag t[T, U] { left(T); right(U); }
+tag t<T, U> { left(T); right(U); }
 
-fn either[T, U, V](f_left: &block(&T) -> V, f_right: &block(&U) -> V,
+fn either<T, U, V>(f_left: &block(&T) -> V, f_right: &block(&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 {
         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 {
         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 {

trunk/src/lib/list.rs

@@ -1,9 +1,9 @@
 import option::some;
 import option::none;
 
-tag list[T] { cons(T, @list<T>); nil; }
+tag list<T> { cons(T, @list<T>); nil; }
 
-fn from_vec[@T](v: &[T]) -> list<T> {
+fn from_vec<@T>(v: &[T]) -> list<T> {
     let l = nil[T];
     // FIXME: This would be faster and more space efficient if it looped over
     // a reverse vector iterator. Unfortunately generic iterators seem not to
@@ -13,7 +13,7 @@ fn from_vec[@T](v: &[T]) -> list<T> {
     ret l;
 }
 
-fn foldl[@T, @U](ls_: &list<T>, u: &U, f: &block(&T, &U) -> U ) -> U {
+fn foldl<@T, @U>(ls_: &list<T>, u: &U, f: &block(&T, &U) -> U ) -> U {
     let accum: U = u;
     let ls = ls_;
     while true {
@@ -25,7 +25,7 @@ fn foldl[@T, @U](ls_: &list<T>, u: &U, f: &block(&T, &U) -> U ) -> U {
     ret accum;
 }
 
-fn find[@T, @U](ls_: &list<T>, f: &block(&T) -> option::t<U>)
+fn find<@T, @U>(ls_: &list<T>, f: &block(&T) -> option::t<U>)
     -> option::t<U> {
     let ls = ls_;
     while true {
@@ -39,7 +39,7 @@ fn find[@T, @U](ls_: &list<T>, f: &block(&T) -> option::t<U>)
     ret none;
 }
 
-fn has[@T](ls_: &list<T>, elt: &T) -> bool {
+fn has<@T>(ls_: &list<T>, elt: &T) -> bool {
     let ls = ls_;
     while true {
         alt ls {
@@ -50,26 +50,26 @@ fn has[@T](ls_: &list<T>, elt: &T) -> bool {
     ret false;
 }
 
-fn length[@T](ls: &list<T>) -> uint {
-    fn count[T](t: &T, u: &uint) -> uint { ret u + 1u; }
+fn length<@T>(ls: &list<T>) -> uint {
+    fn count<T>(t: &T, u: &uint) -> uint { ret u + 1u; }
     ret foldl(ls, 0u, count);
 }
 
-fn cdr[@T](ls: &list<T>) -> list<T> {
+fn cdr<@T>(ls: &list<T>) -> list<T> {
     alt ls {
       cons(_, tl) { ret *tl; }
       nil. { fail "list empty" }
     }
 }
 
-fn car[@T](ls: &list<T>) -> T {
+fn car<@T>(ls: &list<T>) -> T {
     alt ls {
       cons(hd, _) { ret hd; }
       nil. { fail "list empty" }
     }
 }
 
-fn append[@T](l: &list<T>, m: &list<T>) -> list<T> {
+fn append<@T>(l: &list<T>, m: &list<T>) -> list<T> {
     alt l {
       nil. { ret m; }
       cons(x, xs) {

trunk/src/lib/map.rs

@@ -1,11 +1,11 @@
 /**
  * Hashmap implementation.
  */
-type hashfn[K] = fn(&K) -> uint ;
+type hashfn<K> = fn(&K) -> uint ;
 
-type eqfn[K] = fn(&K, &K) -> bool ;
+type eqfn<K> = fn(&K, &K) -> bool ;
 
-type hashmap[K, V] =
+type hashmap<K, V> =
     obj {
         fn size() -> uint ;
         fn insert(&K, &V) -> bool ;
@@ -17,16 +17,16 @@ type hashmap[K, V] =
         iter items() -> @{key: K, val: V} ;
         iter keys() -> K ;
     };
-type hashset[K] = hashmap<K, ()>;
+type hashset<K> = hashmap<K, ()>;
 
-fn set_add[@K](set: hashset<K>, key: &K) -> bool { ret set.insert(key, ()); }
+fn set_add<@K>(set: hashset<K>, key: &K) -> bool { ret set.insert(key, ()); }
 
-fn mk_hashmap[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
+fn mk_hashmap<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
     let initial_capacity: uint = 32u; // 2^5
 
     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) -> [mutable (bucket<K, V>)] {
+    tag bucket<@K, @V> { nil; deleted; some(K, V); }
+    fn make_buckets<@K, @V>(nbkts: uint) -> [mutable (bucket<K, V>)] {
         ret vec::init_elt_mut[bucket<K, V>](nil[K, V], nbkts);
     }
     // Derive two hash functions from the one given by taking the upper
@@ -53,7 +53,7 @@ fn mk_hashmap[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
      * will fail.
      */
 
-    fn insert_common[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>,
+    fn insert_common<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>,
                              bkts: &[mutable bucket<K, V>], nbkts: uint,
                              key: &K, val: &V) -> bool {
         let i: uint = 0u;
@@ -76,7 +76,7 @@ fn mk_hashmap[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
         }
         fail; // full table
     }
-    fn find_common[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>,
+    fn find_common<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>,
                            bkts: &[mutable bucket<K, V>], nbkts: uint,
                            key: &K) -> option::t<V> {
         let i: uint = 0u;
@@ -97,7 +97,7 @@ fn mk_hashmap[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
         }
         ret option::none;
     }
-    fn rehash[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>,
+    fn rehash<@K, @V>(hasher: &hashfn<K>, eqer: &eqfn<K>,
                       oldbkts: &[mutable bucket<K, V>], noldbkts: uint,
                       newbkts: &[mutable bucket<K, V>], nnewbkts: uint) {
         for b: bucket<K, V> in oldbkts {
@@ -111,7 +111,7 @@ fn mk_hashmap[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
             }
         }
     }
-    obj hashmap[@K, @V](hasher: hashfn<K>,
+    obj hashmap<@K, @V>(hasher: hashfn<K>,
                         eqer: eqfn<K>,
                         mutable bkts: [mutable bucket<K, V>],
                         mutable nbkts: uint,
@@ -193,17 +193,17 @@ fn mk_hashmap[@K, @V](hasher: &hashfn<K>, eqer: &eqfn<K>) -> hashmap<K, V> {
 
 // Hash map constructors for basic types
 
-fn new_str_hash[@V]() -> hashmap<str, V> {
+fn new_str_hash<@V>() -> hashmap<str, V> {
     ret mk_hashmap(str::hash, str::eq);
 }
 
-fn new_int_hash[@V]() -> hashmap<int, V> {
+fn new_int_hash<@V>() -> hashmap<int, V> {
     fn hash_int(x: &int) -> uint { ret x as uint; }
     fn eq_int(a: &int, b: &int) -> bool { ret a == b; }
     ret mk_hashmap(hash_int, eq_int);
 }
 
-fn new_uint_hash[@V]() -> hashmap<uint, V> {
+fn new_uint_hash<@V>() -> hashmap<uint, V> {
     fn hash_uint(x: &uint) -> uint { ret x; }
     fn eq_uint(a: &uint, b: &uint) -> bool { ret a == b; }
     ret mk_hashmap(hash_uint, eq_uint);