From 6e6798c4e17d9ffa33c0573f329c772e9d96739e Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 26 Mar 2012 18:35:18 -0700 Subject: Bulk-edit mutable -> mut. --- src/libstd/bitv.rs | 2 +- src/libstd/c_vec.rs | 12 +++++----- src/libstd/deque.rs | 28 +++++++++++------------ src/libstd/ebml.rs | 10 ++++---- src/libstd/getopts.rs | 2 +- src/libstd/json.rs | 12 +++++----- src/libstd/list.rs | 2 +- src/libstd/map.rs | 18 +++++++-------- src/libstd/rope.rs | 40 ++++++++++++++++---------------- src/libstd/sha1.rs | 22 +++++++++--------- src/libstd/smallintmap.rs | 6 ++--- src/libstd/sort.rs | 58 +++++++++++++++++++++++------------------------ src/libstd/test.rs | 30 ++++++++++++------------ src/libstd/treemap.rs | 10 ++++---- src/libstd/ufind.rs | 6 ++--- 15 files changed, 129 insertions(+), 129 deletions(-) (limited to 'src/libstd') diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index 371f45cb7a9..37df940f6fb 100644 --- a/src/libstd/bitv.rs +++ b/src/libstd/bitv.rs @@ -22,7 +22,7 @@ export eq_vec; // for the case where nbits <= 32. #[doc = "The bitvector type"] -type bitv = @{storage: [mutable uint], nbits: uint}; +type bitv = @{storage: [mut uint], nbits: uint}; const uint_bits: uint = 32u + (1u << 32u >> 27u); diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 28ee44690ee..ce89f323cdc 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -4,7 +4,7 @@ Library to interface with chunks of memory allocated in C. It is often desirable to safely interface with memory allocated from C, encapsulating the unsafety into allocation and destruction time. Indeed, allocating memory externally is currently the only way to give Rust shared -mutable state with C programs that keep their own references; vectors are +mut state with C programs that keep their own references; vectors are unsuitable because they could be reallocated or moved at any time, and importing C memory into a vector takes a one-time snapshot of the memory. @@ -38,7 +38,7 @@ Wrapped in a enum for opacity; FIXME #818 when it is possible to have truly opaque types, this should be revisited. "] enum c_vec { - c_vec_({ base: *mutable T, len: uint, rsrc: @dtor_res}) + c_vec_({ base: *mut T, len: uint, rsrc: @dtor_res}) } resource dtor_res(dtor: option) { @@ -60,7 +60,7 @@ Create a `c_vec` from a native buffer with a given length. * base - A native pointer to a buffer * len - The number of elements in the buffer "] -unsafe fn c_vec(base: *mutable T, len: uint) -> c_vec { +unsafe fn c_vec(base: *mut T, len: uint) -> c_vec { ret c_vec_({ base: base, len: len, @@ -79,7 +79,7 @@ and a function to run upon destruction. * dtor - A function to run when the value is destructed, useful for freeing the buffer, etc. "] -unsafe fn c_vec_with_dtor(base: *mutable T, len: uint, dtor: fn@()) +unsafe fn c_vec_with_dtor(base: *mut T, len: uint, dtor: fn@()) -> c_vec { ret c_vec_({ base: base, @@ -122,7 +122,7 @@ fn len(t: c_vec) -> uint { } #[doc = "Returns a pointer to the first element of the vector"] -unsafe fn ptr(t: c_vec) -> *mutable T { +unsafe fn ptr(t: c_vec) -> *mut T { ret (*t).base; } @@ -135,7 +135,7 @@ mod tests { assert mem as int != 0; - ret unsafe { c_vec_with_dtor(mem as *mutable u8, n, + ret unsafe { c_vec_with_dtor(mem as *mut u8, n, bind free(mem)) }; } diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 749cefc5ba6..8a894a4b8f3 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -23,30 +23,30 @@ fn create() -> t { * Grow is only called on full elts, so nelts is also len(elts), unlike * elsewhere. */ - fn grow(nelts: uint, lo: uint, elts: [mutable cell]) -> - [mutable cell] { + fn grow(nelts: uint, lo: uint, elts: [mut cell]) -> + [mut cell] { assert (nelts == vec::len(elts)); - let mut rv = [mutable]; + let mut rv = [mut]; let mut i = 0u; let nalloc = uint::next_power_of_two(nelts + 1u); while i < nalloc { if i < nelts { - rv += [mutable elts[(lo + i) % nelts]]; - } else { rv += [mutable none]; } + rv += [mut elts[(lo + i) % nelts]]; + } else { rv += [mut none]; } i += 1u; } ret rv; } - fn get(elts: [mutable cell], i: uint) -> T { + fn get(elts: [mut cell], i: uint) -> T { ret alt elts[i] { some(t) { t } _ { fail } }; } - type repr = {mutable nelts: uint, - mutable lo: uint, - mutable hi: uint, - mutable elts: [mutable cell]}; + type repr = {mut nelts: uint, + mut lo: uint, + mut hi: uint, + mut elts: [mut cell]}; impl of t for repr { fn size() -> uint { ret self.nelts; } @@ -102,10 +102,10 @@ fn create() -> t { } let repr: repr = { - mutable nelts: 0u, - mutable lo: 0u, - mutable hi: 0u, - mutable elts: vec::to_mut(vec::from_elem(initial_capacity, none)) + mut nelts: 0u, + mut lo: 0u, + mut hi: 0u, + mut elts: vec::to_mut(vec::from_elem(initial_capacity, none)) }; repr as t:: } diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 40c44da8b45..91a9c244011 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -149,7 +149,7 @@ fn doc_as_i32(d: doc) -> i32 { doc_as_u32(d) as i32 } fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 } // ebml writing -type writer = {writer: io::writer, mutable size_positions: [uint]}; +type writer = {writer: io::writer, mut size_positions: [uint]}; fn write_sized_vuint(w: io::writer, n: uint, size: uint) { let buf: [u8] = alt size { @@ -178,7 +178,7 @@ fn write_vuint(w: io::writer, n: uint) { fn writer(w: io::writer) -> writer { let size_positions: [uint] = []; - ret {writer: w, mutable size_positions: size_positions}; + ret {writer: w, mut size_positions: size_positions}; } // TODO: Provide a function to write the standard ebml header. @@ -361,11 +361,11 @@ impl serializer of serialization::serializer for ebml::writer { fn emit_tup_elt(_idx: uint, f: fn()) { f() } } -type ebml_deserializer = {mutable parent: ebml::doc, - mutable pos: uint}; +type ebml_deserializer = {mut parent: ebml::doc, + mut pos: uint}; fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer { - {mutable parent: d, mutable pos: d.start} + {mut parent: d, mut pos: d.start} } impl deserializer of serialization::deserializer for ebml_deserializer { diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 91f9c499ce1..3d921fb4d9d 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -114,7 +114,7 @@ enum optval { val(str), given, } The result of checking command line arguments. Contains a vector of matches and a vector of free strings. "] -type match = {opts: [opt], vals: [mutable [optval]], free: [str]}; +type match = {opts: [opt], vals: [mut [optval]], free: [str]}; fn is_arg(arg: str) -> bool { ret str::len(arg) > 1u && arg[0] == '-' as u8; diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 8f7765c4e02..b9931ba3f86 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -109,9 +109,9 @@ fn to_str(j: json) -> str { type parser = { rdr: io::reader, - mutable ch: char, - mutable line: uint, - mutable col: uint, + mut ch: char, + mut line: uint, + mut col: uint, }; impl parser for parser { @@ -458,9 +458,9 @@ impl parser for parser { fn from_reader(rdr: io::reader) -> result { let parser = { rdr: rdr, - mutable ch: rdr.read_char(), - mutable line: 1u, - mutable col: 1u, + mut ch: rdr.read_char(), + mut line: 1u, + mut col: 1u, }; parser.parse() diff --git a/src/libstd/list.rs b/src/libstd/list.rs index ca3905dd246..bf2f51cf82d 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -164,7 +164,7 @@ mod tests { #[test] fn test_from_vec_mut() { - let l = from_vec([mutable 0, 1, 2]); + let l = from_vec([mut 0, 1, 2]); assert (head(l) == 0); diff --git a/src/libstd/map.rs b/src/libstd/map.rs index 5722789e64a..a35b51be900 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -71,8 +71,8 @@ mod chained { type entry = { hash: uint, key: K, - mutable value: V, - mutable next: chain + mut value: V, + mut next: chain }; enum chain { @@ -81,8 +81,8 @@ mod chained { } type t = @{ - mutable count: uint, - mutable chains: [mutable chain], + mut count: uint, + mut chains: [mut chain], hasher: hashfn, eqer: eqfn }; @@ -152,8 +152,8 @@ mod chained { tbl.chains[idx] = present(@{ hash: hash, key: k, - mutable value: v, - mutable next: old_chain}); + mut value: v, + mut next: old_chain}); ret true; } found_first(_, entry) { @@ -203,7 +203,7 @@ mod chained { } } - fn chains(nchains: uint) -> [mutable chain] { + fn chains(nchains: uint) -> [mut chain] { ret vec::to_mut(vec::from_elem(nchains, absent)); } @@ -286,8 +286,8 @@ mod chained { fn mk(hasher: hashfn, eqer: eqfn) -> t { let initial_capacity: uint = 32u; // 2^5 - let slf: t = @{mutable count: 0u, - mutable chains: chains(initial_capacity), + let slf: t = @{mut count: 0u, + mut chains: chains(initial_capacity), hasher: hasher, eqer: eqer}; slf diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index 2452188db24..735d273faa3 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -154,7 +154,7 @@ rope remains balanced. However, this function does not take any further measure to ensure that the result is balanced. "] fn concat(v: [rope]) -> rope { - //Copy `v` into a mutable vector + //Copy `v` into a mut vector let mut len = vec::len(v); if len == 0u { ret node::empty; } let ropes = vec::to_mut(vec::from_elem(len, v[0])); @@ -752,7 +752,7 @@ mod node { * forest - The forest. This vector is progressively rewritten during execution and should be discarded as meaningless afterwards. "] - fn tree_from_forest_destructive(forest: [mutable @node]) -> @node { + fn tree_from_forest_destructive(forest: [mut @node]) -> @node { let mut i = 0u; let mut len = vec::len(forest); while len > 1u { @@ -861,12 +861,12 @@ mod node { fn bal(node: @node) -> option<@node> { if height(node) < hint_max_node_height { ret option::none; } //1. Gather all leaves as a forest - let mut forest = [mutable]; + let mut forest = [mut]; let it = leaf_iterator::start(node); loop { alt (leaf_iterator::next(it)) { option::none { break; } - option::some(x) { forest += [mutable @leaf(x)]; } + option::some(x) { forest += [mut @leaf(x)]; } } } //2. Rebuild tree from forest @@ -1117,20 +1117,20 @@ mod node { mod leaf_iterator { type t = { - stack: [mutable @node], - mutable stackpos: int + stack: [mut @node], + mut stackpos: int }; fn empty() -> t { - let stack : [mutable @node] = [mutable]; - ret {stack: stack, mutable stackpos: -1} + let stack : [mut @node] = [mut]; + ret {stack: stack, mut stackpos: -1} } fn start(node: @node) -> t { let stack = vec::to_mut(vec::from_elem(height(node)+1u, node)); ret { stack: stack, - mutable stackpos: 0 + mut stackpos: 0 } } @@ -1157,23 +1157,23 @@ mod node { mod char_iterator { type t = { leaf_iterator: leaf_iterator::t, - mutable leaf: option, - mutable leaf_byte_pos: uint + mut leaf: option, + mut leaf_byte_pos: uint }; fn start(node: @node) -> t { ret { leaf_iterator: leaf_iterator::start(node), - mutable leaf: option::none, - mutable leaf_byte_pos: 0u + mut leaf: option::none, + mut leaf_byte_pos: 0u } } fn empty() -> t { ret { leaf_iterator: leaf_iterator::empty(), - mutable leaf: option::none, - mutable leaf_byte_pos: 0u + mut leaf: option::none, + mut leaf_byte_pos: 0u } } @@ -1242,8 +1242,8 @@ mod tests { alt(r) { node::empty { ret "" } node::content(x) { - let str = @mutable ""; - fn aux(str: @mutable str, node: @node::node) unsafe { + let str = @mut ""; + fn aux(str: @mut str, node: @node::node) unsafe { alt(*node) { node::leaf(x) { *str += str::slice( @@ -1280,7 +1280,7 @@ mod tests { #[test] fn of_string2() { - let buf = @ mutable "1234567890"; + let buf = @ mut "1234567890"; let mut i = 0; while i < 10 { *buf = *buf + *buf; i+=1;} let sample = @*buf; @@ -1313,7 +1313,7 @@ mod tests { #[test] fn iter1() { - let buf = @ mutable "1234567890"; + let buf = @ mut "1234567890"; let mut i = 0; while i < 10 { *buf = *buf + *buf; i+=1;} let sample = @*buf; @@ -1334,7 +1334,7 @@ mod tests { #[test] fn bal1() { let init = @ "1234567890"; - let buf = @ mutable * init; + let buf = @ mut * init; let mut i = 0; while i < 8 { *buf = *buf + *buf; i+=1;} let sample = @*buf; diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs index 4d5aabf705d..8e5f0cb122a 100644 --- a/src/libstd/sha1.rs +++ b/src/libstd/sha1.rs @@ -52,13 +52,13 @@ const k3: u32 = 0xCA62C1D6u32; #[doc = "Construct a `sha` object"] fn sha1() -> sha1 { type sha1state = - {h: [mutable u32], - mutable len_low: u32, - mutable len_high: u32, - msg_block: [mutable u8], - mutable msg_block_idx: uint, - mutable computed: bool, - work_buf: [mutable u32]}; + {h: [mut u32], + mut len_low: u32, + mut len_high: u32, + msg_block: [mut u8], + mut msg_block_idx: uint, + mut computed: bool, + work_buf: [mut u32]}; fn add_input(st: sha1state, msg: [u8]) { // FIXME: Should be typestate precondition @@ -244,11 +244,11 @@ fn sha1() -> sha1 { } let st = { h: vec::to_mut(vec::from_elem(digest_buf_len, 0u32)), - mutable len_low: 0u32, - mutable len_high: 0u32, + mut len_low: 0u32, + mut len_high: 0u32, msg_block: vec::to_mut(vec::from_elem(msg_block_len, 0u8)), - mutable msg_block_idx: 0u, - mutable computed: false, + mut msg_block_idx: 0u, + mut computed: false, work_buf: vec::to_mut(vec::from_elem(work_buf_len, 0u32)) }; let sh = st as sha1; diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index d58e0519387..a088cd52f68 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -7,12 +7,12 @@ import core::option::{some, none}; // FIXME: Should not be @; there's a bug somewhere in rustc that requires this // to be. -type smallintmap = @{mutable v: [mutable option]}; +type smallintmap = @{mut v: [mut option]}; #[doc = "Create a smallintmap"] fn mk() -> smallintmap { - let v: [mutable option] = [mutable]; - ret @{mutable v: v}; + let v: [mut option] = [mut]; + ret @{mut v: v}; } #[doc = " diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index 461dd1bab3a..8385158e93a 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -51,7 +51,7 @@ fn merge_sort(le: le, v: [const T]) -> [T] { } } -fn part(compare_func: le, arr: [mutable T], left: uint, +fn part(compare_func: le, arr: [mut T], left: uint, right: uint, pivot: uint) -> uint { let pivot_value = arr[pivot]; arr[pivot] <-> arr[right]; @@ -68,7 +68,7 @@ fn part(compare_func: le, arr: [mutable T], left: uint, ret storage_index; } -fn qsort(compare_func: le, arr: [mutable T], left: uint, +fn qsort(compare_func: le, arr: [mut T], left: uint, right: uint) { if right > left { let pivot = (left + right) / 2u; @@ -82,18 +82,18 @@ fn qsort(compare_func: le, arr: [mutable T], left: uint, } #[doc = " -Quicksort. Sorts a mutable vector in place. +Quicksort. Sorts a mut vector in place. Has worst case O(n^2) performance, average case O(n log n). This is an unstable sort. "] -fn quick_sort(compare_func: le, arr: [mutable T]) { +fn quick_sort(compare_func: le, arr: [mut T]) { if len::(arr) == 0u { ret; } qsort::(compare_func, arr, 0u, len::(arr) - 1u); } fn qsort3(compare_func_lt: le, compare_func_eq: le, - arr: [mutable T], left: int, right: int) { + arr: [mut T], left: int, right: int) { if right <= left { ret; } let v: T = arr[right]; let mut i: int = left - 1; @@ -142,7 +142,7 @@ fn qsort3(compare_func_lt: le, compare_func_eq: le, // FIXME: This should take lt and eq types #[doc = " -Fancy quicksort. Sorts a mutable vector in place. +Fancy quicksort. Sorts a mut vector in place. Based on algorithm presented by [Sedgewick and Bentley] (http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf). @@ -152,7 +152,7 @@ According to these slides this is the algorithm of choice for This is an unstable sort. "] fn quick_sort3(compare_func_lt: le, compare_func_eq: le, - arr: [mutable T]) { + arr: [mut T]) { if len::(arr) == 0u { ret; } qsort3::(compare_func_lt, compare_func_eq, arr, 0, (len::(arr) as int) - 1); @@ -160,7 +160,7 @@ fn quick_sort3(compare_func_lt: le, compare_func_eq: le, #[cfg(test)] mod test_qsort3 { - fn check_sort(v1: [mutable int], v2: [mutable int]) { + fn check_sort(v1: [mut int], v2: [mut int]) { let len = vec::len::(v1); fn lt(&&a: int, &&b: int) -> bool { ret a < b; } fn equal(&&a: int, &&b: int) -> bool { ret a == b; } @@ -178,24 +178,24 @@ mod test_qsort3 { #[test] fn test() { { - let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8]; - let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9]; + let v1 = [mut 3, 7, 4, 5, 2, 9, 5, 8]; + let v2 = [mut 2, 3, 4, 5, 5, 7, 8, 9]; check_sort(v1, v2); } { - let v1 = [mutable 1, 1, 1]; - let v2 = [mutable 1, 1, 1]; + let v1 = [mut 1, 1, 1]; + let v2 = [mut 1, 1, 1]; check_sort(v1, v2); } { - let v1: [mutable int] = [mutable]; - let v2: [mutable int] = [mutable]; + let v1: [mut int] = [mut]; + let v2: [mut int] = [mut]; check_sort(v1, v2); } - { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); } + { let v1 = [mut 9]; let v2 = [mut 9]; check_sort(v1, v2); } { - let v1 = [mutable 9, 3, 3, 3, 9]; - let v2 = [mutable 3, 3, 3, 9, 9]; + let v1 = [mut 9, 3, 3, 3, 9]; + let v2 = [mut 3, 3, 3, 9, 9]; check_sort(v1, v2); } } @@ -203,7 +203,7 @@ mod test_qsort3 { #[cfg(test)] mod test_qsort { - fn check_sort(v1: [mutable int], v2: [mutable int]) { + fn check_sort(v1: [mut int], v2: [mut int]) { let len = vec::len::(v1); fn leual(&&a: int, &&b: int) -> bool { ret a <= b; } let f = leual; @@ -219,24 +219,24 @@ mod test_qsort { #[test] fn test() { { - let v1 = [mutable 3, 7, 4, 5, 2, 9, 5, 8]; - let v2 = [mutable 2, 3, 4, 5, 5, 7, 8, 9]; + let v1 = [mut 3, 7, 4, 5, 2, 9, 5, 8]; + let v2 = [mut 2, 3, 4, 5, 5, 7, 8, 9]; check_sort(v1, v2); } { - let v1 = [mutable 1, 1, 1]; - let v2 = [mutable 1, 1, 1]; + let v1 = [mut 1, 1, 1]; + let v2 = [mut 1, 1, 1]; check_sort(v1, v2); } { - let v1: [mutable int] = [mutable]; - let v2: [mutable int] = [mutable]; + let v1: [mut int] = [mut]; + let v2: [mut int] = [mut]; check_sort(v1, v2); } - { let v1 = [mutable 9]; let v2 = [mutable 9]; check_sort(v1, v2); } + { let v1 = [mut 9]; let v2 = [mut 9]; check_sort(v1, v2); } { - let v1 = [mutable 9, 3, 3, 3, 9]; - let v2 = [mutable 3, 3, 3, 9, 9]; + let v1 = [mut 9, 3, 3, 3, 9]; + let v2 = [mut 3, 3, 3, 9, 9]; check_sort(v1, v2); } } @@ -244,7 +244,7 @@ mod test_qsort { // Regression test for #750 #[test] fn test_simple() { - let names = [mutable 2, 1, 3]; + let names = [mut 2, 1, 3]; let expected = [1, 2, 3]; @@ -294,7 +294,7 @@ mod tests { #[test] fn test_merge_sort_mutable() { fn le(&&a: int, &&b: int) -> bool { ret a <= b; } - let v1 = [mutable 3, 2, 1]; + let v1 = [mut 3, 2, 1]; let v2 = merge_sort(le, v1); assert v2 == [1, 2, 3]; } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 271fac730ab..5847dea1e4e 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -88,11 +88,11 @@ enum test_result { tr_ok, tr_failed, tr_ignored, } type console_test_state = @{out: io::writer, use_color: bool, - mutable total: uint, - mutable passed: uint, - mutable failed: uint, - mutable ignored: uint, - mutable failures: [test_desc]}; + mut total: uint, + mut passed: uint, + mut failed: uint, + mut ignored: uint, + mut failures: [test_desc]}; // A simple console test runner fn run_tests_console(opts: test_opts, @@ -131,11 +131,11 @@ fn run_tests_console(opts: test_opts, let st = @{out: io::stdout(), use_color: use_color(), - mutable total: 0u, - mutable passed: 0u, - mutable failed: 0u, - mutable ignored: 0u, - mutable failures: []}; + mut total: 0u, + mut passed: 0u, + mut failed: 0u, + mut ignored: 0u, + mut failures: []}; run_tests(opts, tests, bind callback(_, st)); @@ -210,11 +210,11 @@ fn should_sort_failures_before_printing_them() { let st = @{out: writer, use_color: false, - mutable total: 0u, - mutable passed: 0u, - mutable failed: 0u, - mutable ignored: 0u, - mutable failures: [test_b, test_a]}; + mut total: 0u, + mut passed: 0u, + mut failed: 0u, + mut ignored: 0u, + mut failures: [test_b, test_a]}; print_failures(st); diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index 54e38483a97..ebf532ab19d 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -15,17 +15,17 @@ export insert; export find; export traverse; -type treemap = @mutable tree_node; +type treemap = @mut tree_node; enum tree_node { empty, node(@K, @V, treemap, treemap) } #[doc = "Create a treemap"] -fn treemap() -> treemap { @mutable empty } +fn treemap() -> treemap { @mut empty } #[doc = "Insert a value into the map"] fn insert(m: treemap, k: K, v: V) { alt m { - @empty { *m = node(@k, @v, @mutable empty, @mutable empty); } + @empty { *m = node(@k, @v, @mut empty, @mut empty); } @node(@kk, _, _, _) { // We have to name left and right individually, because @@ -114,8 +114,8 @@ mod tests { insert(m, 2, ()); insert(m, 1, ()); - let n = @mutable 0; - fn t(n: @mutable int, &&k: int, &&_v: ()) { + let n = @mut 0; + fn t(n: @mut int, &&k: int, &&_v: ()) { assert (*n == k); *n += 1; } traverse(m, bind t(n, _, _)); diff --git a/src/libstd/ufind.rs b/src/libstd/ufind.rs index 53bdabfc203..555c0a0f212 100644 --- a/src/libstd/ufind.rs +++ b/src/libstd/ufind.rs @@ -8,13 +8,13 @@ import option::{some, none}; // than the node itself. type node = option; -type ufind = {mutable nodes: [mutable node]}; +type ufind = {mut nodes: [mut node]}; -fn make() -> ufind { ret {mutable nodes: [mutable]}; } +fn make() -> ufind { ret {mut nodes: [mut]}; } fn make_set(ufnd: ufind) -> uint { let idx = vec::len(ufnd.nodes); - ufnd.nodes += [mutable none::]; + ufnd.nodes += [mut none::]; ret idx; } -- cgit 1.4.1-3-g733a5