From f3c05b9faec1f2801b3c1987afb7c4059e175007 Mon Sep 17 00:00:00 2001
From: Graydon Hoare <graydon@mozilla.com>
Date: Fri, 29 Jul 2011 12:58:52 -0700
Subject: [PATCH] Turn on kind propagation for typarams. Annotate a bunch of
 typarams in rustc and libstd.

---
 src/comp/metadata/tydecode.rs |  2 +-
 src/comp/middle/ty.rs         |  5 +--
 src/lib/deque.rs              | 14 ++++----
 src/lib/ivec.rs               |  2 +-
 src/lib/list.rs               | 14 ++++----
 src/lib/map.rs                | 46 ++++++++++++-------------
 src/lib/sort.rs               | 30 ++++++++--------
 src/lib/vec.rs                | 65 ++++++++++++++++++-----------------
 src/test/run-pass/swap-2.rs   |  2 +-
 9 files changed, 89 insertions(+), 91 deletions(-)

diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 4c07648c3f5..a54b8622bb0 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/src/comp/metadata/tydecode.rs
@@ -150,7 +150,7 @@ fn parse_ty_constr_arg(st: @pstate, sd: str_def) ->
     }
 }
 
-fn parse_constr[T](st: @pstate, sd: str_def, pser: arg_parser[T]) ->
+fn parse_constr[@T](st: @pstate, sd: str_def, pser: arg_parser[T]) ->
    @ty::constr_general[T] {
     let sp = {lo: 0u, hi: 0u}; // FIXME: use a real span
     let args: (@sp_constr_arg[T])[] = ~[];
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 9e93c40b60c..37ca0632cab 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -1129,10 +1129,7 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
       ty_var(_) { fail; }
 
       ty_param(_,k) {
-        // FIXME: when you turn this on, the stdlib will break; be sure
-        // to have a snapshot done that understands kinds before doing so.
-
-        // result = kind::lower_kind(result, k);
+        result = kind::lower_kind(result, k);
       }
 
       ty_constr(t, _) {
diff --git a/src/lib/deque.rs b/src/lib/deque.rs
index 00ccde1f4b5..a501cfaf8f1 100644
--- a/src/lib/deque.rs
+++ b/src/lib/deque.rs
@@ -16,7 +16,7 @@ type t[T] =
         fn get(int) -> T ;
     };
 
-fn create[T]() -> 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: &(cell[T])[mutable ]) ->
+    fn grow[@T](nelts: uint, lo: uint, elts: &(cell[T])[mutable ]) ->
        (cell[T])[mutable ] {
         assert (nelts == ivec::len(elts));
         let rv = ~[mutable ];
@@ -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: &(cell[T])[mutable ], 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 ]) {
+    obj deque[@T](mutable nelts: uint,
+                  mutable lo: uint,
+                  mutable hi: uint,
+                  mutable elts: (cell[T])[mutable ]) {
         fn size() -> uint { ret nelts; }
         fn add_front(t: &T) {
             let oldlo: uint = lo;
diff --git a/src/lib/ivec.rs b/src/lib/ivec.rs
index dd13fcef7d2..eed4837d83f 100644
--- a/src/lib/ivec.rs
+++ b/src/lib/ivec.rs
@@ -168,7 +168,7 @@ fn grow_fn[T](v: &mutable T[], n: uint, init_fn: fn(uint) -> T ) {
 /// 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 T[mutable ], index: uint, initval: &T, val: &T) {
     if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); }
     v.(index) = val;
 }
diff --git a/src/lib/list.rs b/src/lib/list.rs
index ce10fccb588..cd38d0f6cd7 100644
--- a/src/lib/list.rs
+++ b/src/lib/list.rs
@@ -8,7 +8,7 @@ import option::none;
 // our recursion rules do not permit that.
 tag list[T] { cons(T, @list[T]); nil; }
 
-fn from_vec[T](v: vec[T]) -> list[T] {
+fn from_vec[@T](v: vec[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
@@ -18,7 +18,7 @@ fn from_vec[T](v: vec[T]) -> list[T] {
     ret l;
 }
 
-fn foldl[T, U](ls_: &list[T], u: &U, f: fn(&T, &U) -> U ) -> U {
+fn foldl[@T, @U](ls_: &list[T], u: &U, f: fn(&T, &U) -> U ) -> U {
     let accum: U = u;
     let ls = ls_;
     while true {
@@ -30,7 +30,7 @@ fn foldl[T, U](ls_: &list[T], u: &U, f: fn(&T, &U) -> U ) -> U {
     ret accum;
 }
 
-fn find[T, U](ls_: &list[T], f: fn(&T) -> option::t[U] ) -> option::t[U] {
+fn find[@T, @U](ls_: &list[T], f: fn(&T) -> option::t[U] ) -> option::t[U] {
     let ls = ls_;
     while true {
         alt ls {
@@ -43,7 +43,7 @@ fn find[T, U](ls_: &list[T], f: fn(&T) -> option::t[U] ) -> 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 {
@@ -60,11 +60,11 @@ fn length[T](ls: &list[T]) -> uint {
     ret foldl[T, uint](ls, 0u, bind count[T](_, _));
 }
 
-fn cdr[T](ls: &list[T]) -> list[T] { alt ls { cons(_, tl) { ret *tl; } } }
+fn cdr[@T](ls: &list[T]) -> list[T] { alt ls { cons(_, tl) { ret *tl; } } }
 
-fn car[T](ls: &list[T]) -> T { alt ls { cons(hd, _) { ret hd; } } }
+fn car[@T](ls: &list[T]) -> T { alt ls { cons(hd, _) { ret hd; } } }
 
-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) {
diff --git a/src/lib/map.rs b/src/lib/map.rs
index a5a894fc9a6..6ce93d4592f 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -19,9 +19,9 @@ type hashmap[K, V] =
     };
 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};
@@ -53,10 +53,10 @@ 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],
-                        bkts: &(bucket[K, V])[mutable ], nbkts: uint, key: &K,
-                        val: &V) -> bool {
+    fn insert_common[@K,
+                     @V](hasher: &hashfn[K], eqer: &eqfn[K],
+                         bkts: &(bucket[K, V])[mutable ], nbkts: uint,
+                         key: &K, val: &V) -> bool {
         let i: uint = 0u;
         let h: uint = hasher(key);
         while i < nbkts {
@@ -78,9 +78,9 @@ 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],
-                      bkts: &(bucket[K, V])[mutable ], nbkts: uint, key: &K)
+    fn find_common[@K,
+                   @V](hasher: &hashfn[K], eqer: &eqfn[K],
+                       bkts: &(bucket[K, V])[mutable ], nbkts: uint, key: &K)
        -> option::t[V] {
         let i: uint = 0u;
         let h: uint = hasher(key);
@@ -101,10 +101,10 @@ fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
         }
         ret option::none[V];
     }
-    fn rehash[K,
-              V](hasher: &hashfn[K], eqer: &eqfn[K],
-                 oldbkts: &(bucket[K, V])[mutable ], noldbkts: uint,
-                 newbkts: &(bucket[K, V])[mutable ], nnewbkts: uint) {
+    fn rehash[@K,
+              @V](hasher: &hashfn[K], eqer: &eqfn[K],
+                  oldbkts: &(bucket[K, V])[mutable ], noldbkts: uint,
+                  newbkts: &(bucket[K, V])[mutable ], nnewbkts: uint) {
         for b: bucket[K, V]  in oldbkts {
             alt b {
               some(k_, v_) {
@@ -116,13 +116,13 @@ fn mk_hashmap[K, V](hasher: &hashfn[K], eqer: &eqfn[K]) -> hashmap[K, V] {
             }
         }
     }
-    obj hashmap[K,
-                V](hasher: hashfn[K],
-                   eqer: eqfn[K],
-                   mutable bkts: (bucket[K, V])[mutable ],
-                   mutable nbkts: uint,
-                   mutable nelts: uint,
-                   lf: util::rational) {
+    obj hashmap[@K,
+                @V](hasher: hashfn[K],
+                    eqer: eqfn[K],
+                    mutable bkts: (bucket[K, V])[mutable ],
+                    mutable nbkts: uint,
+                    mutable nelts: uint,
+                    lf: util::rational) {
         fn size() -> uint { ret nelts; }
         fn insert(key: &K, val: &V) -> bool {
             let load: util::rational =
@@ -199,17 +199,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[int, V](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[uint, V](hash_uint, eq_uint);
diff --git a/src/lib/sort.rs b/src/lib/sort.rs
index 65aaf8fd4de..909e40c5c6b 100644
--- a/src/lib/sort.rs
+++ b/src/lib/sort.rs
@@ -11,7 +11,7 @@ export quick_sort3;
 
 type lteq[T] = fn(&T, &T) -> bool ;
 
-fn merge_sort[T](le: lteq[T], v: vec[T]) -> vec[T] {
+fn merge_sort[@T](le: lteq[T], v: vec[T]) -> vec[T] {
     fn merge[T](le: lteq[T], a: vec[T], b: vec[T]) -> vec[T] {
         let rs: vec[T] = [];
         let a_len: uint = len[T](a);
@@ -36,13 +36,13 @@ fn merge_sort[T](le: lteq[T], v: vec[T]) -> vec[T] {
     ret merge[T](le, merge_sort[T](le, a), merge_sort[T](le, b));
 }
 
-fn swap[T](arr: vec[mutable T], x: uint, y: uint) {
+fn swap[@T](arr: vec[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: vec[mutable T], left: uint,
+fn part[@T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
            right: uint, pivot: uint) -> uint {
     let pivot_value = arr.(pivot);
     swap[T](arr, pivot, right);
@@ -59,7 +59,7 @@ fn part[T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
     ret storage_index;
 }
 
-fn qsort[T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
+fn qsort[@T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
             right: uint) {
     if right > left {
         let pivot = (left + right) / 2u;
@@ -72,7 +72,7 @@ fn qsort[T](compare_func: lteq[T], arr: vec[mutable T], left: uint,
     }
 }
 
-fn quick_sort[T](compare_func: lteq[T], arr: vec[mutable T]) {
+fn quick_sort[@T](compare_func: lteq[T], arr: vec[mutable T]) {
     if len[T](arr) == 0u { ret; }
     qsort[T](compare_func, arr, 0u, len[T](arr) - 1u);
 }
@@ -82,7 +82,7 @@ fn quick_sort[T](compare_func: lteq[T], arr: vec[mutable T]) {
 // http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf
 // According to these slides this is the algorithm of choice for
 // 'randomly ordered keys, abstract compare' & 'small number of key values'
-fn qsort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+fn qsort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
              arr: vec[mutable T], left: int, right: int) {
     if right <= left { ret; }
     let v: T = arr.(right);
@@ -130,7 +130,7 @@ fn qsort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
     qsort3[T](compare_func_lt, compare_func_eq, arr, i, right);
 }
 
-fn quick_sort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+fn quick_sort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
                   arr: vec[mutable T]) {
     if vec::len[T](arr) == 0u { ret; }
     qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
@@ -144,8 +144,8 @@ mod ivector {
 
     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[] {
+    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;
@@ -169,13 +169,13 @@ mod ivector {
         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: &T[mutable ], 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: &T[mutable ], left: uint,
                right: uint, pivot: uint) -> uint {
         let pivot_value = arr.(pivot);
         swap[T](arr, pivot, right);
@@ -192,7 +192,7 @@ mod ivector {
         ret storage_index;
     }
 
-    fn qsort[T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
+    fn qsort[@T](compare_func: lteq[T], arr: &T[mutable ], left: uint,
                 right: uint) {
         if right > left {
             let pivot = (left + right) / 2u;
@@ -205,7 +205,7 @@ mod ivector {
         }
     }
 
-    fn quick_sort[T](compare_func: lteq[T], arr: &T[mutable ]) {
+    fn quick_sort[@T](compare_func: lteq[T], arr: &T[mutable ]) {
         if ilen[T](arr) == 0u { ret; }
         qsort[T](compare_func, arr, 0u, ilen[T](arr) - 1u);
     }
@@ -216,7 +216,7 @@ mod ivector {
     // According to these slides this is the algorithm of choice for
     // 'randomly ordered keys, abstract compare' & 'small number of key
     // values'
-    fn qsort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+    fn qsort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
                  arr: &T[mutable ], left: int, right: int) {
         if right <= left { ret; }
         let v: T = arr.(right);
@@ -264,7 +264,7 @@ mod ivector {
         qsort3[T](compare_func_lt, compare_func_eq, arr, i, right);
     }
 
-    fn quick_sort3[T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
+    fn quick_sort3[@T](compare_func_lt: lteq[T], compare_func_eq: lteq[T],
                       arr: &T[mutable ]) {
         if ilen[T](arr) == 0u { ret; }
         qsort3[T](compare_func_lt, compare_func_eq, arr, 0,
diff --git a/src/lib/vec.rs b/src/lib/vec.rs
index c902e39a0de..0bf6475d297 100644
--- a/src/lib/vec.rs
+++ b/src/lib/vec.rs
@@ -60,14 +60,14 @@ fn empty_mut[T]() -> vec[mutable T] { ret alloc_mut[T](0u); }
 
 type init_op[T] = fn(uint) -> T ;
 
-fn init_fn[T](op: &init_op[T], n_elts: uint) -> vec[T] {
+fn init_fn[@T](op: &init_op[T], n_elts: uint) -> vec[T] {
     let v: vec[T] = alloc[T](n_elts);
     let i: uint = 0u;
     while i < n_elts { v += [op(i)]; i += 1u; }
     ret v;
 }
 
-fn init_fn_mut[T](op: &init_op[T], n_elts: uint) -> vec[mutable T] {
+fn init_fn_mut[@T](op: &init_op[T], n_elts: uint) -> vec[mutable T] {
     let v: vec[mutable T] = alloc_mut[T](n_elts);
     let i: uint = 0u;
     while i < n_elts { v += [mutable op(i)]; i += 1u; }
@@ -76,7 +76,7 @@ fn init_fn_mut[T](op: &init_op[T], n_elts: uint) -> vec[mutable T] {
 
 // init_elt: creates and returns a vector of length n_elts, filled with
 // that many copies of element t.
-fn init_elt[T](t: &T, n_elts: uint) -> vec[T] {
+fn init_elt[@T](t: &T, n_elts: uint) -> vec[T] {
     /**
      * FIXME (issue #81): should be:
      *
@@ -91,7 +91,7 @@ fn init_elt[T](t: &T, n_elts: uint) -> vec[T] {
     ret v;
 }
 
-fn init_elt_mut[T](t: &T, n_elts: uint) -> vec[mutable T] {
+fn init_elt_mut[@T](t: &T, n_elts: uint) -> vec[mutable T] {
     let v: vec[mutable T] = alloc_mut[T](n_elts);
     let i: uint = n_elts;
     while i > 0u { i -= 1u; v += [mutable t]; }
@@ -113,7 +113,7 @@ fn print_debug_info[T](v: array[T]) { rustrt::vec_print_debug_info[T](v); }
 
 // FIXME: typestate precondition (list is non-empty)
 // Returns the last element of v.
-fn last[T](v: array[T]) -> option::t[T] {
+fn last[@T](v: array[T]) -> option::t[T] {
     let l = len[T](v);
     if l == 0u { ret none[T]; }
     ret some[T](v.(l - 1u));
@@ -121,7 +121,7 @@ fn last[T](v: array[T]) -> option::t[T] {
 
 
 // Returns elements from [start..end) from v.
-fn slice[T](v: array[T], start: uint, end: uint) -> vec[T] {
+fn slice[@T](v: array[T], start: uint, end: uint) -> vec[T] {
     assert (start <= end);
     assert (end <= len[T](v));
     let result = alloc[T](end - start);
@@ -132,7 +132,7 @@ fn slice[T](v: array[T], start: uint, end: uint) -> vec[T] {
 
 
 // FIXME: Should go away eventually.
-fn slice_mut[T](v: array[T], start: uint, end: uint) -> vec[mutable T] {
+fn slice_mut[@T](v: array[T], start: uint, end: uint) -> vec[mutable T] {
     assert (start <= end);
     assert (end <= len[T](v));
     let result = alloc_mut[T](end - start);
@@ -141,7 +141,7 @@ fn slice_mut[T](v: array[T], start: uint, end: uint) -> vec[mutable T] {
     ret result;
 }
 
-fn shift[T](v: &mutable array[T]) -> T {
+fn shift[@T](v: &mutable array[T]) -> T {
     let ln = len[T](v);
     assert (ln > 0u);
     let e = v.(0);
@@ -149,7 +149,7 @@ fn shift[T](v: &mutable array[T]) -> T {
     ret e;
 }
 
-fn pop[T](v: &mutable array[T]) -> T {
+fn pop[@T](v: &mutable array[T]) -> T {
     let ln = len[T](v);
     assert (ln > 0u);
     ln -= 1u;
@@ -158,58 +158,59 @@ fn pop[T](v: &mutable array[T]) -> T {
     ret e;
 }
 
-fn top[T](v: &array[T]) -> T {
+fn top[@T](v: &array[T]) -> T {
     let ln = len[T](v);
     assert (ln > 0u);
     ret v.(ln - 1u);
 }
 
-fn push[T](v: &mutable array[T], t: &T) { v += [t]; }
+fn push[@T](v: &mutable array[T], t: &T) { v += [t]; }
 
-fn unshift[T](v: &mutable array[T], t: &T) {
+fn unshift[@T](v: &mutable array[T], t: &T) {
     let rs = alloc[T](len[T](v) + 1u);
     rs += [t];
     rs += v;
     v = rs;
 }
 
-fn grow[T](v: &mutable array[T], n: uint, initval: &T) {
+fn grow[@T](v: &mutable array[T], n: uint, initval: &T) {
     let i: uint = n;
     while i > 0u { i -= 1u; v += [initval]; }
 }
 
-fn grow_set[T](v: &mutable vec[mutable T], index: uint, initval: &T,
+fn grow_set[@T](v: &mutable vec[mutable T], index: uint, initval: &T,
                val: &T) {
     let length = vec::len(v);
     if index >= length { grow(v, index - length + 1u, initval); }
     v.(index) = val;
 }
 
-fn grow_init_fn[T](v: &mutable array[T], n: uint, init_fn: fn() -> T ) {
+fn grow_init_fn[@T](v: &mutable array[T], n: uint, init_fn: fn() -> T ) {
     let i: uint = n;
     while i > 0u { i -= 1u; v += [init_fn()]; }
 }
 
-fn grow_init_fn_set[T](v: &mutable array[T], index: uint, init_fn: fn() -> T,
+fn grow_init_fn_set[@T](v: &mutable array[T], index: uint, init_fn: fn() -> T,
                        val: &T) {
     let length = vec::len(v);
     if index >= length { grow_init_fn(v, index - length + 1u, init_fn); }
     v.(index) = val;
 }
 
-fn map[T, U](f: &fn(&T) -> U , v: &vec[T]) -> vec[U] {
+fn map[@T, @U](f: &fn(&T) -> U , v: &vec[T]) -> vec[U] {
     let rs: vec[U] = alloc[U](len[T](v));
     for ve: T  in v { rs += [f(ve)]; }
     ret rs;
 }
 
-fn filter_map[T, U](f: &fn(&T) -> option::t[U] , v: &vec[T]) -> vec[U] {
+fn filter_map[@T, @U](f: &fn(&T) -> option::t[U] , v: &vec[T]) -> vec[U] {
     let rs: vec[U] = [];
     for ve: T  in v { alt f(ve) { some(elt) { rs += [elt]; } none. { } } }
     ret rs;
 }
 
-fn map2[T, U, V](f: &operator2[T, U, V], v0: &vec[T], v1: &vec[U]) -> vec[V] {
+fn map2[@T, @U, @V](f: &operator2[T, U, V], v0: &vec[T], v1: &vec[U])
+    -> vec[V] {
     let v0_len = len[T](v0);
     if v0_len != len[U](v1) { fail; }
     let u: vec[V] = alloc[V](v0_len);
@@ -218,12 +219,12 @@ fn map2[T, U, V](f: &operator2[T, U, V], v0: &vec[T], v1: &vec[U]) -> vec[V] {
     ret u;
 }
 
-fn find[T](f: fn(&T) -> bool , v: &vec[T]) -> option::t[T] {
+fn find[@T](f: fn(&T) -> bool , v: &vec[T]) -> option::t[T] {
     for elt: T  in v { if f(elt) { ret some[T](elt); } }
     ret none[T];
 }
 
-fn position[T](x: &T, v: &array[T]) -> option::t[uint] {
+fn position[@T](x: &T, v: &array[T]) -> option::t[uint] {
     let i: uint = 0u;
     while i < len(v) { if x == v.(i) { ret some[uint](i); } i += 1u; }
     ret none[uint];
@@ -246,7 +247,7 @@ fn count[T](x: &T, v: &array[T]) -> uint {
     ret cnt;
 }
 
-fn foldl[T, U](p: fn(&U, &T) -> U , z: &U, v: &vec[T]) -> U {
+fn foldl[@T, @U](p: fn(&U, &T) -> U , z: &U, v: &vec[T]) -> U {
     let sz = len[T](v);
     if sz == 0u {
         ret z;
@@ -256,7 +257,7 @@ fn foldl[T, U](p: fn(&U, &T) -> U , z: &U, v: &vec[T]) -> U {
     }
 }
 
-fn unzip[T, U](v: &vec[{_0: T, _1: U}]) -> {_0: vec[T], _1: vec[U]} {
+fn unzip[@T, @U](v: &vec[{_0: T, _1: U}]) -> {_0: vec[T], _1: vec[U]} {
     let sz = len(v);
     if sz == 0u {
         ret {_0: alloc[T](0u), _1: alloc[U](0u)};
@@ -271,7 +272,7 @@ fn unzip[T, U](v: &vec[{_0: T, _1: U}]) -> {_0: vec[T], _1: vec[U]} {
 
 
 // FIXME make the lengths being equal a constraint
-fn zip[T, U](v: &vec[T], u: &vec[U]) -> vec[{_0: T, _1: U}] {
+fn zip[@T, @U](v: &vec[T], u: &vec[U]) -> vec[{_0: T, _1: U}] {
     let sz = len(v);
     assert (sz == len(u));
     if sz == 0u {
@@ -297,13 +298,13 @@ fn all[T](f: &fn(&T) -> bool , v: &vec[T]) -> bool {
     ret true;
 }
 
-fn clone[T](v: &vec[T]) -> vec[T] { ret slice[T](v, 0u, len[T](v)); }
+fn clone[@T](v: &vec[T]) -> vec[T] { ret slice[T](v, 0u, len[T](v)); }
 
-fn plus_option[T](v: &mutable vec[T], o: &option::t[T]) {
+fn plus_option[@T](v: &mutable vec[T], o: &option::t[T]) {
     alt o { none. { } some(x) { v += [x]; } }
 }
 
-fn cat_options[T](v: &vec[option::t[T]]) -> vec[T] {
+fn cat_options[@T](v: &vec[option::t[T]]) -> vec[T] {
     let rs: vec[T] = [];
     for o: option::t[T]  in v { alt o { none. { } some(t) { rs += [t]; } } }
     ret rs;
@@ -311,7 +312,7 @@ fn cat_options[T](v: &vec[option::t[T]]) -> vec[T] {
 
 
 // TODO: Remove in favor of built-in "freeze" operation when it's implemented.
-fn freeze[T](v: vec[mutable T]) -> vec[T] {
+fn freeze[@T](v: vec[mutable T]) -> vec[T] {
     let result: vec[T] = [];
     for elem: T  in v { result += [elem]; }
     ret result;
@@ -319,7 +320,7 @@ fn freeze[T](v: vec[mutable T]) -> vec[T] {
 
 
 // Swaps two elements in a vector
-fn swap[T](v: &vec[mutable T], a: uint, b: uint) {
+fn swap[@T](v: &vec[mutable T], a: uint, b: uint) {
     let t: T = v.(a);
     v.(a) = v.(b);
     v.(b) = t;
@@ -327,7 +328,7 @@ fn swap[T](v: &vec[mutable T], a: uint, b: uint) {
 
 
 // In place vector reversal
-fn reverse[T](v: &vec[mutable T]) {
+fn reverse[@T](v: &vec[mutable T]) {
     let i: uint = 0u;
     let ln = len[T](v);
     while i < ln / 2u { swap(v, i, ln - i - 1u); i += 1u; }
@@ -335,7 +336,7 @@ fn reverse[T](v: &vec[mutable T]) {
 
 
 // Functional vector reversal. Returns a reversed copy of v.
-fn reversed[T](v: vec[T]) -> vec[T] {
+fn reversed[@T](v: vec[T]) -> vec[T] {
     let rs: vec[T] = [];
     let i = len[T](v);
     if i == 0u { ret rs; } else { i -= 1u; }
@@ -347,7 +348,7 @@ fn reversed[T](v: vec[T]) -> vec[T] {
 
 /// Truncates the vector to length `new_len`.
 /// FIXME: This relies on a typechecker bug (covariance vs. invariance).
-fn truncate[T](v: &mutable vec[mutable? T], new_len: uint) {
+fn truncate[@T](v: &mutable vec[mutable? T], new_len: uint) {
     v = slice[T](v, 0u, new_len);
 }
 // Local Variables:
diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs
index 826c3e24176..724ffc8b70d 100644
--- a/src/test/run-pass/swap-2.rs
+++ b/src/test/run-pass/swap-2.rs
@@ -1,4 +1,4 @@
-fn swap[T](v: &vec[mutable T], i: int, j: int) { v.(i) <-> v.(j); }
+fn swap[@T](v: &vec[mutable T], i: int, j: int) { v.(i) <-> v.(j); }
 
 fn main() {
     let a: vec[mutable int] = [mutable 0, 1, 2, 3, 4, 5, 6];