diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs index 425b43f7ce6..67a6d09ce17 100644 --- a/src/comp/driver/rustc.rs +++ b/src/comp/driver/rustc.rs @@ -88,7 +88,7 @@ fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str) ret {crate: crate, src: src}; } -fn time<@T>(do_it: bool, what: str, thunk: fn@() -> T) -> T { +fn time<T>(do_it: bool, what: str, thunk: fn@() -> T) -> T { if !do_it { ret thunk(); } let start = std::time::precise_time_s(); let rv = thunk(); diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs index 62c6a0282ce..a9da327fcef 100644 --- a/src/comp/front/attr.rs +++ b/src/comp/front/attr.rs @@ -182,7 +182,7 @@ fn require_unique_names(sess: session::session, metas: [@ast::meta_item]) { } } -fn span<@T>(item: T) -> ast::spanned<T> { +fn span<T>(item: T) -> ast::spanned<T> { ret {node: item, span: ast_util::dummy_sp()}; } diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs index 0def0979928..255a83712f8 100644 --- a/src/comp/front/test.rs +++ b/src/comp/front/test.rs @@ -180,7 +180,7 @@ fn mk_test_module(cx: test_ctxt) -> @ast::item { ret @item; } -fn nospan<@T>(t: T) -> ast::spanned<T> { ret {node: t, span: dummy_sp()}; } +fn nospan<T>(t: T) -> ast::spanned<T> { ret {node: t, span: dummy_sp()}; } fn mk_tests(cx: test_ctxt) -> @ast::item { let ret_ty = mk_test_desc_vec_ty(cx); diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs index 96a4edb017c..91f0feda596 100644 --- a/src/comp/metadata/encoder.rs +++ b/src/comp/metadata/encoder.rs @@ -391,7 +391,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer) -> // Path and definition ID indexing -fn create_index<@T>(index: [entry<T>], hash_fn: fn(T) -> uint) -> +fn create_index<T>(index: [entry<T>], hash_fn: fn(T) -> uint) -> [@[entry<T>]] { let buckets: [@mutable [entry<T>]] = []; uint::range(0u, 256u) {|_i| buckets += [@mutable []]; }; diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs index 25519a04923..e1f98ca34bb 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 = ast_util::dummy_sp(); // FIXME: use a real span let args: [@sp_constr_arg<T>] = []; diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs index 6f9d250fc43..3e73ec1060c 100644 --- a/src/comp/middle/ast_map.rs +++ b/src/comp/middle/ast_map.rs @@ -75,7 +75,7 @@ fn map_expr(cx: ctx, ex: @expr) { cx.map.insert(ex.id, node_expr(ex)); } -fn new_smallintmap_int_adapter<@V>() -> std::map::hashmap<int, V> { +fn new_smallintmap_int_adapter<V>() -> std::map::hashmap<int, V> { let key_idx = fn (&&key: int) -> uint { key as uint }; let idx_key = fn (idx: uint) -> int { idx as int }; ret new_smallintmap_adapter(key_idx, idx_key); @@ -86,13 +86,13 @@ fn new_smallintmap_int_adapter<@V>() -> std::map::hashmap<int, V> { // the entire codebase adapting all the callsites to the different // interface. // FIXME: hashmap and smallintmap should support the same interface. -fn new_smallintmap_adapter<@K, @V>(key_idx: fn(K) -> uint, +fn new_smallintmap_adapter<K, V>(key_idx: fn(K) -> uint, idx_key: fn(uint) -> K) -> std::map::hashmap<K, V> { - obj adapter<@K, @V>(map: smallintmap::smallintmap<V>, - key_idx: fn(K) -> uint, - idx_key: fn(uint) -> K) { + obj adapter<K, V>(map: smallintmap::smallintmap<V>, + key_idx: fn(K) -> uint, + idx_key: fn(uint) -> K) { fn size() -> uint { fail } diff --git a/src/comp/middle/kind.rs b/src/comp/middle/kind.rs index 81032c6a91f..149e463c111 100644 --- a/src/comp/middle/kind.rs +++ b/src/comp/middle/kind.rs @@ -25,10 +25,10 @@ * * * Since this forms a lattice, we denote the capabilites in terms of a -* worst-case requirement. That is, if your function needs to move-and-send -* (or copy) your T, you write fn<~T>(...). If you need to move but not send, -* you write fn<@T>(...). And if you need neither -- can work with any sort of -* pinned data at all -- then you write fn<T>(...). +* worst-case requirement. That is, if your function needs to move-and-send (or +* copy) your T, you write fn<unique T>(...). If you need to move but not send, +* you write fn<T>(...). And if you need neither -- can work with any sort of +* pinned data at all -- then you write fn<pinned T>(...). * * Most types are unique or shared. Other possible name combinations for these * two: (tree, graph; pruned, pooled; message, local; owned, common) are diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs index b10ce87a697..864b82ed9fb 100644 --- a/src/comp/syntax/ast_util.rs +++ b/src/comp/syntax/ast_util.rs @@ -2,7 +2,7 @@ import std::{str, option}; import codemap::span; import ast::*; -fn respan<@T>(sp: span, t: T) -> spanned<T> { ret {node: t, span: sp}; } +fn respan<T>(sp: span, t: T) -> spanned<T> { ret {node: t, span: sp}; } /* assuming that we're not in macro expansion */ fn mk_sp(lo: uint, hi: uint) -> span { @@ -186,7 +186,7 @@ fn eq_def_id(&&a: def_id, &&b: def_id) -> bool { a == b } -fn new_def_id_hash<@T>() -> std::map::hashmap<def_id, T> { +fn new_def_id_hash<T>() -> std::map::hashmap<def_id, T> { std::map::mk_hashmap(hash_def_id, eq_def_id) } diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs index d766ff11579..3adcfbccf4e 100644 --- a/src/comp/syntax/ext/simplext.rs +++ b/src/comp/syntax/ext/simplext.rs @@ -104,7 +104,7 @@ fn elts_to_ell(cx: ext_ctxt, elts: [@expr]) -> } } -fn option_flatten_map<T, @U>(f: fn@(T) -> option::t<U>, v: [T]) -> +fn option_flatten_map<T, U>(f: fn@(T) -> option::t<U>, v: [T]) -> option::t<[U]> { let res = []; for elem: T in v { diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs index 7c9ad1fae1c..9b467e683b8 100644 --- a/src/comp/syntax/parse/parser.rs +++ b/src/comp/syntax/parse/parser.rs @@ -210,7 +210,7 @@ fn expect_gt(p: parser) { } } -fn spanned<@T>(lo: uint, hi: uint, node: T) -> spanned<T> { +fn spanned<T>(lo: uint, hi: uint, node: T) -> spanned<T> { ret {node: node, span: ast_util::mk_sp(lo, hi)}; } @@ -595,7 +595,7 @@ fn parse_fn_block_arg(p: parser) -> ast::arg { ret {mode: m, ty: t, ident: i, id: p.get_id()}; } -fn parse_seq_to_before_gt<@T>(sep: option::t<token::token>, +fn parse_seq_to_before_gt<T>(sep: option::t<token::token>, f: fn@(parser) -> T, p: parser) -> [T] { let first = true; @@ -612,7 +612,7 @@ fn parse_seq_to_before_gt<@T>(sep: option::t<token::token>, ret v; } -fn parse_seq_to_gt<@T>(sep: option::t<token::token>, f: fn@(parser) -> T, +fn parse_seq_to_gt<T>(sep: option::t<token::token>, f: fn@(parser) -> T, p: parser) -> [T] { let v = parse_seq_to_before_gt(sep, f, p); expect_gt(p); @@ -620,7 +620,7 @@ fn parse_seq_to_gt<@T>(sep: option::t<token::token>, f: fn@(parser) -> T, ret v; } -fn parse_seq_lt_gt<@T>(sep: option::t<token::token>, f: fn@(parser) -> T, +fn parse_seq_lt_gt<T>(sep: option::t<token::token>, f: fn@(parser) -> T, p: parser) -> spanned<[T]> { let lo = p.get_lo_pos(); expect(p, token::LT); @@ -630,14 +630,14 @@ fn parse_seq_lt_gt<@T>(sep: option::t<token::token>, f: fn@(parser) -> T, ret spanned(lo, hi, result); } -fn parse_seq_to_end<@T>(ket: token::token, sep: option::t<token::token>, +fn parse_seq_to_end<T>(ket: token::token, sep: option::t<token::token>, f: fn(parser) -> T, p: parser) -> [T] { let val = parse_seq_to_before_end(ket, sep, f, p); p.bump(); ret val; } -fn parse_seq_to_before_end<@T>(ket: token::token, +fn parse_seq_to_before_end<T>(ket: token::token, sep: option::t<token::token>, f: fn@(parser) -> T, p: parser) -> [T] { let first: bool = true; @@ -653,7 +653,7 @@ fn parse_seq_to_before_end<@T>(ket: token::token, } -fn parse_seq<@T>(bra: token::token, ket: token::token, +fn parse_seq<T>(bra: token::token, ket: token::token, sep: option::t<token::token>, f: fn@(parser) -> T, p: parser) -> spanned<[T]> { let lo = p.get_lo_pos(); diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs index 67324491267..dea86723af3 100644 --- a/src/comp/syntax/util/interner.rs +++ b/src/comp/syntax/util/interner.rs @@ -11,12 +11,12 @@ type interner<T> = hasher: hashfn<T>, eqer: eqfn<T>}; -fn mk<@T>(hasher: hashfn<T>, eqer: eqfn<T>) -> interner<T> { +fn mk<T>(hasher: hashfn<T>, eqer: eqfn<T>) -> interner<T> { let m = map::mk_hashmap::<T, uint>(hasher, eqer); ret {map: m, mutable vect: [], hasher: hasher, eqer: eqer}; } -fn intern<@T>(itr: interner<T>, val: T) -> uint { +fn intern<T>(itr: interner<T>, val: T) -> uint { alt itr.map.find(val) { some(idx) { ret idx; } none. { @@ -31,7 +31,7 @@ fn intern<@T>(itr: interner<T>, val: T) -> uint { // |get| isn't "pure" in the traditional sense, because it can go from // failing to returning a value as items are interned. But for typestate, // where we first check a pred and then rely on it, ceasing to fail is ok. -pure fn get<@T>(itr: interner<T>, idx: uint) -> T { +pure fn get<T>(itr: interner<T>, idx: uint) -> T { unchecked { itr.vect[idx] } diff --git a/src/comp/util/common.rs b/src/comp/util/common.rs index 22b85fac3da..2eb717f5109 100644 --- a/src/comp/util/common.rs +++ b/src/comp/util/common.rs @@ -25,7 +25,7 @@ fn hash_def(d: ast::def_id) -> uint { ret h; } -fn new_def_hash<@V>() -> std::map::hashmap<ast::def_id, V> { +fn new_def_hash<V>() -> std::map::hashmap<ast::def_id, V> { let hasher: std::map::hashfn<ast::def_id> = hash_def; let eqer: std::map::eqfn<ast::def_id> = def_eq; ret std::map::mk_hashmap::<ast::def_id, V>(hasher, eqer); @@ -166,7 +166,7 @@ fn lit_in_range(l: @ast::lit, m1: @ast::lit, m2: @ast::lit) -> bool { } } -fn ranges_overlap<@T>(a1: T, a2: T, b1: T, b2: T) -> bool { +fn ranges_overlap<T>(a1: T, a2: T, b1: T, b2: T) -> bool { let min1 = min(a1, a2); let max1 = max(a1, a2); let min2 = min(b1, b2); diff --git a/src/comp/util/filesearch.rs b/src/comp/util/filesearch.rs index d6f058ab1ca..a619d7e6884 100644 --- a/src/comp/util/filesearch.rs +++ b/src/comp/util/filesearch.rs @@ -16,7 +16,7 @@ export pick_file; export search; export relative_target_lib_path; -type pick<@T> = block(path: fs::path) -> option::t<T>; +type pick<T> = block(path: fs::path) -> option::t<T>; fn pick_file(file: fs::path, path: fs::path) -> option::t<fs::path> { if fs::basename(path) == file { option::some(path) } @@ -57,7 +57,7 @@ fn mk_filesearch(maybe_sysroot: option::t<fs::path>, } // FIXME #1001: This can't be an obj method -fn search<@T>(filesearch: filesearch, pick: pick<T>) -> option::t<T> { +fn search<T>(filesearch: filesearch, pick: pick<T>) -> option::t<T> { for lib_search_path in filesearch.lib_search_paths() { log #fmt["searching %s", lib_search_path]; for path in fs::list_dir(lib_search_path) { diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index 5caf9f7d57a..173403690e5 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -154,17 +154,17 @@ fn worker(p: port<request>) { // Only windows needs to set the library path #[cfg(target_os = "win32")] -fn maybe_with_lib_path<@T>(path: str, f: fn@() -> T) -> T { +fn maybe_with_lib_path<T>(path: str, f: fn@() -> T) -> T { with_lib_path(path, f) } #[cfg(target_os = "linux")] #[cfg(target_os = "macos")] -fn maybe_with_lib_path<@T>(_path: str, f: fn@() -> T) -> T { +fn maybe_with_lib_path<T>(_path: str, f: fn@() -> T) -> T { f() } -fn with_lib_path<@T>(path: str, f: fn@() -> T) -> T { +fn with_lib_path<T>(path: str, f: fn@() -> T) -> T { let maybe_oldpath = getenv(util::lib_path_env_var()); append_lib_path(path); let res = f(); diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index 04e7550533e..f99bff1cf47 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -227,7 +227,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap, check_variants_T(crate, codemap, filename, "ty", stolen.tys, pprust::ty_to_str, replace_ty_in_crate, cx); } -fn check_variants_T<@T>( +fn check_variants_T<T>( crate: ast::crate, codemap: codemap::codemap, filename: str, diff --git a/src/fuzzer/ivec_fuzz.rs b/src/fuzzer/ivec_fuzz.rs index 4ede2f4482a..66b1a60f173 100644 --- a/src/fuzzer/ivec_fuzz.rs +++ b/src/fuzzer/ivec_fuzz.rs @@ -22,22 +22,22 @@ import std::vec::slice; import std::vec::len; import std::int; -fn vec_omit<@T>(v: [T], i: uint) -> [T] { +fn vec_omit<T>(v: [T], i: uint) -> [T] { slice(v, 0u, i) + slice(v, i + 1u, len(v)) } -fn vec_dup<@T>(v: [T], i: uint) -> [T] { +fn vec_dup<T>(v: [T], i: uint) -> [T] { slice(v, 0u, i) + [v[i]] + slice(v, i, len(v)) } -fn vec_swadj<@T>(v: [T], i: uint) -> [T] { +fn vec_swadj<T>(v: [T], i: uint) -> [T] { slice(v, 0u, i) + [v[i + 1u], v[i]] + slice(v, i + 2u, len(v)) } -fn vec_prefix<@T>(v: [T], i: uint) -> [T] { slice(v, 0u, i) } -fn vec_suffix<@T>(v: [T], i: uint) -> [T] { slice(v, i, len(v)) } +fn vec_prefix<T>(v: [T], i: uint) -> [T] { slice(v, 0u, i) } +fn vec_suffix<T>(v: [T], i: uint) -> [T] { slice(v, i, len(v)) } -fn vec_poke<@T>(v: [T], i: uint, x: T) -> [T] { +fn vec_poke<T>(v: [T], i: uint, x: T) -> [T] { slice(v, 0u, i) + [x] + slice(v, i + 1u, len(v)) } -fn vec_insert<@T>(v: [T], i: uint, x: T) -> [T] { +fn vec_insert<T>(v: [T], i: uint, x: T) -> [T] { slice(v, 0u, i) + [x] + slice(v, i, len(v)) } @@ -48,7 +48,7 @@ fn ix(skip_low: uint, skip_high: uint, length: uint, it: block(uint)) { } // Returns a bunch of modified versions of v, some of which introduce new elements (borrowed from xs). -fn vec_edits<@T>(v: [T], xs: [T]) -> [[T]] { +fn vec_edits<T>(v: [T], xs: [T]) -> [[T]] { let edits: [[T]] = []; let Lv: uint = len(v); diff --git a/src/fuzzer/rand_util.rs b/src/fuzzer/rand_util.rs index ad6fc958e76..d59cf06b2a2 100644 --- a/src/fuzzer/rand_util.rs +++ b/src/fuzzer/rand_util.rs @@ -12,7 +12,7 @@ fn choice<T>(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[under(r, fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u } // shuffle a vec in place -fn shuffle<@T>(r : rand::rng, &v : [mutable T]) { +fn shuffle<T>(r : rand::rng, &v : [mutable T]) { let i = vec::len(v); while i >= 2u { // Loop invariant: elements with index >= i have been locked in place. @@ -22,7 +22,7 @@ fn shuffle<@T>(r : rand::rng, &v : [mutable T]) { } // create a shuffled copy of a vec -fn shuffled<@T>(r : rand::rng, v : [T]) -> [T] { +fn shuffled<T>(r : rand::rng, v : [T]) -> [T] { let w = vec::to_mut(v); shuffle(r, w); vec::from_mut(w) // Shouldn't this happen automatically? @@ -35,7 +35,7 @@ fn shuffled<@T>(r : rand::rng, v : [T]) -> [T] { // * weighted_choice is O(number of choices) time // * weighted_vec is O(total weight) space type weighted<T> = { weight: uint, item: T }; -fn weighted_choice<@T>(r : rand::rng, v : [weighted<T>]) -> T { +fn weighted_choice<T>(r : rand::rng, v : [weighted<T>]) -> T { assert vec::len(v) != 0u; let total = 0u; for {weight: weight, item: _} in v { diff --git a/src/lib/comm.rs b/src/lib/comm.rs index fd8f0981a9d..dbf7bb3df10 100644 --- a/src/lib/comm.rs +++ b/src/lib/comm.rs @@ -12,9 +12,9 @@ native "c-stack-cdecl" mod rustrt { type void; type rust_port; - fn chan_id_send<~T>(t: *sys::type_desc, - target_task: task::task, target_port: port_id, - -data: T); + fn chan_id_send<unique T>(t: *sys::type_desc, + target_task: task::task, target_port: port_id, + -data: T); fn new_port(unit_sz: uint) -> *rust_port; fn del_port(po: *rust_port); @@ -23,38 +23,38 @@ native "c-stack-cdecl" mod rustrt { } native "rust-intrinsic" mod rusti { - fn recv<~T>(port: *rustrt::rust_port) -> T; + fn recv<unique T>(port: *rustrt::rust_port) -> T; } type port_id = int; // It's critical that this only have one variant, so it has a record // layout, and will work in the rust_task structure in task.rs. -tag chan<~T> { chan_t(task::task, port_id); } +tag chan<unique T> { chan_t(task::task, port_id); } resource port_ptr(po: *rustrt::rust_port) { rustrt::drop_port(po); rustrt::del_port(po); } -tag port<~T> { port_t(@port_ptr); } +tag port<unique T> { port_t(@port_ptr); } -fn send<~T>(ch: chan<T>, -data: T) { +fn send<unique T>(ch: chan<T>, -data: T) { let chan_t(t, p) = ch; rustrt::chan_id_send(sys::get_type_desc::<T>(), t, p, data); task::yield(); } -fn port<~T>() -> port<T> { +fn port<unique T>() -> port<T> { let p = rustrt::new_port(sys::size_of::<T>()); ret port_t(@port_ptr(p)); } -fn recv<~T>(p: port<T>) -> T { +fn recv<unique T>(p: port<T>) -> T { ret rusti::recv(***p); } -fn chan<~T>(p: port<T>) -> chan<T> { +fn chan<unique T>(p: port<T>) -> chan<T> { let id = rustrt::get_port_id(***p); ret chan_t(task::get_task_id(), id); } diff --git a/src/lib/deque.rs b/src/lib/deque.rs index 134d0090be2..24aa95bfc28 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 @@ -30,7 +30,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]; @@ -46,10 +46,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>]) { diff --git a/src/lib/either.rs b/src/lib/either.rs index d20b124a968..143f0cabe92 100644 --- a/src/lib/either.rs +++ b/src/lib/either.rs @@ -10,7 +10,7 @@ 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] { +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 */ } } @@ -18,7 +18,7 @@ fn lefts<@T, U>(eithers: [t<T, U>]) -> [T] { 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 */ } } @@ -26,7 +26,7 @@ fn rights<T, @U>(eithers: [t<T, U>]) -> [U] { 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 { diff --git a/src/lib/fun_treemap.rs b/src/lib/fun_treemap.rs index 0fe87c07273..4a65d6191de 100644 --- a/src/lib/fun_treemap.rs +++ b/src/lib/fun_treemap.rs @@ -19,16 +19,16 @@ export insert; export find; export traverse; -tag tree_node<@K, @V> { +tag tree_node<K, V> { empty; node(@K, @V, @tree_node<K, V>, @tree_node<K, V>); } -type treemap<@K, @V> = @tree_node<K, V>; +type treemap<K, V> = @tree_node<K, V>; -fn init<@K, @V>() -> treemap<K, V> { @empty } +fn init<K, V>() -> treemap<K, V> { @empty } -fn insert<@K, @V>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> { +fn insert<K, V>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> { @alt m { @empty. { node(@k, @v, @empty, @empty) } @node(@kk, vv, left, right) { @@ -41,7 +41,7 @@ fn insert<@K, @V>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> { } } -fn find<@K, @V>(m: treemap<K, V>, k: K) -> option<V> { +fn find<K, V>(m: treemap<K, V>, k: K) -> option<V> { alt *m { empty. { none } node(@kk, @v, left, right) { @@ -54,7 +54,7 @@ fn find<@K, @V>(m: treemap<K, V>, k: K) -> option<V> { // Performs an in-order traversal -fn traverse<@K, @V>(m: treemap<K, V>, f: fn(K, V)) { +fn traverse<K, V>(m: treemap<K, V>, f: fn(K, V)) { alt *m { empty. { } node(@k, @v, _, _) { diff --git a/src/lib/list.rs b/src/lib/list.rs index d327d15db7c..0bacf29d03d 100644 --- a/src/lib/list.rs +++ b/src/lib/list.rs @@ -2,7 +2,7 @@ import option::{some, none}; 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 @@ -12,7 +12,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 { @@ -24,7 +24,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>) -> option::t<U> { +fn find<T, U>(ls_: list<T>, f: block(T) -> option::t<U>) -> option::t<U> { let ls = ls_; while true { alt ls { @@ -37,7 +37,7 @@ fn find<@T, @U>(ls_: list<T>, f: block(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 { @@ -48,20 +48,20 @@ fn has<@T>(ls_: list<T>, elt: T) -> bool { ret false; } -fn length<@T>(ls: list<T>) -> uint { +fn length<T>(ls: list<T>) -> uint { fn count<T>(_t: T, &&u: uint) -> uint { ret u + 1u; } ret foldl(ls, 0u, bind 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) { let rest = append(*xs, m); ret cons(x, @rest); } diff --git a/src/lib/map.rs b/src/lib/map.rs index ef5e8acae46..88d19092280 100644 --- a/src/lib/map.rs +++ b/src/lib/map.rs @@ -20,14 +20,14 @@ 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}; - 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 @@ -54,10 +54,9 @@ 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: [mutable bucket<K, V>], nbkts: uint, key: K, - val: V) -> bool { + 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; let h: uint = hasher(key); while i < nbkts { @@ -75,9 +74,8 @@ 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: [mutable bucket<K, V>], nbkts: uint, key: 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; let h: uint = hasher(key); @@ -97,10 +95,9 @@ 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>, - oldbkts: [mutable bucket<K, V>], _noldbkts: uint, - newbkts: [mutable bucket<K, V>], nnewbkts: uint) { + 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 { alt b { some(k_, v_) { @@ -112,7 +109,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, @@ -199,17 +196,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); diff --git a/src/lib/math.rs b/src/lib/math.rs index 1d95e1d2607..0b69b78d031 100644 --- a/src/lib/math.rs +++ b/src/lib/math.rs @@ -18,5 +18,5 @@ fn atan(x: float) -> float { llvm::atan(x) } const pi: float = 3.141592653589793; -fn min<@T>(x: T, y: T) -> T { x < y ? x : y } -fn max<@T>(x: T, y: T) -> T { x < y ? y : x } +fn min<T>(x: T, y: T) -> T { x < y ? x : y } +fn max<T>(x: T, y: T) -> T { x < y ? y : x } diff --git a/src/lib/option.rs b/src/lib/option.rs index 53c19ba8c0a..50240c3087b 100644 --- a/src/lib/option.rs +++ b/src/lib/option.rs @@ -1,31 +1,31 @@ // lib/option::rs -tag t<@T> { none; some(T); } +tag t<T> { none; some(T); } -fn get<@T>(opt: t<T>) -> &T { +fn get<T>(opt: t<T>) -> &T { alt opt { some(x) { ret x; } none. { fail "option none"; } } } -fn map<@T, @U>(f: block(T) -> U, opt: t<T>) -> t<U> { +fn map<T, U>(f: block(T) -> U, opt: t<T>) -> t<U> { alt opt { some(x) { some(f(x)) } none. { none } } } -fn is_none<@T>(opt: t<T>) -> bool { +fn is_none<T>(opt: t<T>) -> bool { alt opt { none. { true } some(_) { false } } } -fn is_some<@T>(opt: t<T>) -> bool { !is_none(opt) } +fn is_some<T>(opt: t<T>) -> bool { !is_none(opt) } -fn from_maybe<@T>(def: T, opt: t<T>) -> T { +fn from_maybe<T>(def: T, opt: t<T>) -> T { alt opt { some(x) { x } none. { def } } } -fn maybe<@T, @U>(def: U, f: block(T) -> U, opt: t<T>) -> U { +fn maybe<T, U>(def: U, f: block(T) -> U, opt: t<T>) -> U { alt opt { none. { def } some(t) { f(t) } } } // Can be defined in terms of the above when/if we have const bind. -fn may<@T>(f: block(T), opt: t<T>) { +fn may<T>(f: block(T), opt: t<T>) { alt opt { none. {/* nothing */ } some(t) { f(t); } } } diff --git a/src/lib/ptr.rs b/src/lib/ptr.rs index ccb05f0ce29..8d730732c3c 100644 --- a/src/lib/ptr.rs +++ b/src/lib/ptr.rs @@ -5,9 +5,9 @@ native "rust-intrinsic" mod rusti { fn ptr_offset<T>(ptr: *T, count: uint) -> *T; } -fn addr_of<@T>(val: T) -> *mutable T { ret rusti::addr_of(val); } -fn offset<@T>(ptr: *T, count: uint) -> *T { +fn addr_of<T>(val: T) -> *mutable T { ret rusti::addr_of(val); } +fn offset<T>(ptr: *T, count: uint) -> *T { ret rusti::ptr_offset(ptr, count); } -fn null<@T>() -> *T { ret unsafe::reinterpret_cast(0u); } +fn null<T>() -> *T { ret unsafe::reinterpret_cast(0u); } diff --git a/src/lib/smallintmap.rs b/src/lib/smallintmap.rs index 1eec907ffb2..b70c03ad1d5 100644 --- a/src/lib/smallintmap.rs +++ b/src/lib/smallintmap.rs @@ -8,32 +8,32 @@ import option::{some, none}; // to be. type smallintmap<T> = @{mutable v: [mutable option::t<T>]}; -fn mk<@T>() -> smallintmap<T> { +fn mk<T>() -> smallintmap<T> { let v: [mutable option::t<T>] = [mutable]; ret @{mutable v: v}; } -fn insert<@T>(m: smallintmap<T>, key: uint, val: T) { +fn insert<T>(m: smallintmap<T>, key: uint, val: T) { vec::grow_set::<option::t<T>>(m.v, key, none::<T>, some::<T>(val)); } -fn find<@T>(m: smallintmap<T>, key: uint) -> option::t<T> { +fn find<T>(m: smallintmap<T>, key: uint) -> option::t<T> { if key < vec::len::<option::t<T>>(m.v) { ret m.v[key]; } ret none::<T>; } -fn get<@T>(m: smallintmap<T>, key: uint) -> T { +fn get<T>(m: smallintmap<T>, key: uint) -> T { alt find::<T>(m, key) { none::<T>. { log_err "smallintmap::get(): key not present"; fail; } some::<T>(v) { ret v; } } } -fn contains_key<@T>(m: smallintmap<T>, key: uint) -> bool { +fn contains_key<T>(m: smallintmap<T>, key: uint) -> bool { ret !option::is_none(find::<T>(m, key)); } -fn truncate<@T>(m: smallintmap<T>, len: uint) { +fn truncate<T>(m: smallintmap<T>, len: uint) { m.v = vec::slice_mut::<option::t<T>>(m.v, 0u, len); } diff --git a/src/lib/sort.rs b/src/lib/sort.rs index a24225392dd..a70505e4847 100644 --- a/src/lib/sort.rs +++ b/src/lib/sort.rs @@ -7,8 +7,8 @@ export quick_sort3; type lteq<T> = block(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 = len::<T>(a); let a_ix: uint = 0u; @@ -32,13 +32,13 @@ fn merge_sort<@T>(le: lteq<T>, v: [T]) -> [T] { ret merge::<T>(le, merge_sort::<T>(le, a), merge_sort::<T>(le, b)); } -fn swap<@T>(arr: [mutable T], 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: [mutable T], left: uint, right: 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); @@ -55,7 +55,7 @@ fn part<@T>(compare_func: lteq<T>, arr: [mutable T], left: uint, right: uint, ret storage_index; } -fn qsort<@T>(compare_func: lteq<T>, arr: [mutable T], left: uint, +fn qsort<T>(compare_func: lteq<T>, arr: [mutable T], left: uint, right: uint) { if right > left { let pivot = (left + right) / 2u; @@ -68,7 +68,7 @@ fn qsort<@T>(compare_func: lteq<T>, arr: [mutable T], left: uint, } } -fn quick_sort<@T>(compare_func: lteq<T>, arr: [mutable T]) { +fn quick_sort<T>(compare_func: lteq<T>, arr: [mutable T]) { if len::<T>(arr) == 0u { ret; } qsort::<T>(compare_func, arr, 0u, len::<T>(arr) - 1u); } @@ -78,7 +78,7 @@ fn quick_sort<@T>(compare_func: lteq<T>, arr: [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: [mutable T], left: int, right: int) { if right <= left { ret; } let v: T = arr[right]; @@ -126,8 +126,8 @@ 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>, - arr: [mutable T]) { +fn quick_sort3<T>(compare_func_lt: lteq<T>, compare_func_eq: lteq<T>, + arr: [mutable T]) { if len::<T>(arr) == 0u { ret; } qsort3::<T>(compare_func_lt, compare_func_eq, arr, 0, (len::<T>(arr) as int) - 1); diff --git a/src/lib/task.rs b/src/lib/task.rs index 1c462108b2e..0a44026ea52 100644 --- a/src/lib/task.rs +++ b/src/lib/task.rs @@ -95,16 +95,16 @@ fn unpin() { rustrt2::unpin_task(); } fn set_min_stack(stack_size: uint) { rustrt2::set_min_stack(stack_size); } -fn spawn<~T>(-data: T, f: fn(T)) -> task { +fn spawn<unique T>(-data: T, f: fn(T)) -> task { spawn_inner2(data, f, none) } -fn spawn_notify<~T>(-data: T, f: fn(T), +fn spawn_notify<unique T>(-data: T, f: fn(T), notify: comm::chan<task_notification>) -> task { spawn_inner2(data, f, some(notify)) } -fn spawn_joinable<~T>(-data: T, f: fn(T)) -> joinable_task { +fn spawn_joinable<unique T>(-data: T, f: fn(T)) -> joinable_task { let p = comm::port::<task_notification>(); let id = spawn_notify(data, f, comm::chan::<task_notification>(p)); ret (id, p); @@ -120,11 +120,11 @@ fn spawn_joinable<~T>(-data: T, f: fn(T)) -> joinable_task { // // After the transition this should all be rewritten. -fn spawn_inner2<~T>(-data: T, f: fn(T), - notify: option<comm::chan<task_notification>>) +fn spawn_inner2<unique T>(-data: T, f: fn(T), + notify: option<comm::chan<task_notification>>) -> task_id { - fn wrapper<~T>(-data: *u8, f: fn(T)) { + fn wrapper<unique T>(-data: *u8, f: fn(T)) { let data: ~T = unsafe::reinterpret_cast(data); f(*data); } diff --git a/src/lib/test.rs b/src/lib/test.rs index e8df06c0c2c..8c76d397d95 100644 --- a/src/lib/test.rs +++ b/src/lib/test.rs @@ -41,13 +41,13 @@ type test_name = str; // the test succeeds; if the function fails then the test fails. We // may need to come up with a more clever definition of test in order // to support isolation of tests into tasks. -type test_fn<@T> = T; +type test_fn<T> = T; type default_test_fn = test_fn<fn()>; // The definition of a single test. A test runner will run a list of // these. -type test_desc<@T> = { +type test_desc<T> = { name: test_name, fn: test_fn<T>, ignore: bool @@ -100,7 +100,7 @@ type joinable = (task, comm::port<task::task_notification>); // In cases where test functions are closures it is not ok to just dump them // into a task and run them, so this transformation gives the caller a chance // to create the test task. -type test_to_task<@T> = fn@(test_fn<T>) -> joinable; +type test_to_task<T> = fn@(test_fn<T>) -> joinable; // A simple console test runner fn run_tests_console(opts: test_opts, @@ -108,7 +108,7 @@ fn run_tests_console(opts: test_opts, run_tests_console_(opts, tests, default_test_to_task) } -fn run_tests_console_<@T>(opts: test_opts, tests: [test_desc<T>], +fn run_tests_console_<T>(opts: test_opts, tests: [test_desc<T>], to_task: test_to_task<T>) -> bool { type test_state = @@ -120,7 +120,7 @@ fn run_tests_console_<@T>(opts: test_opts, tests: [test_desc<T>], mutable ignored: uint, mutable failures: [test_desc<T>]}; - fn callback<@T>(event: testevent<T>, st: test_state) { + fn callback<T>(event: testevent<T>, st: test_state) { alt event { te_filtered(filtered_tests) { st.total = vec::len(filtered_tests); @@ -207,13 +207,13 @@ fn run_tests_console_<@T>(opts: test_opts, tests: [test_desc<T>], fn use_color() -> bool { ret get_concurrency() == 1u; } -tag testevent<@T> { +tag testevent<T> { te_filtered([test_desc<T>]); te_wait(test_desc<T>); te_result(test_desc<T>, test_result); } -fn run_tests<@T>(opts: test_opts, tests: [test_desc<T>], +fn run_tests<T>(opts: test_opts, tests: [test_desc<T>], to_task: test_to_task<T>, callback: fn@(testevent<T>)) { @@ -248,7 +248,7 @@ fn run_tests<@T>(opts: test_opts, tests: [test_desc<T>], fn get_concurrency() -> uint { rustrt::sched_threads() } -fn filter_tests<@T>(opts: test_opts, +fn filter_tests<T>(opts: test_opts, tests: [test_desc<T>]) -> [test_desc<T>] { let filtered = tests; @@ -262,7 +262,7 @@ fn filter_tests<@T>(opts: test_opts, option::none. { "" } }; - fn filter_fn<@T>(test: test_desc<T>, filter_str: str) -> + fn filter_fn<T>(test: test_desc<T>, filter_str: str) -> option::t<test_desc<T>> { if str::find(test.name, filter_str) >= 0 { ret option::some(test); @@ -278,7 +278,7 @@ fn filter_tests<@T>(opts: test_opts, filtered = if !opts.run_ignored { filtered } else { - fn filter<@T>(test: test_desc<T>) -> option::t<test_desc<T>> { + fn filter<T>(test: test_desc<T>) -> option::t<test_desc<T>> { if test.ignore { ret option::some({name: test.name, fn: test.fn, @@ -292,7 +292,7 @@ fn filter_tests<@T>(opts: test_opts, // Sort the tests alphabetically filtered = { - fn lteq<@T>(t1: test_desc<T>, t2: test_desc<T>) -> bool { + fn lteq<T>(t1: test_desc<T>, t2: test_desc<T>) -> bool { str::lteq(t1.name, t2.name) } sort::merge_sort(bind lteq(_, _), filtered) @@ -301,9 +301,9 @@ fn filter_tests<@T>(opts: test_opts, ret filtered; } -type test_future<@T> = {test: test_desc<T>, wait: fn@() -> test_result}; +type test_future<T> = {test: test_desc<T>, wait: fn@() -> test_result}; -fn run_test<@T>(test: test_desc<T>, +fn run_test<T>(test: test_desc<T>, to_task: test_to_task<T>) -> test_future<T> { if !test.ignore { let test_task = to_task(test.fn); diff --git a/src/lib/treemap.rs b/src/lib/treemap.rs index c9817c2d730..a361bd20cdb 100644 --- a/src/lib/treemap.rs +++ b/src/lib/treemap.rs @@ -16,13 +16,13 @@ export insert; export find; export traverse; -tag tree_node<@K, @V> { empty; node(@K, @V, treemap<K, V>, treemap<K, V>); } +tag tree_node<K, V> { empty; node(@K, @V, treemap<K, V>, treemap<K, V>); } -type treemap<@K, @V> = @mutable tree_node<K, V>; +type treemap<K, V> = @mutable tree_node<K, V>; -fn init<@K, @V>() -> treemap<K, V> { @mutable empty } +fn init<K, V>() -> treemap<K, V> { @mutable empty } -fn insert<@K, @V>(m: treemap<K, V>, k: K, v: V) { +fn insert<K, V>(m: treemap<K, V>, k: K, v: V) { alt m { @empty. { *m = node(@k, @v, @mutable empty, @mutable empty); } @node(@kk, _, _, _) { @@ -36,7 +36,7 @@ fn insert<@K, @V>(m: treemap<K, V>, k: K, v: V) { } } -fn find<@K, @V>(m: treemap<K, V>, k: K) -> option<V> { +fn find<K, V>(m: treemap<K, V>, k: K) -> option<V> { alt *m { empty. { none } node(@kk, @v, _, _) { @@ -52,7 +52,7 @@ fn find<@K, @V>(m: treemap<K, V>, k: K) -> option<V> { } // Performs an in-order traversal -fn traverse<@K, @V>(m: treemap<K, V>, f: fn@(K, V)) { +fn traverse<K, V>(m: treemap<K, V>, f: fn@(K, V)) { alt *m { empty. { } node(k, v, _, _) { diff --git a/src/lib/unsafe.rs b/src/lib/unsafe.rs index 41aa02b8c9d..5194392d1be 100644 --- a/src/lib/unsafe.rs +++ b/src/lib/unsafe.rs @@ -5,10 +5,10 @@ native "rust-intrinsic" mod rusti { } native "c-stack-cdecl" mod rustrt { - fn leak<@T>(-thing: T); + fn leak<T>(-thing: T); } // Casts the value at `src` to U. The two types must have the same length. -fn reinterpret_cast<T, @U>(src: T) -> U { ret rusti::cast(src); } +fn reinterpret_cast<T, U>(src: T) -> U { ret rusti::cast(src); } -fn leak<@T>(-thing: T) { rustrt::leak(thing); } +fn leak<T>(-thing: T) { rustrt::leak(thing); } diff --git a/src/lib/util.rs b/src/lib/util.rs index b67bd469c7f..3c441f1656f 100644 --- a/src/lib/util.rs +++ b/src/lib/util.rs @@ -1,5 +1,5 @@ -pure fn id<@T>(x: T) -> T { x } +pure fn id<T>(x: T) -> T { x } fn unreachable() -> ! { fail "Internal error: entered unreachable code"; diff --git a/src/lib/vec.rs b/src/lib/vec.rs index 0b6f2de0178..e0184767e9d 100644 --- a/src/lib/vec.rs +++ b/src/lib/vec.rs @@ -18,7 +18,7 @@ native "c-stack-cdecl" mod rustrt { } /// Reserves space for `n` elements in the given vector. -fn reserve<@T>(&v: [mutable? T], n: uint) { +fn reserve<T>(&v: [mutable? T], n: uint) { rustrt::vec_reserve_shared(sys::get_type_desc::<T>(), v, n); } @@ -26,7 +26,7 @@ pure fn len<T>(v: [mutable? T]) -> uint { unchecked { rusti::vec_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; @@ -35,7 +35,7 @@ fn init_fn<@T>(op: init_op<T>, n_elts: uint) -> [T] { } // TODO: Remove me once we have slots. -fn init_fn_mut<@T>(op: init_op<T>, n_elts: uint) -> [mutable T] { +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; @@ -43,7 +43,7 @@ fn init_fn_mut<@T>(op: init_op<T>, n_elts: uint) -> [mutable T] { 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; @@ -52,7 +52,7 @@ fn init_elt<@T>(t: T, n_elts: uint) -> [T] { } // TODO: Remove me once we have slots. -fn init_elt_mut<@T>(t: T, n_elts: uint) -> [mutable T] { +fn init_elt_mut<T>(t: T, n_elts: uint) -> [mutable T] { let v = [mutable]; reserve(v, n_elts); let i: uint = 0u; @@ -62,14 +62,14 @@ fn init_elt_mut<@T>(t: T, n_elts: uint) -> [mutable T] { // FIXME: Possible typestate postcondition: // len(result) == len(v) (needs issue #586) -fn to_mut<@T>(v: [T]) -> [mutable T] { +fn to_mut<T>(v: [T]) -> [mutable T] { let vres = [mutable]; for t: T in v { vres += [mutable t]; } ret vres; } // Same comment as from_mut -fn from_mut<@T>(v: [mutable T]) -> [T] { +fn from_mut<T>(v: [mutable T]) -> [T] { let vres = []; for t: T in v { vres += [t]; } ret vres; @@ -87,26 +87,26 @@ pure fn is_not_empty<T>(v: [mutable? T]) -> bool { ret !is_empty(v); } // Accessors /// Returns the first element of a vector -fn head<@T>(v: [mutable? T]) : 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: [mutable? T]) : is_not_empty(v) -> [T] { +fn tail<T>(v: [mutable? T]) : is_not_empty(v) -> [T] { ret slice(v, 1u, len(v)); } /// Returns the last element of `v`. -fn last<@T>(v: [mutable? T]) -> 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 the last element of a non-empty vector `v`. -fn last_total<@T>(v: [mutable? T]) : is_not_empty(v) -> T { +fn last_total<T>(v: [mutable? T]) : is_not_empty(v) -> T { ret v[len(v) - 1u]; } /// Returns a copy of the elements from [`start`..`end`) from `v`. -fn slice<@T>(v: [mutable? T], 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 = []; @@ -117,7 +117,7 @@ fn slice<@T>(v: [mutable? T], start: uint, end: uint) -> [T] { } // TODO: Remove me once we have slots. -fn slice_mut<@T>(v: [mutable? T], start: uint, end: uint) -> [mutable T] { +fn slice_mut<T>(v: [mutable? T], start: uint, end: uint) -> [mutable T] { assert (start <= end); assert (end <= len(v)); let result = [mutable]; @@ -130,7 +130,7 @@ fn slice_mut<@T>(v: [mutable? T], start: uint, end: uint) -> [mutable T] { // Mutators -fn shift<@T>(&v: [mutable? T]) -> T { +fn shift<T>(&v: [mutable? T]) -> T { let ln = len::<T>(v); assert (ln > 0u); let e = v[0]; @@ -139,7 +139,7 @@ fn shift<@T>(&v: [mutable? T]) -> T { } // TODO: Write this, unsafely, in a way that's not O(n). -fn pop<@T>(&v: [mutable? T]) -> T { +fn pop<T>(&v: [mutable? T]) -> T { let ln = len(v); assert (ln > 0u); ln -= 1u; @@ -154,14 +154,14 @@ fn pop<@T>(&v: [mutable? T]) -> T { // Appending /// Expands the given vector in-place by appending `n` copies of `initval`. -fn grow<@T>(&v: [T], n: uint, initval: T) { +fn grow<T>(&v: [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], n: uint, initval: T) { +fn grow_mut<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 += [mutable initval]; i += 1u; } @@ -169,7 +169,7 @@ fn grow_mut<@T>(&v: [mutable T], n: uint, initval: T) { /// Calls `f` `n` times and appends the results of these calls to the given /// vector. -fn grow_fn<@T>(&v: [T], n: uint, init_fn: fn(uint) -> T) { +fn grow_fn<T>(&v: [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; } @@ -178,7 +178,7 @@ fn grow_fn<@T>(&v: [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], index: uint, initval: T, val: T) { +fn grow_set<T>(&v: [mutable T], index: uint, initval: T, val: T) { if index >= len(v) { grow_mut(v, index - len(v) + 1u, initval); } v[index] = val; } @@ -186,7 +186,7 @@ fn grow_set<@T>(&v: [mutable T], index: uint, initval: T, val: T) { // Functional utilities -fn map<@T, @U>(f: block(T) -> U, v: [mutable? T]) -> [U] { +fn map<T, U>(f: block(T) -> U, v: [mutable? T]) -> [U] { let result = []; reserve(result, len(v)); for elem: T in v { @@ -196,7 +196,7 @@ fn map<@T, @U>(f: block(T) -> U, v: [mutable? T]) -> [U] { ret result; } -fn map2<@T, @U, @V>(f: block(T, U) -> V, v0: [T], v1: [U]) -> [V] { +fn map2<T, U, V>(f: block(T, U) -> V, v0: [T], v1: [U]) -> [V] { let v0_len = len::<T>(v0); if v0_len != len::<U>(v1) { fail; } let u: [V] = []; @@ -205,7 +205,7 @@ fn map2<@T, @U, @V>(f: block(T, U) -> V, v0: [T], v1: [U]) -> [V] { ret u; } -fn filter_map<@T, @U>(f: block(T) -> option::t<U>, v: [mutable? T]) -> [U] { +fn filter_map<T, U>(f: block(T) -> option::t<U>, v: [mutable? T]) -> [U] { let result = []; for elem: T in v { let elem2 = elem; // satisfies alias checker @@ -217,7 +217,7 @@ fn filter_map<@T, @U>(f: block(T) -> option::t<U>, v: [mutable? T]) -> [U] { ret result; } -fn filter<@T>(f: block(T) -> bool, v: [mutable? T]) -> [T] { +fn filter<T>(f: block(T) -> bool, v: [mutable? T]) -> [T] { let result = []; for elem: T in v { let elem2 = elem; // satisfies alias checker @@ -228,7 +228,7 @@ fn filter<@T>(f: block(T) -> bool, v: [mutable? T]) -> [T] { ret result; } -fn foldl<@T, @U>(p: block(U, T) -> U, z: U, v: [mutable? T]) -> U { +fn foldl<T, U>(p: block(U, T) -> U, z: U, v: [mutable? T]) -> U { let sz = len(v); if sz == 0u { ret z; } let first = v[0]; @@ -257,12 +257,12 @@ fn count<T>(x: T, v: [mutable? T]) -> uint { ret cnt; } -fn find<@T>(f: block(T) -> bool, v: [T]) -> option::t<T> { +fn find<T>(f: block(T) -> bool, v: [T]) -> option::t<T> { for elt: T in v { if f(elt) { ret some(elt); } } ret none; } -fn position<@T>(x: T, v: [T]) -> option::t<uint> { +fn position<T>(x: T, v: [T]) -> option::t<uint> { let i: uint = 0u; while i < len(v) { if x == v[i] { ret some::<uint>(i); } i += 1u; } ret none; @@ -282,13 +282,13 @@ pure fn same_length<T, U>(xs: [T], ys: [U]) -> bool { // saying the two result lists have the same length -- or, could // return a nominal record with a constraint saying that, instead of // returning a tuple (contingent on issue #869) -fn unzip<@T, @U>(v: [(T, U)]) -> ([T], [U]) { +fn unzip<T, U>(v: [(T, U)]) -> ([T], [U]) { let as = [], bs = []; for (a, b) in v { as += [a]; bs += [b]; } ret (as, bs); } -fn zip<@T, @U>(v: [T], u: [U]) : same_length(v, u) -> [(T, U)] { +fn zip<T, U>(v: [T], u: [U]) : same_length(v, u) -> [(T, U)] { let zipped = []; let sz = len(v), i = 0u; assert (sz == len(u)); @@ -297,14 +297,14 @@ fn zip<@T, @U>(v: [T], u: [U]) : same_length(v, u) -> [(T, U)] { } // Swaps two elements in a vector -fn swap<@T>(v: [mutable T], a: uint, b: uint) { +fn swap<T>(v: [mutable T], a: uint, b: uint) { let t: T = v[a]; v[a] = v[b]; v[b] = t; } // In place vector reversal -fn reverse<@T>(v: [mutable T]) { +fn reverse<T>(v: [mutable T]) { let i: uint = 0u; let ln = len::<T>(v); while i < ln / 2u { swap(v, i, ln - i - 1u); i += 1u; } @@ -312,7 +312,7 @@ fn reverse<@T>(v: [mutable T]) { // Functional vector reversal. Returns a reversed copy of v. -fn reversed<@T>(v: [T]) -> [T] { +fn reversed<T>(v: [T]) -> [T] { let rs: [T] = []; let i = len::<T>(v); if i == 0u { ret rs; } else { i -= 1u; } @@ -336,7 +336,7 @@ fn enum_uints(start: uint, end: uint) : uint::le(start, end) -> [uint] { ret r; } -fn eachi<@T>(f: block(T, uint) -> (), v: [mutable? T]) { +fn eachi<T>(f: block(T, uint) -> (), v: [mutable? T]) { let i = 0u; let l = len(v); while (i < l) { @@ -347,7 +347,7 @@ fn eachi<@T>(f: block(T, uint) -> (), v: [mutable? T]) { } // Iterate over a list with with the indexes -fn iter2<@T>(v: [T], it: block(uint, T)) { +fn iter2<T>(v: [T], it: block(uint, T)) { let i = 0u; for x in v { it(i, x); i += 1u; } } @@ -355,23 +355,23 @@ fn iter2<@T>(v: [T], it: block(uint, T)) { mod unsafe { type vec_repr = {mutable fill: uint, mutable alloc: uint, data: u8}; - unsafe fn from_buf<@T>(ptr: *T, elts: uint) -> [T] { + unsafe fn from_buf<T>(ptr: *T, elts: uint) -> [T] { ret rustrt::vec_from_buf_shared(sys::get_type_desc::<T>(), ptr, elts); } - unsafe fn set_len<@T>(&v: [T], new_len: uint) { + unsafe fn set_len<T>(&v: [T], new_len: uint) { let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); (**repr).fill = new_len * sys::size_of::<T>(); } - unsafe fn to_ptr<@T>(v: [T]) -> *T { + unsafe fn to_ptr<T>(v: [T]) -> *T { let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); ret ::unsafe::reinterpret_cast(addr_of((**repr).data)); } } -unsafe fn to_ptr<@T>(v: [T]) -> *T { ret unsafe::to_ptr(v); } +unsafe fn to_ptr<T>(v: [T]) -> *T { ret unsafe::to_ptr(v); } // Local Variables: // mode: rust; diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index 0beda53a293..d2c6b5f5a5d 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -55,25 +55,25 @@ mod map_reduce { export reducer; export map_reduce; - type putter<~K, ~V> = fn(K, V); + type putter<unique K, unique V> = fn(K, V); // FIXME: the first K1 parameter should probably be a -, but that // doesn't parse at the moment. - type mapper<~K1, ~K2, ~V> = fn(K1, putter<K2, V>); + type mapper<unique K1, unique K2, unique V> = fn(K1, putter<K2, V>); - type getter<~V> = fn() -> option<V>; + type getter<unique V> = fn() -> option<V>; - type reducer<~K, ~V> = fn(K, getter<V>); + type reducer<unique K, unique V> = fn(K, getter<V>); - tag ctrl_proto<~K, ~V> { + tag ctrl_proto<unique K, unique V> { find_reducer(K, chan<chan<reduce_proto<V>>>); mapper_done; } - tag reduce_proto<~V> { emit_val(V); done; ref; release; } + tag reduce_proto<unique V> { emit_val(V); done; ref; release; } - fn start_mappers<~K1, ~K2, - ~V>(map: mapper<K1, K2, V>, + fn start_mappers<unique K1, unique K2, + unique V>(map: mapper<K1, K2, V>, ctrl: chan<ctrl_proto<K2, V>>, inputs: [K1]) -> [joinable_task] { let tasks = []; @@ -84,14 +84,15 @@ mod map_reduce { ret tasks; } - fn map_task<~K1, ~K2, - ~V>(-map: mapper<K1, K2, V>, -ctrl: chan<ctrl_proto<K2, V>>, + fn map_task<unique K1, unique K2, + unique V>(-map: mapper<K1, K2, V>, + -ctrl: chan<ctrl_proto<K2, V>>, -input: K1) { // log_err "map_task " + input; let intermediates = treemap::init(); - fn emit<~K2, - ~V>(im: treemap::treemap<K2, chan<reduce_proto<V>>>, + fn emit<unique K2, + unique V>(im: treemap::treemap<K2, chan<reduce_proto<V>>>, ctrl: chan<ctrl_proto<K2, V>>, key: K2, val: V) { let c; alt treemap::find(im, key) { @@ -109,15 +110,15 @@ mod map_reduce { map(input, bind emit(intermediates, ctrl, _, _)); - fn finish<~K, ~V>(_k: K, v: chan<reduce_proto<V>>) { + fn finish<unique K, unique V>(_k: K, v: chan<reduce_proto<V>>) { send(v, release); } treemap::traverse(intermediates, finish); send(ctrl, mapper_done); } - fn reduce_task<~K, - ~V>(-reduce: reducer<K, V>, -key: K, + fn reduce_task<unique K, + unique V>(-reduce: reducer<K, V>, -key: K, -out: chan<chan<reduce_proto<V>>>) { let p = port(); @@ -126,7 +127,8 @@ mod map_reduce { let ref_count = 0; let is_done = false; - fn get<~V>(p: port<reduce_proto<V>>, &ref_count: int, &is_done: bool) + fn get<unique V>(p: port<reduce_proto<V>>, + &ref_count: int, &is_done: bool) -> option<V> { while !is_done || ref_count > 0 { alt recv(p) { @@ -148,8 +150,8 @@ mod map_reduce { reduce(key, bind get(p, ref_count, is_done)); } - fn map_reduce<~K1, ~K2, - ~V>(map: mapper<K1, K2, V>, reduce: reducer<K2, V>, + fn map_reduce<unique K1, unique K2, + unique V>(map: mapper<K1, K2, V>, reduce: reducer<K2, V>, inputs: [K1]) { let ctrl = port(); @@ -192,7 +194,9 @@ mod map_reduce { } } - fn finish<~K, ~V>(_k: K, v: chan<reduce_proto<V>>) { send(v, done); } + fn finish<unique K, unique V>(_k: K, v: chan<reduce_proto<V>>) { + send(v, done); + } treemap::traverse(reducers, finish); for t in tasks { task::join(t); } diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs index b40cf0770c0..e2178668829 100644 --- a/src/test/compile-fail/unique-unique-kind.rs +++ b/src/test/compile-fail/unique-unique-kind.rs @@ -1,6 +1,6 @@ // error-pattern: needed unique type -fn f<~T>(i: T) { +fn f<unique T>(i: T) { } fn main() { diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs index 467c50e14d6..dd077da4813 100644 --- a/src/test/compile-fail/unique-vec-res.rs +++ b/src/test/compile-fail/unique-vec-res.rs @@ -4,7 +4,7 @@ resource r(i: @mutable int) { *i = *i + 1; } -fn f<@T>(i: [T], j: [T]) { +fn f<T>(i: [T], j: [T]) { // Shouldn't be able to do this copy of j let k = i + j; } diff --git a/src/test/compile-fail/use-after-send.rs b/src/test/compile-fail/use-after-send.rs index c879bdef1a9..2a38a5f6d04 100644 --- a/src/test/compile-fail/use-after-send.rs +++ b/src/test/compile-fail/use-after-send.rs @@ -1,5 +1,5 @@ // error-pattern: Unsatisfied precondition constraint -fn send<~T>(ch: _chan<T>, -data: T) { log ch; log data; fail; } +fn send<unique T>(ch: _chan<T>, -data: T) { log ch; log data; fail; } type _chan<T> = int; // Tests that "log message;" is flagged as using diff --git a/src/test/run-fail/bug-811.rs b/src/test/run-fail/bug-811.rs index f83667ccf87..92e9062534a 100644 --- a/src/test/run-fail/bug-811.rs +++ b/src/test/run-fail/bug-811.rs @@ -4,8 +4,8 @@ fn test00_start(ch: chan_t<int>, message: int) { send(ch, message); } type task_id = int; type port_id = int; -type chan_t<~T> = {task: task_id, port: port_id}; +type chan_t<unique T> = {task: task_id, port: port_id}; -fn send<~T>(ch: chan_t<T>, -data: T) { fail; } +fn send<unique T>(ch: chan_t<T>, -data: T) { fail; } fn main() { fail "quux"; } diff --git a/src/test/run-fail/port-type.rs b/src/test/run-fail/port-type.rs index 75474a17a75..a648f0b560a 100644 --- a/src/test/run-fail/port-type.rs +++ b/src/test/run-fail/port-type.rs @@ -5,7 +5,7 @@ import std::comm::port; import std::comm::send; import std::comm::recv; -fn echo<~T>(c: chan<T>, oc: chan<chan<T>>) { +fn echo<unique T>(c: chan<T>, oc: chan<chan<T>>) { // Tests that the type argument in port gets // visited let p = port::<T>(); diff --git a/src/test/run-pass/alloca-from-derived-tydesc.rs b/src/test/run-pass/alloca-from-derived-tydesc.rs index 57e31935738..6077bbf6723 100644 --- a/src/test/run-pass/alloca-from-derived-tydesc.rs +++ b/src/test/run-pass/alloca-from-derived-tydesc.rs @@ -2,6 +2,6 @@ tag option<T> { some(T); none; } type r<T> = {mutable v: [option<T>]}; -fn f<@T>() -> [T] { ret []; } +fn f<T>() -> [T] { ret []; } fn main() { let r: r<int> = {mutable v: []}; r.v = f(); } diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs index 8def06bfe98..4900df4aed0 100644 --- a/src/test/run-pass/auto-instantiate.rs +++ b/src/test/run-pass/auto-instantiate.rs @@ -2,6 +2,6 @@ // -*- rust -*- -fn f<@T, @U>(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; } +fn f<T, U>(x: T, y: U) -> {a: T, b: U} { ret {a: x, b: y}; } fn main() { log f({x: 3, y: 4, z: 5}, 4).a.x; log f(5, 6).a; } diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs index 19f5f13e5a6..dc875c3133d 100644 --- a/src/test/run-pass/autobind.rs +++ b/src/test/run-pass/autobind.rs @@ -2,7 +2,7 @@ // because it would have to convert them to shared closures // xfail-test -fn f<@T>(x: [T]) -> T { ret x[0]; } +fn f<T>(x: [T]) -> T { ret x[0]; } fn g(act: fn([int]) -> int) -> int { ret act([1, 2, 3]); } diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs index 54558d1785a..5dc0c670dca 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -2,7 +2,7 @@ type box<T> = {c: @T}; -fn unbox<@T>(b: box<T>) -> T { ret *b.c; } +fn unbox<T>(b: box<T>) -> T { ret *b.c; } fn main() { let foo: int = 17; diff --git a/src/test/run-pass/expr-alt-generic-box2.rs b/src/test/run-pass/expr-alt-generic-box2.rs index 556e00adc54..53cab4546e2 100644 --- a/src/test/run-pass/expr-alt-generic-box2.rs +++ b/src/test/run-pass/expr-alt-generic-box2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, eq: compare<T>) { let actual: T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-alt-generic-unique1.rs b/src/test/run-pass/expr-alt-generic-unique1.rs index 6548c98b469..e8b949e9410 100644 --- a/src/test/run-pass/expr-alt-generic-unique1.rs +++ b/src/test/run-pass/expr-alt-generic-unique1.rs @@ -3,7 +3,7 @@ // -*- rust -*- type compare<T> = fn@(~T, ~T) -> bool; -fn test_generic<@T>(expected: ~T, eq: compare<T>) { +fn test_generic<T>(expected: ~T, eq: compare<T>) { let actual: ~T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-alt-generic-unique2.rs b/src/test/run-pass/expr-alt-generic-unique2.rs index f56070a6444..ee0be17ffa2 100644 --- a/src/test/run-pass/expr-alt-generic-unique2.rs +++ b/src/test/run-pass/expr-alt-generic-unique2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, eq: compare<T>) { let actual: T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-alt-generic.rs b/src/test/run-pass/expr-alt-generic.rs index b2d686db43d..c3df90f7fdc 100644 --- a/src/test/run-pass/expr-alt-generic.rs +++ b/src/test/run-pass/expr-alt-generic.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, eq: compare<T>) { let actual: T = alt true { true { expected } }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs index 63526729f5e..9a54cd20a8b 100644 --- a/src/test/run-pass/expr-block-generic-box2.rs +++ b/src/test/run-pass/expr-block-generic-box2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, eq: compare<T>) { let actual: T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs index 6415558fb1e..1055cd16221 100644 --- a/src/test/run-pass/expr-block-generic-unique1.rs +++ b/src/test/run-pass/expr-block-generic-unique1.rs @@ -3,7 +3,7 @@ // -*- rust -*- type compare<T> = fn@(~T, ~T) -> bool; -fn test_generic<@T>(expected: ~T, eq: compare<T>) { +fn test_generic<T>(expected: ~T, eq: compare<T>) { let actual: ~T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs index 6a1716493f4..3325c8f2384 100644 --- a/src/test/run-pass/expr-block-generic-unique2.rs +++ b/src/test/run-pass/expr-block-generic-unique2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, eq: compare<T>) { let actual: T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs index 147ae500b7c..8e270a56edd 100644 --- a/src/test/run-pass/expr-block-generic.rs +++ b/src/test/run-pass/expr-block-generic.rs @@ -6,7 +6,7 @@ // Tests for standalone blocks as expressions with dynamic type sizes type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, eq: compare<T>) { let actual: T = { expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs index 42b57a7c193..549d3a69aea 100644 --- a/src/test/run-pass/expr-if-generic-box2.rs +++ b/src/test/run-pass/expr-if-generic-box2.rs @@ -4,7 +4,7 @@ // -*- rust -*- type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, not_expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, not_expected: T, eq: compare<T>) { let actual: T = if true { expected } else { not_expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs index 4ccef87fb8c..b2b62523e55 100644 --- a/src/test/run-pass/expr-if-generic.rs +++ b/src/test/run-pass/expr-if-generic.rs @@ -6,7 +6,7 @@ // Tests for if as expressions with dynamic type sizes type compare<T> = fn@(T, T) -> bool; -fn test_generic<@T>(expected: T, not_expected: T, eq: compare<T>) { +fn test_generic<T>(expected: T, not_expected: T, eq: compare<T>) { let actual: T = if true { expected } else { not_expected }; assert (eq(expected, actual)); } diff --git a/src/test/run-pass/fixed-point-bind-box.rs b/src/test/run-pass/fixed-point-bind-box.rs index 531c59fffbc..a9686c83645 100644 --- a/src/test/run-pass/fixed-point-bind-box.rs +++ b/src/test/run-pass/fixed-point-bind-box.rs @@ -1,8 +1,8 @@ -fn fix_help<A, @B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B { +fn fix_help<A, B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B { ret f(bind fix_help(f, _), x); } -fn fix<A, @B>(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { +fn fix<A, B>(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { ret bind fix_help(f, _); } diff --git a/src/test/run-pass/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs index aaee23ff35b..9e14ab19228 100644 --- a/src/test/run-pass/fixed-point-bind-unique.rs +++ b/src/test/run-pass/fixed-point-bind-unique.rs @@ -1,8 +1,8 @@ -fn fix_help<A, ~B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B { +fn fix_help<A, unique B>(f: fn(fn@(A) -> B, A) -> B, x: A) -> B { ret f(bind fix_help(f, _), x); } -fn fix<A, ~B>(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { +fn fix<A, unique B>(f: fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { ret bind fix_help(f, _); } diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs index f007d9471e2..19c59529870 100644 --- a/src/test/run-pass/fn-bare-spawn.rs +++ b/src/test/run-pass/fn-bare-spawn.rs @@ -1,6 +1,6 @@ // This is what the signature to spawn should look like with bare functions -fn spawn<~T>(val: T, f: fn(T)) { +fn spawn<unique T>(val: T, f: fn(T)) { f(val); } diff --git a/src/test/run-pass/foreach-unique-drop.rs b/src/test/run-pass/foreach-unique-drop.rs index f0b65a3091f..bd33b4bbc51 100644 --- a/src/test/run-pass/foreach-unique-drop.rs +++ b/src/test/run-pass/foreach-unique-drop.rs @@ -1,5 +1,5 @@ -obj ob<@K>(k: K) { +obj ob<K>(k: K) { fn foo(it: block(~{a: K})) { it(~{a: k}); } } diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs index cf7e8ba499c..9624eca31ac 100644 --- a/src/test/run-pass/generic-alias-box.rs +++ b/src/test/run-pass/generic-alias-box.rs @@ -1,6 +1,6 @@ -fn id<@T>(t: T) -> T { ret t; } +fn id<T>(t: T) -> T { ret t; } fn main() { let expected = @100; diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs index e62ab1d318b..dbcbdcfae1a 100644 --- a/src/test/run-pass/generic-alias-unique.rs +++ b/src/test/run-pass/generic-alias-unique.rs @@ -1,6 +1,6 @@ -fn id<~T>(t: T) -> T { ret t; } +fn id<unique T>(t: T) -> T { ret t; } fn main() { let expected = ~100; diff --git a/src/test/run-pass/generic-bind-2.rs b/src/test/run-pass/generic-bind-2.rs index 8d584534fd8..8b03cc68f0f 100644 --- a/src/test/run-pass/generic-bind-2.rs +++ b/src/test/run-pass/generic-bind-2.rs @@ -1,6 +1,6 @@ -fn id<@T>(t: T) -> T { ret t; } +fn id<T>(t: T) -> T { ret t; } fn main() { let t = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7}; diff --git a/src/test/run-pass/generic-bind.rs b/src/test/run-pass/generic-bind.rs index 320b22c0bee..47e0ffc973e 100644 --- a/src/test/run-pass/generic-bind.rs +++ b/src/test/run-pass/generic-bind.rs @@ -1,6 +1,6 @@ -fn id<@T>(t: T) -> T { ret t; } +fn id<T>(t: T) -> T { ret t; } fn main() { let t = {_0: 1, _1: 2, _2: 3, _3: 4, _4: 5, _5: 6, _6: 7}; diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs index 4f132a79a81..3e37834f47b 100644 --- a/src/test/run-pass/generic-box.rs +++ b/src/test/run-pass/generic-box.rs @@ -1,6 +1,6 @@ -fn box<@T>(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { ret @x; } +fn box<T>(x: {x: T, y: T, z: T}) -> @{x: T, y: T, z: T} { ret @x; } fn main() { let x: @{x: int, y: int, z: int} = box::<int>({x: 1, y: 2, z: 3}); diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs index a889021378f..50834dd2b1f 100644 --- a/src/test/run-pass/generic-derived-type.rs +++ b/src/test/run-pass/generic-derived-type.rs @@ -1,8 +1,8 @@ -fn g<@X>(x: X) -> X { ret x; } +fn g<X>(x: X) -> X { ret x; } -fn f<@T>(t: T) -> {a: T, b: T} { +fn f<T>(t: T) -> {a: T, b: T} { type pair = {a: T, b: T}; let x: pair = {a: t, b: t}; diff --git a/src/test/run-pass/generic-drop-glue.rs b/src/test/run-pass/generic-drop-glue.rs index f866e2077ab..ad89b7fe556 100644 --- a/src/test/run-pass/generic-drop-glue.rs +++ b/src/test/run-pass/generic-drop-glue.rs @@ -1,5 +1,5 @@ -fn f<@T>(t: T) { let t1: T = t; } +fn f<T>(t: T) { let t1: T = t; } fn main() { let x = {x: @10, y: @12}; f(x); } diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs index c1ce4257b14..7573bff74e8 100644 --- a/src/test/run-pass/generic-exterior-box.rs +++ b/src/test/run-pass/generic-exterior-box.rs @@ -2,7 +2,7 @@ type recbox<T> = {x: @T}; -fn reclift<@T>(t: T) -> recbox<T> { ret {x: @t}; } +fn reclift<T>(t: T) -> recbox<T> { ret {x: @t}; } fn main() { let foo: int = 17; diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs index 16f9f3aec67..09c2a5daead 100644 --- a/src/test/run-pass/generic-exterior-unique.rs +++ b/src/test/run-pass/generic-exterior-unique.rs @@ -1,6 +1,6 @@ type recbox<T> = {x: ~T}; -fn reclift<@T>(t: T) -> recbox<T> { ret {x: ~t}; } +fn reclift<T>(t: T) -> recbox<T> { ret {x: ~t}; } fn main() { let foo: int = 17; diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs index b1f5a06ee34..d45722ccc94 100644 --- a/src/test/run-pass/generic-fn-infer.rs +++ b/src/test/run-pass/generic-fn-infer.rs @@ -4,6 +4,6 @@ // -*- rust -*- // Issue #45: infer type parameters in function applications -fn id<@T>(x: T) -> T { ret x; } +fn id<T>(x: T) -> T { ret x; } fn main() { let x: int = 42; let y: int = id(x); assert (x == y); } diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs index 2b9e73a000b..28f3fcec1e4 100644 --- a/src/test/run-pass/generic-fn-unique.rs +++ b/src/test/run-pass/generic-fn-unique.rs @@ -1,4 +1,4 @@ -fn f<@T>(x: ~T) -> ~T { ret x; } +fn f<T>(x: ~T) -> ~T { ret x; } fn main() { let x = f(~3); log *x; } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index d72f32eeb10..9dbd6dd156c 100644 --- a/src/test/run-pass/generic-fn.rs +++ b/src/test/run-pass/generic-fn.rs @@ -2,7 +2,7 @@ // -*- rust -*- -fn id<@T>(x: T) -> T { ret x; } +fn id<T>(x: T) -> T { ret x; } type triple = {x: int, y: int, z: int}; diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs index 0bc1fafa495..05552db04ff 100644 --- a/src/test/run-pass/generic-obj-with-derived-type.rs +++ b/src/test/run-pass/generic-obj-with-derived-type.rs @@ -1,6 +1,6 @@ -obj handle<@T>(data: T) { +obj handle<T>(data: T) { fn get() -> T { ret data; } } diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs index 7226345d9c0..b81aba5604f 100644 --- a/src/test/run-pass/generic-obj.rs +++ b/src/test/run-pass/generic-obj.rs @@ -1,6 +1,6 @@ -obj buf<@T>(data: {_0: T, _1: T, _2: T}) { +obj buf<T>(data: {_0: T, _1: T, _2: T}) { fn get(i: int) -> T { if i == 0 { ret data._0; diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs index 08bf75b733b..e85de5dd485 100644 --- a/src/test/run-pass/generic-tup.rs +++ b/src/test/run-pass/generic-tup.rs @@ -1,4 +1,4 @@ -fn get_third<@T>(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; } +fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; ret x; } fn main() { log get_third((1, 2, 3)); diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs index 805501eac8b..29a40dd4c1f 100644 --- a/src/test/run-pass/generic-unique.rs +++ b/src/test/run-pass/generic-unique.rs @@ -1,5 +1,5 @@ -fn box<@T>(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { ret ~x; } +fn box<T>(x: {x: T, y: T, z: T}) -> ~{x: T, y: T, z: T} { ret ~x; } fn main() { let x: ~{x: int, y: int, z: int} = box::<int>({x: 1, y: 2, z: 3}); diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs index abae3c5dcb2..0a01845841a 100644 --- a/src/test/run-pass/issue-333.rs +++ b/src/test/run-pass/issue-333.rs @@ -1,5 +1,5 @@ -fn quux<@T>(x: T) -> T { let f = bind id::<T>(_); ret f(x); } +fn quux<T>(x: T) -> T { let f = bind id::<T>(_); ret f(x); } -fn id<@T>(x: T) -> T { ret x; } +fn id<T>(x: T) -> T { ret x; } fn main() { assert (quux(10) == 10); } diff --git a/src/test/run-pass/issue-511.rs b/src/test/run-pass/issue-511.rs index a545f751af9..b843d42570b 100644 --- a/src/test/run-pass/issue-511.rs +++ b/src/test/run-pass/issue-511.rs @@ -1,7 +1,7 @@ use std; import std::option; -fn f<@T>(&o: option::t<T>) { +fn f<T>(&o: option::t<T>) { assert o == option::none; } diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs index e13b2557b09..f9378b21317 100644 --- a/src/test/run-pass/ivec-add.rs +++ b/src/test/run-pass/ivec-add.rs @@ -1,4 +1,4 @@ -fn double<@T>(a: T) -> [T] { ret [a] + [a]; } +fn double<T>(a: T) -> [T] { ret [a] + [a]; } fn double_int(a: int) -> [int] { ret [a] + [a]; } diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs index 7b62db82ad0..d45417e20e3 100644 --- a/src/test/run-pass/log-linearized.rs +++ b/src/test/run-pass/log-linearized.rs @@ -7,12 +7,12 @@ tag option<T> { type smallintmap<T> = @{mutable v: [mutable option<T>]}; -fn mk<@T>() -> smallintmap<T> { +fn mk<T>() -> smallintmap<T> { let v: [mutable option<T>] = [mutable]; ret @{mutable v: v}; } -fn f<@T,@U>() { +fn f<T,U>() { let sim = mk::<U>(); log_err sim; } diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs index 191e3e4b3c7..e08ace6947d 100644 --- a/src/test/run-pass/newtype-polymorphic.rs +++ b/src/test/run-pass/newtype-polymorphic.rs @@ -1,8 +1,8 @@ tag myvec<X> = [X]; -fn myvec_deref<@X>(mv: myvec<X>) -> [X] { ret *mv; } +fn myvec_deref<X>(mv: myvec<X>) -> [X] { ret *mv; } -fn myvec_elt<@X>(mv: myvec<X>) -> X { ret mv[0]; } +fn myvec_elt<X>(mv: myvec<X>) -> X { ret mv[0]; } fn main() { let mv = myvec([1, 2, 3]); diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs index 0f1558975a2..abf2ec0d039 100644 --- a/src/test/run-pass/non-boolean-pure-fns.rs +++ b/src/test/run-pass/non-boolean-pure-fns.rs @@ -2,19 +2,19 @@ use std; import std::list::*; -pure fn pure_length_go<@T>(ls: list<T>, acc: uint) -> uint { +pure fn pure_length_go<T>(ls: list<T>, acc: uint) -> uint { alt ls { nil. { acc } cons(_, tl) { pure_length_go(*tl, acc + 1u) } } } -pure fn pure_length<@T>(ls: list<T>) -> uint { pure_length_go(ls, 0u) } +pure fn pure_length<T>(ls: list<T>) -> uint { pure_length_go(ls, 0u) } -pure fn nonempty_list<@T>(ls: list<T>) -> bool { pure_length(ls) > 0u } +pure fn nonempty_list<T>(ls: list<T>) -> bool { pure_length(ls) > 0u } // Of course, the compiler can't take advantage of the // knowledge that ls is a cons node. Future work. // Also, this is pretty contrived since nonempty_list // could be a "tag refinement", if we implement those. -fn safe_head<@T>(ls: list<T>) : nonempty_list(ls) -> T { car(ls) } +fn safe_head<T>(ls: list<T>) : nonempty_list(ls) -> T { car(ls) } fn main() { let mylist = cons(@1u, @nil); diff --git a/src/test/run-pass/ret-by-reference.rs b/src/test/run-pass/ret-by-reference.rs index 7e430c97115..9c2324a2169 100644 --- a/src/test/run-pass/ret-by-reference.rs +++ b/src/test/run-pass/ret-by-reference.rs @@ -1,6 +1,6 @@ tag option<T> { some(T); none; } -fn get<@T>(opt: option<T>) -> &T { +fn get<T>(opt: option<T>) -> &T { alt opt { some(x) { ret x; } } diff --git a/src/test/run-pass/ret-none.rs b/src/test/run-pass/ret-none.rs index 841753d7ad1..b56db9f9c70 100644 --- a/src/test/run-pass/ret-none.rs +++ b/src/test/run-pass/ret-none.rs @@ -2,6 +2,6 @@ tag option<T> { none; some(T); } -fn f<@T>() -> option<T> { ret none; } +fn f<T>() -> option<T> { ret none; } fn main() { f::<int>(); } diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs index 9ab1d758fea..73c36e0cdb3 100644 --- a/src/test/run-pass/send-type-inference.rs +++ b/src/test/run-pass/send-type-inference.rs @@ -4,9 +4,9 @@ import std::comm::send; import std::comm::port; // tests that ctrl's type gets inferred properly -type command<~K, ~V> = {key: K, val: V}; +type command<unique K, unique V> = {key: K, val: V}; -fn cache_server<~K, ~V>(c: chan<chan<command<K, V>>>) { +fn cache_server<unique K, unique V>(c: chan<chan<command<K, V>>>) { let ctrl = port(); send(c, chan(ctrl)); } diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs index 71c3fb99d03..19c56111b61 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: [mutable T], i: int, j: int) { v[i] <-> v[j]; } +fn swap<T>(v: [mutable T], i: int, j: int) { v[i] <-> v[j]; } fn main() { let a: [mutable int] = [mutable 0, 1, 2, 3, 4, 5, 6]; diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs index 2d6a88e625c..293b1ae5118 100644 --- a/src/test/run-pass/type-param-constraints.rs +++ b/src/test/run-pass/type-param-constraints.rs @@ -1,6 +1,6 @@ fn p_foo<T>(pinned: T) { } -fn s_foo<@T>(shared: T) { } -fn u_foo<~T>(unique: T) { } +fn s_foo<T>(shared: T) { } +fn u_foo<unique T>(unique: T) { } resource r(i: int) { } diff --git a/src/test/run-pass/type-params-in-for-each.rs b/src/test/run-pass/type-params-in-for-each.rs index fee8a5053d5..b2ccb96efdf 100644 --- a/src/test/run-pass/type-params-in-for-each.rs +++ b/src/test/run-pass/type-params-in-for-each.rs @@ -5,7 +5,7 @@ fn range(lo: uint, hi: uint, it: block(uint)) { while lo_ < hi { it(lo_); lo_ += 1u; } } -fn create_index<@T>(index: [{a: T, b: uint}], hash_fn: fn(T) -> uint) { +fn create_index<T>(index: [{a: T, b: uint}], hash_fn: fn(T) -> uint) { range(0u, 256u) {|_i| let bucket: [T] = []; } } diff --git a/src/test/run-pass/unchecked-predicates.rs b/src/test/run-pass/unchecked-predicates.rs index 8f4791399ea..a855f96297d 100644 --- a/src/test/run-pass/unchecked-predicates.rs +++ b/src/test/run-pass/unchecked-predicates.rs @@ -5,24 +5,24 @@ import std::list::*; // Can't easily be written as a "pure fn" because there's // no syntax for specifying that f is pure. -fn pure_foldl<@T, @U>(ls: list<T>, u: U, f: block(T, U) -> U) -> U { +fn pure_foldl<T, U>(ls: list<T>, u: U, f: block(T, U) -> U) -> U { alt ls { nil. { u } cons(hd, tl) { f(hd, pure_foldl(*tl, f(hd, u), f)) } } } // Shows how to use an "unchecked" block to call a general // fn from a pure fn -pure fn pure_length<@T>(ls: list<T>) -> uint { +pure fn pure_length<T>(ls: list<T>) -> uint { fn count<T>(_t: T, &&u: uint) -> uint { u + 1u } unchecked{ pure_foldl(ls, 0u, bind count(_, _)) } } -pure fn nonempty_list<@T>(ls: list<T>) -> bool { pure_length(ls) > 0u } +pure fn nonempty_list<T>(ls: list<T>) -> bool { pure_length(ls) > 0u } // Of course, the compiler can't take advantage of the // knowledge that ls is a cons node. Future work. // Also, this is pretty contrived since nonempty_list // could be a "tag refinement", if we implement those. -fn safe_head<@T>(ls: list<T>) : nonempty_list(ls) -> T { car(ls) } +fn safe_head<T>(ls: list<T>) : nonempty_list(ls) -> T { car(ls) } fn main() { let mylist = cons(@1u, @nil); diff --git a/src/test/run-pass/unify-return-ty.rs b/src/test/run-pass/unify-return-ty.rs index 2a22499e8c7..81a93b6ab13 100644 --- a/src/test/run-pass/unify-return-ty.rs +++ b/src/test/run-pass/unify-return-ty.rs @@ -4,6 +4,6 @@ use std; import std::unsafe; -fn null<@T>() -> *T unsafe { unsafe::reinterpret_cast(0) } +fn null<T>() -> *T unsafe { unsafe::reinterpret_cast(0) } fn main() { null::<int>(); } diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs index 7a10de278ea..dfff2490b05 100644 --- a/src/test/run-pass/unique-assign-generic.rs +++ b/src/test/run-pass/unique-assign-generic.rs @@ -1,4 +1,4 @@ -fn f<@T>(t: T) -> T { +fn f<T>(t: T) -> T { let t1 = t; t1 } diff --git a/src/test/run-pass/unique-generic-assign.rs b/src/test/run-pass/unique-generic-assign.rs index 7b5a4638bc9..3f692a59db7 100644 --- a/src/test/run-pass/unique-generic-assign.rs +++ b/src/test/run-pass/unique-generic-assign.rs @@ -1,6 +1,6 @@ // Issue #976 -fn f<@T>(x: ~T) { +fn f<T>(x: ~T) { let _x2 = x; } fn main() { } diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index 2b3f79899a9..5378bddff2d 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -1,10 +1,10 @@ fn unique() { - fn f<~T>(i: T, j: T) { + fn f<unique T>(i: T, j: T) { assert i == j; } - fn g<~T>(i: T, j: T) { + fn g<unique T>(i: T, j: T) { assert i != j; } @@ -18,11 +18,11 @@ fn unique() { fn shared() { - fn f<@T>(i: T, j: T) { + fn f<T>(i: T, j: T) { assert i == j; } - fn g<@T>(i: T, j: T) { + fn g<T>(i: T, j: T) { assert i != j; } diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs index bb7b6805f14..0e0d828bf63 100644 --- a/src/test/run-pass/vec-push.rs +++ b/src/test/run-pass/vec-push.rs @@ -1,5 +1,5 @@ -fn push<@T>(&v: [mutable? T], t: T) { v += [t]; } +fn push<T>(&v: [mutable? T], t: T) { v += [t]; } fn main() { let v = [1, 2, 3]; push(v, 1); } diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs index d532d975535..fac7aa3a853 100644 --- a/src/test/stdtest/deque.rs +++ b/src/test/stdtest/deque.rs @@ -81,7 +81,7 @@ fn test_boxes(a: @int, b: @int, c: @int, d: @int) { type eqfn<T> = fn@(T, T) -> bool; -fn test_parameterized<@T>(e: eqfn<T>, a: T, b: T, c: T, d: T) { +fn test_parameterized<T>(e: eqfn<T>, a: T, b: T, c: T, d: T) { let deq: deque::t<T> = deque::create::<T>(); assert (deq.size() == 0u); deq.add_front(a); @@ -113,7 +113,7 @@ fn test_parameterized<@T>(e: eqfn<T>, a: T, b: T, c: T, d: T) { tag taggy { one(int); two(int, int); three(int, int, int); } -tag taggypar<@T> { onepar(int); twopar(int, int); threepar(int, int, int); } +tag taggypar<T> { onepar(int); twopar(int, int); threepar(int, int, int); } type reccy = {x: int, y: int, t: taggy}; @@ -138,7 +138,7 @@ fn test() { } } } - fn taggypareq<@T>(a: taggypar<T>, b: taggypar<T>) -> bool { + fn taggypareq<T>(a: taggypar<T>, b: taggypar<T>) -> bool { alt a { onepar::<T>(a1) { alt b { onepar::<T>(b1) { ret a1 == b1; } _ { ret false; } } diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs index 1349831cb87..b12636a58c0 100644 --- a/src/test/stdtest/task.rs +++ b/src/test/stdtest/task.rs @@ -80,7 +80,7 @@ fn test_join_convenient() { #[ignore] fn spawn_polymorphic() { // FIXME #1038: Can't spawn palymorphic functions - /*fn foo<~T>(x: T) { log_err x; } + /*fn foo<unique T>(x: T) { log_err x; } task::spawn(true, foo); task::spawn(42, foo);*/