diff options
| author | Brian Anderson <banderson@mozilla.com> | 2012-08-14 16:54:13 -0700 |
|---|---|---|
| committer | Brian Anderson <banderson@mozilla.com> | 2012-08-15 14:14:20 -0700 |
| commit | 74c69e1053188d92b86bc8b28cbf1af87d31ea2d (patch) | |
| tree | 8c07fc440e572eb59787705a9dd11fcd789430e0 | |
| parent | 8be0f665bcda9f5e4077d0be6ebc6aa382e72319 (diff) | |
| download | rust-74c69e1053188d92b86bc8b28cbf1af87d31ea2d.tar.gz rust-74c69e1053188d92b86bc8b28cbf1af87d31ea2d.zip | |
Convert more core types to camel case
67 files changed, 457 insertions, 427 deletions
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index 060015c26cf..59ed352e1ee 100644 --- a/src/libcore/at_vec.rs +++ b/src/libcore/at_vec.rs @@ -15,7 +15,7 @@ export unsafe; #[abi = "cdecl"] extern mod rustrt { fn vec_reserve_shared_actual(++t: *sys::TypeDesc, - ++v: **vec::unsafe::vec_repr, + ++v: **vec::unsafe::VecRepr, ++n: libc::size_t); } @@ -25,13 +25,13 @@ extern mod rusti { } /// A function used to initialize the elements of a vector -type init_op<T> = fn(uint) -> T; +type InitOp<T> = fn(uint) -> T; /// Returns the number of elements the vector can hold without reallocating #[inline(always)] pure fn capacity<T>(&&v: @[const T]) -> uint { unsafe { - let repr: **unsafe::vec_repr = + let repr: **unsafe::VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); (**repr).alloc / sys::size_of::<T>() } @@ -103,7 +103,7 @@ pure fn map<T, U>(v: &[T], f: fn(T) -> U) -> @[U] { * Creates an immutable vector of size `n_elts` and initializes the elements * to the value returned by the function `op`. */ -pure fn from_fn<T>(n_elts: uint, op: init_op<T>) -> @[T] { +pure fn from_fn<T>(n_elts: uint, op: InitOp<T>) -> @[T] { do build_sized(n_elts) |push| { let mut i: uint = 0u; while i < n_elts { push(op(i)); i += 1u; } @@ -133,8 +133,8 @@ impl<T: copy> @[T]: add<&[const T],@[T]> { mod unsafe { - type vec_repr = vec::unsafe::vec_repr; - type slice_repr = vec::unsafe::slice_repr; + type VecRepr = vec::unsafe::VecRepr; + type SliceRepr = vec::unsafe::SliceRepr; /** * Sets the length of a vector @@ -145,13 +145,13 @@ mod unsafe { */ #[inline(always)] unsafe fn set_len<T>(&&v: @[const T], new_len: uint) { - let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); (**repr).fill = new_len * sys::size_of::<T>(); } #[inline(always)] unsafe fn push<T>(&v: @[const T], +initval: T) { - let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); let fill = (**repr).fill; if (**repr).alloc > fill { push_fast(v, initval); @@ -163,7 +163,7 @@ mod unsafe { // This doesn't bother to make sure we have space. #[inline(always)] // really pretty please unsafe fn push_fast<T>(&v: @[const T], +initval: T) { - let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); let fill = (**repr).fill; (**repr).fill += sys::size_of::<T>(); let p = ptr::addr_of((**repr).data); @@ -190,7 +190,7 @@ mod unsafe { unsafe fn reserve<T>(&v: @[const T], n: uint) { // Only make the (slow) call into the runtime if we have to if capacity(v) < n { - let ptr = addr_of(v) as **vec_repr; + let ptr = addr_of(v) as **VecRepr; rustrt::vec_reserve_shared_actual(sys::get_type_desc::<T>(), ptr, n as libc::size_t); } diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index b4cf0ef1002..eb19a12c254 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -27,7 +27,7 @@ * ~~~ */ -import either::either; +import either::Either; import libc::size_t; export port; @@ -222,7 +222,7 @@ fn peek_(p: *rust_port) -> bool { /// Receive on one of two ports fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>) - -> either<A, B> { + -> Either<A, B> { let ports = ~[(**p_a).po, (**p_b).po]; let yield = 0u, yieldp = ptr::addr_of(yield); @@ -246,9 +246,9 @@ fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>) assert resport != ptr::null(); if resport == (**p_a).po { - either::left(recv(p_a)) + either::Left(recv(p_a)) } else if resport == (**p_b).po { - either::right(recv(p_b)) + either::Right(recv(p_b)) } else { fail ~"unexpected result from rust_port_select"; } @@ -355,11 +355,11 @@ fn test_select2_available() { send(ch_a, ~"a"); - assert select2(po_a, po_b) == either::left(~"a"); + assert select2(po_a, po_b) == either::Left(~"a"); send(ch_b, ~"b"); - assert select2(po_a, po_b) == either::right(~"b"); + assert select2(po_a, po_b) == either::Right(~"b"); } #[test] @@ -375,14 +375,14 @@ fn test_select2_rendezvous() { send(ch_a, ~"a"); }; - assert select2(po_a, po_b) == either::left(~"a"); + assert select2(po_a, po_b) == either::Left(~"a"); do task::spawn { for iter::repeat(10u) { task::yield() } send(ch_b, ~"b"); }; - assert select2(po_a, po_b) == either::right(~"b"); + assert select2(po_a, po_b) == either::Right(~"b"); } } @@ -413,8 +413,8 @@ fn test_select2_stress() { let mut bs = 0; for iter::repeat(msgs * times * 2u) { match select2(po_a, po_b) { - either::left(~"a") => as += 1, - either::right(~"b") => bs += 1, + either::Left(~"a") => as += 1, + either::Right(~"b") => bs += 1, _ => fail ~"test_select_2_stress failed" } } diff --git a/src/libcore/core.rc b/src/libcore/core.rc index f5c9039ad25..3c54e077cc3 100644 --- a/src/libcore/core.rc +++ b/src/libcore/core.rc @@ -68,6 +68,7 @@ export priv; // Built-in-type support modules /// Operations and constants for `int` +#[warn(non_camel_case_types)] #[path = "int-template"] mod int { import inst::{ hash, pow }; @@ -77,6 +78,7 @@ mod int { } /// Operations and constants for `i8` +#[warn(non_camel_case_types)] #[path = "int-template"] mod i8 { #[path = "i8.rs"] @@ -84,6 +86,7 @@ mod i8 { } /// Operations and constants for `i16` +#[warn(non_camel_case_types)] #[path = "int-template"] mod i16 { #[path = "i16.rs"] @@ -91,6 +94,7 @@ mod i16 { } /// Operations and constants for `i32` +#[warn(non_camel_case_types)] #[path = "int-template"] mod i32 { #[path = "i32.rs"] @@ -98,6 +102,7 @@ mod i32 { } /// Operations and constants for `i64` +#[warn(non_camel_case_types)] #[path = "int-template"] mod i64 { #[path = "i64.rs"] @@ -105,6 +110,7 @@ mod i64 { } /// Operations and constants for `uint` +#[warn(non_camel_case_types)] #[path = "uint-template"] mod uint { import inst::{ @@ -119,6 +125,7 @@ mod uint { } /// Operations and constants for `u8` +#[warn(non_camel_case_types)] #[path = "uint-template"] mod u8 { import inst::is_ascii; @@ -129,6 +136,7 @@ mod u8 { } /// Operations and constants for `u16` +#[warn(non_camel_case_types)] #[path = "uint-template"] mod u16 { #[path = "u16.rs"] @@ -136,6 +144,7 @@ mod u16 { } /// Operations and constants for `u32` +#[warn(non_camel_case_types)] #[path = "uint-template"] mod u32 { #[path = "u32.rs"] @@ -143,6 +152,7 @@ mod u32 { } /// Operations and constants for `u64` +#[warn(non_camel_case_types)] #[path = "uint-template"] mod u64 { #[path = "u64.rs"] @@ -150,15 +160,25 @@ mod u64 { } +#[warn(non_camel_case_types)] mod box; +#[warn(non_camel_case_types)] mod char; +#[warn(non_camel_case_types)] mod float; +#[warn(non_camel_case_types)] mod f32; +#[warn(non_camel_case_types)] mod f64; +#[warn(non_camel_case_types)] mod str; +#[warn(non_camel_case_types)] mod ptr; +#[warn(non_camel_case_types)] mod vec; +#[warn(non_camel_case_types)] mod at_vec; +#[warn(non_camel_case_types)] mod bool; #[warn(non_camel_case_types)] mod tuple; @@ -173,7 +193,9 @@ mod cmp; mod num; #[warn(non_camel_case_types)] mod hash; +#[warn(non_camel_case_types)] mod either; +#[warn(non_camel_case_types)] mod iter; #[warn(non_camel_case_types)] mod logging; @@ -193,18 +215,23 @@ mod util; // Data structure modules +#[warn(non_camel_case_types)] mod dvec; #[path="iter-trait"] +#[warn(non_camel_case_types)] mod dvec_iter { #[path = "dvec.rs"] mod inst; } +#[warn(non_camel_case_types)] mod dlist; #[path="iter-trait"] +#[warn(non_camel_case_types)] mod dlist_iter { #[path ="dlist.rs"] mod inst; } +#[warn(non_camel_case_types)] mod send_map; // Concurrency diff --git a/src/libcore/core.rs b/src/libcore/core.rs index f6a721d102a..1fb831b46fa 100644 --- a/src/libcore/core.rs +++ b/src/libcore/core.rs @@ -6,25 +6,25 @@ import option::{some, none}; import option = option::option; import Path = path::Path; import tuple::{TupleOps, ExtendedTupleOps}; -import str::{str_slice, unique_str}; -import vec::{const_vector, copyable_vector, immutable_vector}; -import vec::{immutable_copyable_vector, iter_trait_extensions}; -import iter::{base_iter, extended_iter, copyable_iter, times, timesi}; +import str::{StrSlice, UniqueStr}; +import vec::{ConstVector, CopyableVector, ImmutableVector}; +import vec::{ImmutableCopyableVector, IterTraitExtensions}; +import iter::{BaseIter, ExtendedIter, CopyableIter, Times, TimesIx}; import num::Num; -import ptr::ptr; +import ptr::Ptr; import to_str::ToStr; export Path, option, some, none, unreachable; export extensions; // The following exports are the extension impls for numeric types -export Num, times, timesi; +export Num, Times, TimesIx; // The following exports are the common traits -export str_slice, unique_str; -export const_vector, copyable_vector, immutable_vector; -export immutable_copyable_vector, iter_trait_extensions; -export base_iter, copyable_iter, extended_iter; +export StrSlice, UniqueStr; +export ConstVector, CopyableVector, ImmutableVector; +export ImmutableCopyableVector, IterTraitExtensions; +export BaseIter, CopyableIter, ExtendedIter; export TupleOps, ExtendedTupleOps; -export ptr; +export Ptr; export ToStr; // The following exports are the core operators and kinds diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs index b3f56109ee4..f835344f2d1 100644 --- a/src/libcore/dlist.rs +++ b/src/libcore/dlist.rs @@ -8,25 +8,25 @@ * Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate. */ -export dlist, dlist_node; +export DList, dlist, dlist_node; export new_dlist, from_elem, from_vec, extensions; -type dlist_link<T> = option<dlist_node<T>>; +type DListLink<T> = option<DListNode<T>>; -enum dlist_node<T> = @{ +enum DListNode<T> = @{ data: T, mut linked: bool, // for assertions - mut prev: dlist_link<T>, - mut next: dlist_link<T> + mut prev: DListLink<T>, + mut next: DListLink<T> }; -enum dlist<T> = @{ +enum DList<T> = @{ mut size: uint, - mut hd: dlist_link<T>, - mut tl: dlist_link<T>, + mut hd: DListLink<T>, + mut tl: DListLink<T>, }; -priv impl<T> dlist_node<T> { +priv impl<T> DListNode<T> { pure fn assert_links() { match self.next { some(neighbour) => match neighbour.prev { @@ -49,26 +49,26 @@ priv impl<T> dlist_node<T> { } } -impl<T> dlist_node<T> { +impl<T> DListNode<T> { /// Get the next node in the list, if there is one. - pure fn next_link() -> option<dlist_node<T>> { + pure fn next_link() -> option<DListNode<T>> { self.assert_links(); self.next } /// Get the next node in the list, failing if there isn't one. - pure fn next_node() -> dlist_node<T> { + pure fn next_node() -> DListNode<T> { match self.next_link() { some(nobe) => nobe, none => fail ~"This dlist node has no next neighbour." } } /// Get the previous node in the list, if there is one. - pure fn prev_link() -> option<dlist_node<T>> { + pure fn prev_link() -> option<DListNode<T>> { self.assert_links(); self.prev } /// Get the previous node in the list, failing if there isn't one. - pure fn prev_node() -> dlist_node<T> { + pure fn prev_node() -> DListNode<T> { match self.prev_link() { some(nobe) => nobe, none => fail ~"This dlist node has no previous neighbour." @@ -77,24 +77,24 @@ impl<T> dlist_node<T> { } /// Creates a new dlist node with the given data. -pure fn new_dlist_node<T>(+data: T) -> dlist_node<T> { - dlist_node(@{data: data, mut linked: false, +pure fn new_dlist_node<T>(+data: T) -> DListNode<T> { + DListNode(@{data: data, mut linked: false, mut prev: none, mut next: none}) } /// Creates a new, empty dlist. -pure fn new_dlist<T>() -> dlist<T> { - dlist(@{mut size: 0, mut hd: none, mut tl: none}) +pure fn new_dlist<T>() -> DList<T> { + DList(@{mut size: 0, mut hd: none, mut tl: none}) } /// Creates a new dlist with a single element -pure fn from_elem<T>(+data: T) -> dlist<T> { +pure fn from_elem<T>(+data: T) -> DList<T> { let list = new_dlist(); unchecked { list.push(data); } list } -fn from_vec<T: copy>(+vec: &[T]) -> dlist<T> { +fn from_vec<T: copy>(+vec: &[T]) -> DList<T> { do vec::foldl(new_dlist(), vec) |list,data| { list.push(data); // Iterating left-to-right -- add newly to the tail. list @@ -103,7 +103,7 @@ fn from_vec<T: copy>(+vec: &[T]) -> dlist<T> { /// Produce a list from a list of lists, leaving no elements behind in the /// input. O(number of sub-lists). -fn concat<T>(lists: dlist<dlist<T>>) -> dlist<T> { +fn concat<T>(lists: DList<DList<T>>) -> DList<T> { let result = new_dlist(); while !lists.is_empty() { result.append(lists.pop().get()); @@ -111,12 +111,12 @@ fn concat<T>(lists: dlist<dlist<T>>) -> dlist<T> { result } -priv impl<T> dlist<T> { - pure fn new_link(-data: T) -> dlist_link<T> { - some(dlist_node(@{data: data, mut linked: true, +priv impl<T> DList<T> { + pure fn new_link(-data: T) -> DListLink<T> { + some(DListNode(@{data: data, mut linked: true, mut prev: none, mut next: none})) } - pure fn assert_mine(nobe: dlist_node<T>) { + pure fn assert_mine(nobe: DListNode<T>) { // These asserts could be stronger if we had node-root back-pointers, // but those wouldn't allow for O(1) append. if self.size == 0 { @@ -130,7 +130,7 @@ priv impl<T> dlist<T> { fail ~"That node isn't on this dlist." } } - fn make_mine(nobe: dlist_node<T>) { + fn make_mine(nobe: DListNode<T>) { if nobe.prev.is_some() || nobe.next.is_some() || nobe.linked { fail ~"Cannot insert node that's already on a dlist!" } @@ -139,7 +139,7 @@ priv impl<T> dlist<T> { // Link two nodes together. If either of them are 'none', also sets // the head and/or tail pointers appropriately. #[inline(always)] - fn link(+before: dlist_link<T>, +after: dlist_link<T>) { + fn link(+before: DListLink<T>, +after: DListLink<T>) { match before { some(neighbour) => neighbour.next = after, none => self.hd = after @@ -150,7 +150,7 @@ priv impl<T> dlist<T> { } } // Remove a node from the list. - fn unlink(nobe: dlist_node<T>) { + fn unlink(nobe: DListNode<T>) { self.assert_mine(nobe); assert self.size > 0; self.link(nobe.prev, nobe.next); @@ -160,24 +160,24 @@ priv impl<T> dlist<T> { self.size -= 1; } - fn add_head(+nobe: dlist_link<T>) { + fn add_head(+nobe: DListLink<T>) { self.link(nobe, self.hd); // Might set tail too. self.hd = nobe; self.size += 1; } - fn add_tail(+nobe: dlist_link<T>) { + fn add_tail(+nobe: DListLink<T>) { self.link(self.tl, nobe); // Might set head too. self.tl = nobe; self.size += 1; } - fn insert_left(nobe: dlist_link<T>, neighbour: dlist_node<T>) { + fn insert_left(nobe: DListLink<T>, neighbour: DListNode<T>) { self.assert_mine(neighbour); assert self.size > 0; self.link(neighbour.prev, nobe); self.link(nobe, some(neighbour)); self.size += 1; } - fn insert_right(neighbour: dlist_node<T>, nobe: dlist_link<T>) { + fn insert_right(neighbour: DListNode<T>, nobe: DListLink<T>) { self.assert_mine(neighbour); assert self.size > 0; self.link(nobe, neighbour.next); @@ -186,7 +186,7 @@ priv impl<T> dlist<T> { } } -impl<T> dlist<T> { +impl<T> DList<T> { /// Get the size of the list. O(1). pure fn len() -> uint { self.size } /// Returns true if the list is empty. O(1). @@ -202,7 +202,7 @@ impl<T> dlist<T> { * Add data to the head of the list, and get the new containing * node. O(1). */ - fn push_head_n(+data: T) -> dlist_node<T> { + fn push_head_n(+data: T) -> DListNode<T> { let mut nobe = self.new_link(data); self.add_head(nobe); option::get(nobe) @@ -215,7 +215,7 @@ impl<T> dlist<T> { * Add data to the tail of the list, and get the new containing * node. O(1). */ - fn push_n(+data: T) -> dlist_node<T> { + fn push_n(+data: T) -> DListNode<T> { let mut nobe = self.new_link(data); self.add_tail(nobe); option::get(nobe) @@ -224,14 +224,14 @@ impl<T> dlist<T> { * Insert data into the middle of the list, left of the given node. * O(1). */ - fn insert_before(+data: T, neighbour: dlist_node<T>) { + fn insert_before(+data: T, neighbour: DListNode<T>) { self.insert_left(self.new_link(data), neighbour); } /** * Insert an existing node in the middle of the list, left of the * given node. O(1). */ - fn insert_n_before(nobe: dlist_node<T>, neighbour: dlist_node<T>) { + fn insert_n_before(nobe: DListNode<T>, neighbour: DListNode<T>) { self.make_mine(nobe); self.insert_left(some(nobe), neighbour); } @@ -239,7 +239,7 @@ impl<T> dlist<T> { * Insert data in the middle of the list, left of the given node, * and get its containing node. O(1). */ - fn insert_before_n(+data: T, neighbour: dlist_node<T>) -> dlist_node<T> { + fn insert_before_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> { let mut nobe = self.new_link(data); self.insert_left(nobe, neighbour); option::get(nobe) @@ -248,14 +248,14 @@ impl<T> dlist<T> { * Insert data into the middle of the list, right of the given node. * O(1). */ - fn insert_after(+data: T, neighbour: dlist_node<T>) { + fn insert_after(+data: T, neighbour: DListNode<T>) { self.insert_right(neighbour, self.new_link(data)); } /** * Insert an existing node in the middle of the list, right of the * given node. O(1). */ - fn insert_n_after(nobe: dlist_node<T>, neighbour: dlist_node<T>) { + fn insert_n_after(nobe: DListNode<T>, neighbour: DListNode<T>) { self.make_mine(nobe); self.insert_right(neighbour, some(nobe)); } @@ -263,38 +263,38 @@ impl<T> dlist<T> { * Insert data in the middle of the list, right of the given node, * and get its containing node. O(1). */ - fn insert_after_n(+data: T, neighbour: dlist_node<T>) -> dlist_node<T> { + fn insert_after_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> { let mut nobe = self.new_link(data); self.insert_right(neighbour, nobe); option::get(nobe) } /// Remove a node from the head of the list. O(1). - fn pop_n() -> option<dlist_node<T>> { + fn pop_n() -> option<DListNode<T>> { let hd = self.peek_n(); hd.map(|nobe| self.unlink(nobe)); hd } /// Remove a node from the tail of the list. O(1). - fn pop_tail_n() -> option<dlist_node<T>> { + fn pop_tail_n() -> option<DListNode<T>> { let tl = self.peek_tail_n(); tl.map(|nobe| self.unlink(nobe)); tl } /// Get the node at the list's head. O(1). - pure fn peek_n() -> option<dlist_node<T>> { self.hd } + pure fn peek_n() -> option<DListNode<T>> { self.hd } /// Get the node at the list's tail. O(1). - pure fn peek_tail_n() -> option<dlist_node<T>> { self.tl } + pure fn peek_tail_n() -> option<DListNode<T>> { self.tl } /// Get the node at the list's head, failing if empty. O(1). - pure fn head_n() -> dlist_node<T> { + pure fn head_n() -> DListNode<T> { match self.hd { some(nobe) => nobe, none => fail ~"Attempted to get the head of an empty dlist." } } /// Get the node at the list's tail, failing if empty. O(1). - pure fn tail_n() -> dlist_node<T> { + pure fn tail_n() -> DListNode<T> { match self.tl { some(nobe) => nobe, none => fail ~"Attempted to get the tail of an empty dlist." @@ -302,13 +302,13 @@ impl<T> dlist<T> { } /// Remove a node from anywhere in the list. O(1). - fn remove(nobe: dlist_node<T>) { self.unlink(nobe); } + fn remove(nobe: DListNode<T>) { self.unlink(nobe); } /** * Empty another list onto the end of this list, joining this list's tail * to the other list's head. O(1). */ - fn append(them: dlist<T>) { + fn append(them: DList<T>) { if box::ptr_eq(*self, *them) { fail ~"Cannot append a dlist to itself!" } @@ -325,7 +325,7 @@ impl<T> dlist<T> { * Empty another list onto the start of this list, joining the other * list's tail to this list's head. O(1). */ - fn prepend(them: dlist<T>) { + fn prepend(them: DList<T>) { if box::ptr_eq(*self, *them) { fail ~"Cannot prepend a dlist to itself!" } @@ -363,7 +363,7 @@ impl<T> dlist<T> { } /// Iterate over nodes. - pure fn each_node(f: fn(dlist_node<T>) -> bool) { + pure fn each_node(f: fn(DListNode<T>) -> bool) { let mut link = self.peek_n(); while link.is_some() { let nobe = link.get(); @@ -415,7 +415,7 @@ impl<T> dlist<T> { } } -impl<T: copy> dlist<T> { +impl<T: copy> DList<T> { /// Remove data from the head of the list. O(1). fn pop() -> option<T> { self.pop_n().map (|nobe| nobe.data) } /// Remove data from the tail of the list. O(1). diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs index 1f349b67002..ecbff6f12df 100644 --- a/src/libcore/dvec.rs +++ b/src/libcore/dvec.rs @@ -12,6 +12,7 @@ import unsafe::reinterpret_cast; import ptr::null; +export DVec; export dvec; export from_elem; export from_vec; @@ -49,36 +50,36 @@ export unwrap; * pointers achieved about 103 million pushes/second. Using an option * type could only produce 47 million pushes/second. */ -type dvec_<A> = { +type DVec_<A> = { mut data: ~[mut A] }; -enum dvec<A> { - dvec_(dvec_<A>) +enum DVec<A> { + DVec_(DVec_<A>) } /// Creates a new, empty dvec -fn dvec<A>() -> dvec<A> { - dvec_({mut data: ~[mut]}) +fn dvec<A>() -> DVec<A> { + DVec_({mut data: ~[mut]}) } /// Creates a new dvec with a single element -fn from_elem<A>(+e: A) -> dvec<A> { - dvec_({mut data: ~[mut e]}) +fn from_elem<A>(+e: A) -> DVec<A> { + DVec_({mut data: ~[mut e]}) } /// Creates a new dvec with the contents of a vector -fn from_vec<A>(+v: ~[mut A]) -> dvec<A> { - dvec_({mut data: v}) +fn from_vec<A>(+v: ~[mut A]) -> DVec<A> { + DVec_({mut data: v}) } /// Consumes the vector and returns its contents -fn unwrap<A>(+d: dvec<A>) -> ~[mut A] { - let dvec_({data: v}) <- d; +fn unwrap<A>(+d: DVec<A>) -> ~[mut A] { + let DVec_({data: v}) <- d; return v; } -priv impl<A> dvec<A> { +priv impl<A> DVec<A> { pure fn check_not_borrowed() { unsafe { let data: *() = unsafe::reinterpret_cast(self.data); @@ -110,7 +111,7 @@ priv impl<A> dvec<A> { // In theory, most everything should work with any A, but in practice // almost nothing works without the copy bound due to limitations // around closures. -impl<A> dvec<A> { +impl<A> DVec<A> { /// Reserves space for N elements fn reserve(count: uint) { vec::reserve(self.data, count) @@ -191,7 +192,7 @@ impl<A> dvec<A> { } } -impl<A: copy> dvec<A> { +impl<A: copy> DVec<A> { /** * Append all elements of a vector to the end of the list * @@ -308,7 +309,7 @@ impl<A: copy> dvec<A> { } } -impl<A:copy> dvec<A>: index<uint,A> { +impl<A:copy> DVec<A>: index<uint,A> { pure fn index(&&idx: uint) -> A { self.get_elt(idx) } diff --git a/src/libcore/either.rs b/src/libcore/either.rs index 6b9c1846c37..6e2698ce8ab 100644 --- a/src/libcore/either.rs +++ b/src/libcore/either.rs @@ -7,13 +7,13 @@ import result::result; /// The either type -enum either<T, U> { - left(T), - right(U) +enum Either<T, U> { + Left(T), + Right(U) } fn either<T, U, V>(f_left: fn((&T)) -> V, - f_right: fn((&U)) -> V, value: &either<T, U>) -> V { + f_right: fn((&U)) -> V, value: &Either<T, U>) -> V { /*! * Applies a function based on the given either value * @@ -23,38 +23,38 @@ fn either<T, U, V>(f_left: fn((&T)) -> V, */ match *value { - left(ref l) => f_left(l), - right(ref r) => f_right(r) + Left(ref l) => f_left(l), + Right(ref r) => f_right(r) } } -fn lefts<T: copy, U>(eithers: &[either<T, U>]) -> ~[T] { +fn lefts<T: copy, U>(eithers: &[Either<T, U>]) -> ~[T] { //! Extracts from a vector of either all the left values let mut result: ~[T] = ~[]; for vec::each(eithers) |elt| { match elt { - left(l) => vec::push(result, l), + Left(l) => vec::push(result, l), _ => { /* fallthrough */ } } } return result; } -fn rights<T, U: copy>(eithers: &[either<T, U>]) -> ~[U] { +fn rights<T, U: copy>(eithers: &[Either<T, U>]) -> ~[U] { //! Extracts from a vector of either all the right values let mut result: ~[U] = ~[]; for vec::each(eithers) |elt| { match elt { - right(r) => vec::push(result, r), + Right(r) => vec::push(result, r), _ => { /* fallthrough */ } } } return result; } -fn partition<T: copy, U: copy>(eithers: &[either<T, U>]) +fn partition<T: copy, U: copy>(eithers: &[Either<T, U>]) -> {lefts: ~[T], rights: ~[U]} { /*! * Extracts from a vector of either all the left values and right values @@ -67,23 +67,23 @@ fn partition<T: copy, U: copy>(eithers: &[either<T, U>]) let mut rights: ~[U] = ~[]; for vec::each(eithers) |elt| { match elt { - left(l) => vec::push(lefts, l), - right(r) => vec::push(rights, r) + Left(l) => vec::push(lefts, l), + Right(r) => vec::push(rights, r) } } return {lefts: lefts, rights: rights}; } -pure fn flip<T: copy, U: copy>(eith: &either<T, U>) -> either<U, T> { +pure fn flip<T: copy, U: copy>(eith: &Either<T, U>) -> Either<U, T> { //! Flips between left and right of a given either match *eith { - right(r) => left(r), - left(l) => right(l) + Right(r) => Left(r), + Left(l) => Right(l) } } -pure fn to_result<T: copy, U: copy>(eith: &either<T, U>) -> result<U, T> { +pure fn to_result<T: copy, U: copy>(eith: &Either<T, U>) -> result<U, T> { /*! * Converts either::t to a result::t * @@ -92,26 +92,26 @@ pure fn to_result<T: copy, U: copy>(eith: &either<T, U>) -> result<U, T> { */ match *eith { - right(r) => result::ok(r), - left(l) => result::err(l) + Right(r) => result::ok(r), + Left(l) => result::err(l) } } -pure fn is_left<T, U>(eith: &either<T, U>) -> bool { +pure fn is_left<T, U>(eith: &Either<T, U>) -> bool { //! Checks whether the given value is a left - match *eith { left(_) => true, _ => false } + match *eith { Left(_) => true, _ => false } } -pure fn is_right<T, U>(eith: &either<T, U>) -> bool { +pure fn is_right<T, U>(eith: &Either<T, U>) -> bool { //! Checks whether the given value is a right - match *eith { right(_) => true, _ => false } + match *eith { Right(_) => true, _ => false } } #[test] fn test_either_left() { - let val = left(10); + let val = Left(10); fn f_left(x: &int) -> bool { *x == 10 } fn f_right(_x: &uint) -> bool { false } assert (either(f_left, f_right, &val)); @@ -119,7 +119,7 @@ fn test_either_left() { #[test] fn test_either_right() { - let val = right(10u); + let val = Right(10u); fn f_left(_x: &int) -> bool { false } fn f_right(x: &uint) -> bool { *x == 10u } assert (either(f_left, f_right, &val)); @@ -127,49 +127,49 @@ fn test_either_right() { #[test] fn test_lefts() { - let input = ~[left(10), right(11), left(12), right(13), left(14)]; + let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; let result = lefts(input); assert (result == ~[10, 12, 14]); } #[test] fn test_lefts_none() { - let input: ~[either<int, int>] = ~[right(10), right(10)]; + let input: ~[Either<int, int>] = ~[Right(10), Right(10)]; let result = lefts(input); assert (vec::len(result) == 0u); } #[test] fn test_lefts_empty() { - let input: ~[either<int, int>] = ~[]; + let input: ~[Either<int, int>] = ~[]; let result = lefts(input); assert (vec::len(result) == 0u); } #[test] fn test_rights() { - let input = ~[left(10), right(11), left(12), right(13), left(14)]; + let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; let result = rights(input); assert (result == ~[11, 13]); } #[test] fn test_rights_none() { - let input: ~[either<int, int>] = ~[left(10), left(10)]; + let input: ~[Either<int, int>] = ~[Left(10), Left(10)]; let result = rights(input); assert (vec::len(result) == 0u); } #[test] fn test_rights_empty() { - let input: ~[either<int, int>] = ~[]; + let input: ~[Either<int, int>] = ~[]; let result = rights(input); assert (vec::len(result) == 0u); } #[test] fn test_partition() { - let input = ~[left(10), right(11), left(12), right(13), left(14)]; + let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)]; let result = partition(input); assert (result.lefts[0] == 10); assert (result.lefts[1] == 12); @@ -180,7 +180,7 @@ fn test_partition() { #[test] fn test_partition_no_lefts() { - let input: ~[either<int, int>] = ~[right(10), right(11)]; + let input: ~[Either<int, int>] = ~[Right(10), Right(11)]; let result = partition(input); assert (vec::len(result.lefts) == 0u); assert (vec::len(result.rights) == 2u); @@ -188,7 +188,7 @@ fn test_partition_no_lefts() { #[test] fn test_partition_no_rights() { - let input: ~[either<int, int>] = ~[left(10), left(11)]; + let input: ~[Either<int, int>] = ~[Left(10), Left(11)]; let result = partition(input); assert (vec::len(result.lefts) == 2u); assert (vec::len(result.rights) == 0u); @@ -196,7 +196,7 @@ fn test_partition_no_rights() { #[test] fn test_partition_empty() { - let input: ~[either<int, int>] = ~[]; + let input: ~[Either<int, int>] = ~[]; let result = partition(input); assert (vec::len(result.lefts) == 0u); assert (vec::len(result.rights) == 0u); diff --git a/src/libcore/future.rs b/src/libcore/future.rs index 79259c785fe..a935a50ddb6 100644 --- a/src/libcore/future.rs +++ b/src/libcore/future.rs @@ -15,7 +15,7 @@ * ~~~ */ -import either::either; +import either::Either; import pipes::recv; export future; @@ -32,7 +32,7 @@ export future_pipe; #[doc = "The future type"] enum future<A> = { - mut v: either<@A, fn@() -> A> + mut v: Either<@A, fn@() -> A> }; /// Methods on the `future` type @@ -60,7 +60,7 @@ fn from_value<A>(+val: A) -> future<A> { */ future({ - mut v: either::left(@val) + mut v: either::Left(@val) }) } @@ -97,7 +97,7 @@ fn from_fn<A>(f: fn@() -> A) -> future<A> { */ future({ - mut v: either::right(f) + mut v: either::Right(f) }) } @@ -124,10 +124,10 @@ fn with<A,B>(future: &future<A>, blk: fn((&A)) -> B) -> B { //! Work with the value without copying it let v = match copy future.v { - either::left(v) => v, - either::right(f) => { + either::Left(v) => v, + either::Right(f) => { let v = @f(); - future.v = either::left(v); + future.v = either::Left(v); v } }; diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs index 0819d702456..9ebfec47c7c 100644 --- a/src/libcore/int-template.rs +++ b/src/libcore/int-template.rs @@ -88,7 +88,7 @@ impl T: num::Num { static pure fn from_int(n: int) -> T { return n as T; } } -impl T: iter::times { +impl T: iter::Times { #[inline(always)] #[doc = "A convenience form for basic iteration. Given a variable `x` \ of any numeric type, the expression `for x.times { /* anything */ }` \ @@ -108,7 +108,7 @@ impl T: iter::times { } } -impl T: iter::timesi { +impl T: iter::TimesIx { #[inline(always)] /// Like `times`, but provides an index fn timesi(it: fn(uint) -> bool) { @@ -255,7 +255,7 @@ fn test_interfaces() { #[test] fn test_times() { - import iter::times; + import iter::Times; let ten = 10 as T; let mut accum = 0; for ten.times { accum += 1; } @@ -266,6 +266,6 @@ fn test_times() { #[should_fail] #[ignore(cfg(windows))] fn test_times_negative() { - import iter::times; + import iter::Times; for (-10).times { log(error, ~"nope!"); } } diff --git a/src/libcore/io.rs b/src/libcore/io.rs index c01672b5c73..d85ffb4981d 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -6,7 +6,7 @@ Basic input/output import result::result; -import dvec::dvec; +import dvec::{DVec, dvec}; import libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t}; import libc::consts::os::posix88::*; import libc::consts::os::extra::*; @@ -657,7 +657,7 @@ fn stderr() -> Writer { fd_writer(libc::STDERR_FILENO as c_int, false) } fn print(s: &str) { stdout().write_str(s); } fn println(s: &str) { stdout().write_line(s); } -type MemBuffer = @{buf: dvec<u8>, mut pos: uint}; +type MemBuffer = @{buf: DVec<u8>, mut pos: uint}; impl MemBuffer: Writer { fn write(v: &[const u8]) { diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs index d448292b1aa..5aeb958f5b2 100644 --- a/src/libcore/iter-trait.rs +++ b/src/libcore/iter-trait.rs @@ -5,12 +5,12 @@ import inst::{IMPL_T, EACH, SIZE_HINT}; export extensions; -impl<A> IMPL_T<A>: iter::base_iter<A> { +impl<A> IMPL_T<A>: iter::BaseIter<A> { fn each(blk: fn(A) -> bool) { EACH(self, blk) } fn size_hint() -> option<uint> { SIZE_HINT(self) } } -impl<A> IMPL_T<A>: iter::extended_iter<A> { +impl<A> IMPL_T<A>: iter::ExtendedIter<A> { fn eachi(blk: fn(uint, A) -> bool) { iter::eachi(self, blk) } fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) } fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) } @@ -24,7 +24,7 @@ impl<A> IMPL_T<A>: iter::extended_iter<A> { } } -impl<A: copy> IMPL_T<A>: iter::copyable_iter<A> { +impl<A: copy> IMPL_T<A>: iter::CopyableIter<A> { fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] { iter::filter_to_vec(self, pred) } diff --git a/src/libcore/iter-trait/dlist.rs b/src/libcore/iter-trait/dlist.rs index 9d8d147ffd7..91d6ffa765a 100644 --- a/src/libcore/iter-trait/dlist.rs +++ b/src/libcore/iter-trait/dlist.rs @@ -1,4 +1,5 @@ -type IMPL_T<A> = dlist::dlist<A>; +#[allow(non_camel_case_types)] +type IMPL_T<A> = dlist::DList<A>; /** * Iterates through the current contents. diff --git a/src/libcore/iter-trait/dvec.rs b/src/libcore/iter-trait/dvec.rs index d40eead14ff..5c02f8b5dea 100644 --- a/src/libcore/iter-trait/dvec.rs +++ b/src/libcore/iter-trait/dvec.rs @@ -1,4 +1,5 @@ -type IMPL_T<A> = dvec::dvec<A>; +#[allow(non_camel_case_types)] +type IMPL_T<A> = dvec::DVec<A>; /** * Iterates through the current contents. diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 2cb3369dbc7..06a1c6c9fba 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -1,9 +1,9 @@ -trait base_iter<A> { +trait BaseIter<A> { fn each(blk: fn(A) -> bool); fn size_hint() -> option<uint>; } -trait extended_iter<A> { +trait ExtendedIter<A> { fn eachi(blk: fn(uint, A) -> bool); fn all(blk: fn(A) -> bool) -> bool; fn any(blk: fn(A) -> bool) -> bool; @@ -13,14 +13,14 @@ trait extended_iter<A> { fn position(f: fn(A) -> bool) -> option<uint>; } -trait times { +trait Times { fn times(it: fn() -> bool); } -trait timesi{ +trait TimesIx{ fn timesi(it: fn(uint) -> bool); } -trait copyable_iter<A:copy> { +trait CopyableIter<A:copy> { fn filter_to_vec(pred: fn(A) -> bool) -> ~[A]; fn map_to_vec<B>(op: fn(A) -> B) -> ~[B]; fn to_vec() -> ~[A]; @@ -29,7 +29,7 @@ trait copyable_iter<A:copy> { fn find(p: fn(A) -> bool) -> option<A>; } -fn eachi<A,IA:base_iter<A>>(self: IA, blk: fn(uint, A) -> bool) { +fn eachi<A,IA:BaseIter<A>>(self: IA, blk: fn(uint, A) -> bool) { let mut i = 0u; for self.each |a| { if !blk(i, a) { break; } @@ -37,21 +37,21 @@ fn eachi<A,IA:base_iter<A>>(self: IA, blk: fn(uint, A) -> bool) { } } -fn all<A,IA:base_iter<A>>(self: IA, blk: fn(A) -> bool) -> bool { +fn all<A,IA:BaseIter<A>>(self: IA, blk: fn(A) -> bool) -> bool { for self.each |a| { if !blk(a) { return false; } } return true; } -fn any<A,IA:base_iter<A>>(self: IA, blk: fn(A) -> bool) -> bool { +fn any<A,IA:BaseIter<A>>(self: IA, blk: fn(A) -> bool) -> bool { for self.each |a| { if blk(a) { return true; } } return false; } -fn filter_to_vec<A:copy,IA:base_iter<A>>(self: IA, +fn filter_to_vec<A:copy,IA:BaseIter<A>>(self: IA, prd: fn(A) -> bool) -> ~[A] { let mut result = ~[]; self.size_hint().iter(|hint| vec::reserve(result, hint)); @@ -61,7 +61,7 @@ fn filter_to_vec<A:copy,IA:base_iter<A>>(self: IA, return result; } -fn map_to_vec<A:copy,B,IA:base_iter<A>>(self: IA, op: fn(A) -> B) -> ~[B] { +fn map_to_vec<A:copy,B,IA:BaseIter<A>>(self: IA, op: fn(A) -> B) -> ~[B] { let mut result = ~[]; self.size_hint().iter(|hint| vec::reserve(result, hint)); for self.each |a| { @@ -70,7 +70,7 @@ fn map_to_vec<A:copy,B,IA:base_iter<A>>(self: IA, op: fn(A) -> B) -> ~[B] { return result; } -fn flat_map_to_vec<A:copy,B:copy,IA:base_iter<A>,IB:base_iter<B>>( +fn flat_map_to_vec<A:copy,B:copy,IA:BaseIter<A>,IB:BaseIter<B>>( self: IA, op: fn(A) -> IB) -> ~[B] { let mut result = ~[]; @@ -82,7 +82,7 @@ fn flat_map_to_vec<A:copy,B:copy,IA:base_iter<A>,IB:base_iter<B>>( return result; } -fn foldl<A,B,IA:base_iter<A>>(self: IA, +b0: B, blk: fn(B, A) -> B) -> B { +fn foldl<A,B,IA:BaseIter<A>>(self: IA, +b0: B, blk: fn(B, A) -> B) -> B { let mut b <- b0; for self.each |a| { b = blk(b, a); @@ -90,18 +90,18 @@ fn foldl<A,B,IA:base_iter<A>>(self: IA, +b0: B, blk: fn(B, A) -> B) -> B { return b; } -fn to_vec<A:copy,IA:base_iter<A>>(self: IA) -> ~[A] { +fn to_vec<A:copy,IA:BaseIter<A>>(self: IA) -> ~[A] { foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(r, ~[a])) } -fn contains<A,IA:base_iter<A>>(self: IA, x: A) -> bool { +fn contains<A,IA:BaseIter<A>>(self: IA, x: A) -> bool { for self.each |a| { if a == x { return true; } } return false; } -fn count<A,IA:base_iter<A>>(self: IA, x: A) -> uint { +fn count<A,IA:BaseIter<A>>(self: IA, x: A) -> uint { do foldl(self, 0u) |count, value| { if value == x { count + 1u @@ -111,7 +111,7 @@ fn count<A,IA:base_iter<A>>(self: IA, x: A) -> uint { } } -fn position<A,IA:base_iter<A>>(self: IA, f: fn(A) -> bool) +fn position<A,IA:BaseIter<A>>(self: IA, f: fn(A) -> bool) -> option<uint> { let mut i = 0; for self.each |a| { @@ -133,7 +133,7 @@ fn repeat(times: uint, blk: fn() -> bool) { } } -fn min<A:copy,IA:base_iter<A>>(self: IA) -> A { +fn min<A:copy,IA:BaseIter<A>>(self: IA) -> A { match do foldl::<A,option<A>,IA>(self, none) |a, b| { match a { some(a_) if a_ < b => { @@ -149,7 +149,7 @@ fn min<A:copy,IA:base_iter<A>>(self: IA) -> A { } } -fn max<A:copy,IA:base_iter<A>>(self: IA) -> A { +fn max<A:copy,IA:BaseIter<A>>(self: IA) -> A { match do foldl::<A,option<A>,IA>(self, none) |a, b| { match a { some(a_) if a_ > b => { diff --git a/src/libcore/os.rs b/src/libcore/os.rs index ec4485bb123..7d5e98c08bd 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -177,16 +177,16 @@ mod global_env { do priv::weaken_task |weak_po| { loop { match comm::select2(msg_po, weak_po) { - either::left(MsgGetEnv(n, resp_ch)) => { + either::Left(MsgGetEnv(n, resp_ch)) => { comm::send(resp_ch, impl::getenv(n)) } - either::left(MsgSetEnv(n, v, resp_ch)) => { + either::Left(MsgSetEnv(n, v, resp_ch)) => { comm::send(resp_ch, impl::setenv(n, v)) } - either::left(MsgEnv(resp_ch)) => { + either::Left(MsgEnv(resp_ch)) => { comm::send(resp_ch, impl::env()) } - either::right(_) => break + either::Right(_) => break } } } diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index ba8ac5cae87..6de2059d2de 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -77,7 +77,7 @@ bounded and unbounded protocols allows for less code duplication. #[forbid(deprecated_pattern)]; import unsafe::{forget, reinterpret_cast, transmute}; -import either::{either, left, right}; +import either::{Either, Left, Right}; import option::unwrap; // Things used by code generated by the pipe compiler. @@ -658,15 +658,15 @@ this case, `select2` may return either `left` or `right`. fn select2<A: send, Ab: send, B: send, Bb: send>( +a: recv_packet_buffered<A, Ab>, +b: recv_packet_buffered<B, Bb>) - -> either<(option<A>, recv_packet_buffered<B, Bb>), + -> Either<(option<A>, recv_packet_buffered<B, Bb>), (recv_packet_buffered<A, Ab>, option<B>)> { let i = wait_many([a.header(), b.header()]/_); unsafe { match i { - 0 => left((try_recv(a), b)), - 1 => right((a, try_recv(b))), + 0 => Left((try_recv(a), b)), + 1 => Right((a, try_recv(b))), _ => fail ~"select2 return an invalid packet" } } @@ -687,10 +687,10 @@ fn selecti<T: selectable>(endpoints: &[T]) -> uint { } /// Returns 0 or 1 depending on which endpoint is ready to receive -fn select2i<A: selectable, B: selectable>(a: &A, b: &B) -> either<(), ()> { +fn select2i<A: selectable, B: selectable>(a: &A, b: &B) -> Either<(), ()> { match wait_many([a.header(), b.header()]/_) { - 0 => left(()), - 1 => right(()), + 0 => Left(()), + 1 => Right(()), _ => fail ~"wait returned unexpected index" } } @@ -1117,28 +1117,28 @@ fn shared_chan<T:send>(+c: chan<T>) -> shared_chan<T> { /// Receive a message from one of two endpoints. trait select2<T: send, U: send> { /// Receive a message or return `none` if a connection closes. - fn try_select() -> either<option<T>, option<U>>; + fn try_select() -> Either<option<T>, option<U>>; /// Receive a message or fail if a connection closes. - fn select() -> either<T, U>; + fn select() -> Either<T, U>; } impl<T: send, U: send, Left: selectable recv<T>, Right: selectable recv<U>> (Left, Right): select2<T, U> { - fn select() -> either<T, U> { + fn select() -> Either<T, U> { match self { (lp, rp) => match select2i(&lp, &rp) { - left(()) => left (lp.recv()), - right(()) => right(rp.recv()) + Left(()) => Left (lp.recv()), + Right(()) => Right(rp.recv()) } } } - fn try_select() -> either<option<T>, option<U>> { + fn try_select() -> Either<option<T>, option<U>> { match self { (lp, rp) => match select2i(&lp, &rp) { - left(()) => left (lp.try_recv()), - right(()) => right(rp.try_recv()) + Left(()) => Left (lp.try_recv()), + Right(()) => Right(rp.try_recv()) } } } @@ -1204,7 +1204,7 @@ mod test { c1.send(~"abc"); match (p1, p2).select() { - right(_) => fail, + Right(_) => fail, _ => () } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index b7b63af0afb..2c3ff0121ba 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -16,7 +16,7 @@ export to_uint; export ref_eq; export buf_len; export position; -export ptr; +export Ptr; import libc::{c_void, size_t}; @@ -156,13 +156,13 @@ fn ref_eq<T>(thing: &a/T, other: &b/T) -> bool { to_uint(thing) == to_uint(other) } -trait ptr { +trait Ptr { pure fn is_null() -> bool; pure fn is_not_null() -> bool; } /// Extension methods for pointers -impl<T> *T: ptr { +impl<T> *T: Ptr { /// Returns true if the pointer is equal to the null pointer. pure fn is_null() -> bool { is_null(self) } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 762191842b8..341d28e67e8 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -1,6 +1,6 @@ //! A type representing either success or failure -import either::either; +import either::Either; /// The result type enum result<T, U> { @@ -59,10 +59,10 @@ pure fn is_err<T, U>(res: result<T, U>) -> bool { * `ok` result variants are converted to `either::right` variants, `err` * result variants are converted to `either::left`. */ -pure fn to_either<T: copy, U: copy>(res: result<U, T>) -> either<T, U> { +pure fn to_either<T: copy, U: copy>(res: result<U, T>) -> Either<T, U> { match res { - ok(res) => either::right(res), - err(fail_) => either::left(fail_) + ok(res) => either::Right(res), + err(fail_) => either::Left(fail_) } } diff --git a/src/libcore/send_map.rs b/src/libcore/send_map.rs index 1a130e0e273..cb8d596cf88 100644 --- a/src/libcore/send_map.rs +++ b/src/libcore/send_map.rs @@ -10,28 +10,28 @@ Sendable hash maps. Very much a work in progress. * * The hash should concentrate entropy in the lower bits. */ -type hashfn<K> = pure fn~(K) -> uint; -type eqfn<K> = pure fn~(K, K) -> bool; +type HashFn<K> = pure fn~(K) -> uint; +type EqFn<K> = pure fn~(K, K) -> bool; /// Open addressing with linear probing. mod linear { - export linear_map, linear_map_with_capacity, public_methods; + export LinearMap, linear_map, linear_map_with_capacity, public_methods; const initial_capacity: uint = 32u; // 2^5 - type bucket<K,V> = {hash: uint, key: K, value: V}; - enum linear_map<K,V> { - linear_map_({ + type Bucket<K,V> = {hash: uint, key: K, value: V}; + enum LinearMap<K,V> { + LinearMap_({ hashfn: pure fn~(x: &K) -> uint, eqfn: pure fn~(x: &K, y: &K) -> bool, resize_at: uint, size: uint, - buckets: ~[option<bucket<K,V>>]}) + buckets: ~[option<Bucket<K,V>>]}) } // FIXME(#2979) -- with #2979 we could rewrite found_entry // to have type option<&bucket<K,V>> which would be nifty - enum search_result { - found_entry(uint), found_hole(uint), table_full + enum SearchResult { + FoundEntry(uint), FoundHole(uint), TableFull } fn resize_at(capacity: uint) -> uint { @@ -40,7 +40,7 @@ mod linear { fn linear_map<K,V>( +hashfn: pure fn~(x: &K) -> uint, - +eqfn: pure fn~(x: &K, y: &K) -> bool) -> linear_map<K,V> { + +eqfn: pure fn~(x: &K, y: &K) -> bool) -> LinearMap<K,V> { linear_map_with_capacity(hashfn, eqfn, 32) } @@ -48,9 +48,9 @@ mod linear { fn linear_map_with_capacity<K,V>( +hashfn: pure fn~(x: &K) -> uint, +eqfn: pure fn~(x: &K, y: &K) -> bool, - initial_capacity: uint) -> linear_map<K,V> { + initial_capacity: uint) -> LinearMap<K,V> { - linear_map_({ + LinearMap_({ hashfn: hashfn, eqfn: eqfn, resize_at: resize_at(initial_capacity), @@ -64,7 +64,7 @@ mod linear { unsafe::reinterpret_cast(p) } - priv impl<K, V> &const linear_map<K,V> { + priv impl<K, V> &const LinearMap<K,V> { #[inline(always)] pure fn to_bucket(h: uint) -> uint { // FIXME(#3041) borrow a more sophisticated technique here from @@ -101,8 +101,8 @@ mod linear { #[inline(always)] pure fn bucket_for_key( - buckets: &[option<bucket<K,V>>], - k: &K) -> search_result { + buckets: &[option<Bucket<K,V>>], + k: &K) -> SearchResult { let hash = self.hashfn(k); self.bucket_for_key_with_hash(buckets, hash, k) @@ -110,23 +110,23 @@ mod linear { #[inline(always)] pure fn bucket_for_key_with_hash( - buckets: &[option<bucket<K,V>>], + buckets: &[option<Bucket<K,V>>], hash: uint, - k: &K) -> search_result { + k: &K) -> SearchResult { let _ = for self.bucket_sequence(hash) |i| { match buckets[i] { some(bkt) => if bkt.hash == hash && self.eqfn(k, &bkt.key) { - return found_entry(i); + return FoundEntry(i); }, - none => return found_hole(i) + none => return FoundHole(i) } }; - return table_full; + return TableFull; } } - priv impl<K,V> &mut linear_map<K,V> { + priv impl<K,V> &mut LinearMap<K,V> { /// Expands the capacity of the array and re-inserts each /// of the existing buckets. fn expand() { @@ -146,7 +146,7 @@ mod linear { } } - fn insert_bucket(+bucket: option<bucket<K,V>>) { + fn insert_bucket(+bucket: option<Bucket<K,V>>) { let {hash, key, value} <- option::unwrap(bucket); let _ = self.insert_internal(hash, key, value); } @@ -157,15 +157,15 @@ mod linear { fn insert_internal(hash: uint, +k: K, +v: V) -> bool { match self.bucket_for_key_with_hash(self.buckets, hash, unsafe{borrow(k)}) { - table_full => {fail ~"Internal logic error";} - found_hole(idx) => { + TableFull => {fail ~"Internal logic error";} + FoundHole(idx) => { debug!{"insert fresh (%?->%?) at idx %?, hash %?", k, v, idx, hash}; self.buckets[idx] = some({hash: hash, key: k, value: v}); self.size += 1; return true; } - found_entry(idx) => { + FoundEntry(idx) => { debug!{"insert overwrite (%?->%?) at idx %?, hash %?", k, v, idx, hash}; self.buckets[idx] = some({hash: hash, key: k, value: v}); @@ -175,7 +175,7 @@ mod linear { } } - impl<K,V> &mut linear_map<K,V> { + impl<K,V> &mut LinearMap<K,V> { fn insert(+k: K, +v: V) -> bool { if self.size >= self.resize_at { // n.b.: We could also do this after searching, so @@ -208,10 +208,10 @@ mod linear { // http://www.maths.lse.ac.uk/Courses/MA407/del-hash.pdf let mut idx = match self.bucket_for_key(self.buckets, k) { - table_full | found_hole(_) => { + TableFull | FoundHole(_) => { return false; } - found_entry(idx) => { + FoundEntry(idx) => { idx } }; @@ -230,13 +230,13 @@ mod linear { } } - priv impl<K,V> &linear_map<K,V> { - fn search(hash: uint, op: fn(x: &option<bucket<K,V>>) -> bool) { + priv impl<K,V> &LinearMap<K,V> { + fn search(hash: uint, op: fn(x: &option<Bucket<K,V>>) -> bool) { let _ = self.bucket_sequence(hash, |i| op(&self.buckets[i])); } } - impl<K,V> &const linear_map<K,V> { + impl<K,V> &const LinearMap<K,V> { pure fn len() -> uint { self.size } @@ -247,21 +247,21 @@ mod linear { fn contains_key(k: &K) -> bool { match self.bucket_for_key(self.buckets, k) { - found_entry(_) => {true} - table_full | found_hole(_) => {false} + FoundEntry(_) => {true} + TableFull | FoundHole(_) => {false} } } } - impl<K,V: copy> &const linear_map<K,V> { + impl<K,V: copy> &const LinearMap<K,V> { fn find(k: &K) -> option<V> { match self.bucket_for_key(self.buckets, k) { - found_entry(idx) => { + FoundEntry(idx) => { match check self.buckets[idx] { some(bkt) => {some(copy bkt.value)} } } - table_full | found_hole(_) => { + TableFull | FoundHole(_) => { none } } @@ -277,7 +277,7 @@ mod linear { } - impl<K,V> &linear_map<K,V> { + impl<K,V> &LinearMap<K,V> { /* FIXME --- #2979 must be fixed to typecheck this fn find_ptr(k: K) -> option<&V> { @@ -306,17 +306,17 @@ mod linear { } } - impl<K: copy, V: copy> &linear_map<K,V> { + impl<K: copy, V: copy> &LinearMap<K,V> { fn each(blk: fn(+K,+V) -> bool) { self.each_ref(|k,v| blk(copy *k, copy *v)); } } - impl<K: copy, V> &linear_map<K,V> { + impl<K: copy, V> &LinearMap<K,V> { fn each_key(blk: fn(+K) -> bool) { self.each_key_ref(|k| blk(copy *k)); } } - impl<K, V: copy> &linear_map<K,V> { + impl<K, V: copy> &LinearMap<K,V> { fn each_value(blk: fn(+V) -> bool) { self.each_value_ref(|v| blk(copy *v)); } @@ -326,12 +326,12 @@ mod linear { #[test] mod test { - import linear::linear_map; + import linear::{LinearMap, linear_map}; pure fn uint_hash(x: &uint) -> uint { *x } pure fn uint_eq(x: &uint, y: &uint) -> bool { *x == *y } - fn int_linear_map<V>() -> linear_map<uint,V> { + fn int_linear_map<V>() -> LinearMap<uint,V> { return linear_map(uint_hash, uint_eq); } diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 9a1e32a6711..d73c71c510a 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -108,8 +108,8 @@ export unsafe, extensions, - str_slice, - unique_str; + StrSlice, + UniqueStr; #[abi = "cdecl"] extern mod rustrt { @@ -1877,7 +1877,7 @@ mod unsafe { /// Sets the length of the string and adds the null terminator unsafe fn set_len(&v: ~str, new_len: uint) { - let repr: *vec::unsafe::vec_repr = ::unsafe::reinterpret_cast(v); + let repr: *vec::unsafe::VecRepr = ::unsafe::reinterpret_cast(v); (*repr).fill = new_len + 1u; let null = ptr::mut_offset(ptr::mut_addr_of((*repr).data), new_len); *null = 0u8; @@ -1895,14 +1895,14 @@ mod unsafe { } -trait unique_str { +trait UniqueStr { fn trim() -> self; fn trim_left() -> self; fn trim_right() -> self; } /// Extension methods for strings -impl ~str: unique_str { +impl ~str: UniqueStr { /// Returns a string with leading and trailing whitespace removed #[inline] fn trim() -> ~str { trim(self) } @@ -1922,7 +1922,7 @@ impl ~str: add<&str,~str> { } } -trait str_slice { +trait StrSlice { fn all(it: fn(char) -> bool) -> bool; fn any(it: fn(char) -> bool) -> bool; fn contains(needle: &a/str) -> bool; @@ -1951,7 +1951,7 @@ trait str_slice { } /// Extension methods for strings -impl &str: str_slice { +impl &str: StrSlice { /** * Return true if a predicate matches all characters or if the string * contains no characters diff --git a/src/libcore/task.rs b/src/libcore/task.rs index 2748b53fb54..678cda32404 100644 --- a/src/libcore/task.rs +++ b/src/libcore/task.rs @@ -693,7 +693,7 @@ type task_id = int; type rust_task = libc::c_void; type rust_closure = libc::c_void; -type taskset = send_map::linear::linear_map<*rust_task,()>; +type taskset = send_map::linear::LinearMap<*rust_task,()>; fn new_taskset() -> taskset { pure fn task_hash(t: &*rust_task) -> uint { @@ -1271,7 +1271,7 @@ impl<T: owned> @T: local_data { } // heavily in future, this could be made more efficient with a proper map. type task_local_element = (*libc::c_void, *libc::c_void, local_data); // Has to be a pointer at outermost layer; the foreign call returns void *. -type task_local_map = @dvec::dvec<option<task_local_element>>; +type task_local_map = @dvec::DVec<option<task_local_element>>; extern fn cleanup_task_local_map(map_ptr: *libc::c_void) unsafe { assert !map_ptr.is_null(); diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs index 0fc35156f3a..4f27e8cea8f 100644 --- a/src/libcore/uint-template.rs +++ b/src/libcore/uint-template.rs @@ -80,7 +80,7 @@ impl T: num::Num { static pure fn from_int(n: int) -> T { return n as T; } } -impl T: iter::times { +impl T: iter::Times { #[inline(always)] #[doc = "A convenience form for basic iteration. Given a variable `x` \ of any numeric type, the expression `for x.times { /* anything */ }` \ @@ -96,7 +96,7 @@ impl T: iter::times { } } -impl T: iter::timesi { +impl T: iter::TimesIx { #[inline(always)] /// Like `times`, but with an index, `eachi`-style. fn timesi(it: fn(uint) -> bool) { @@ -295,7 +295,7 @@ fn to_str_radix17() { #[test] fn test_times() { - import iter::times; + import iter::Times; let ten = 10 as T; let mut accum = 0; for ten.times { accum += 1; } diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 6bd0e8c8cd2..e53cd1ddccf 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -86,21 +86,21 @@ export as_const_buf; export unsafe; export u8; export extensions; -export const_vector; -export copyable_vector; -export immutable_vector; -export immutable_copyable_vector; -export iter_trait_extensions; +export ConstVector; +export CopyableVector; +export ImmutableVector; +export ImmutableCopyableVector; +export IterTraitExtensions; export vec_concat; #[abi = "cdecl"] extern mod rustrt { fn vec_reserve_shared(++t: *sys::TypeDesc, - ++v: **unsafe::vec_repr, + ++v: **unsafe::VecRepr, ++n: libc::size_t); fn vec_from_buf_shared(++t: *sys::TypeDesc, ++ptr: *(), - ++count: libc::size_t) -> *unsafe::vec_repr; + ++count: libc::size_t) -> *unsafe::VecRepr; } #[abi = "rust-intrinsic"] @@ -109,7 +109,7 @@ extern mod rusti { } /// A function used to initialize the elements of a vector -type init_op/&<T> = fn(uint) -> T; +type InitOp/&<T> = fn(uint) -> T; /// Returns true if a vector contains no elements pure fn is_empty<T>(v: &[const T]) -> bool { @@ -140,7 +140,7 @@ pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool { fn reserve<T>(&v: ~[const T], n: uint) { // Only make the (slow) call into the runtime if we have to if capacity(v) < n { - let ptr = ptr::addr_of(v) as **unsafe::vec_repr; + let ptr = ptr::addr_of(v) as **unsafe::VecRepr; rustrt::vec_reserve_shared(sys::get_type_desc::<T>(), ptr, n as size_t); } @@ -169,7 +169,7 @@ fn reserve_at_least<T>(&v: ~[const T], n: uint) { #[inline(always)] pure fn capacity<T>(&&v: ~[const T]) -> uint { unsafe { - let repr: **unsafe::vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **unsafe::VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); (**repr).alloc / sys::size_of::<T>() } } @@ -186,7 +186,7 @@ pure fn len<T>(&&v: &[const T]) -> uint { * Creates an immutable vector of size `n_elts` and initializes the elements * to the value returned by the function `op`. */ -pure fn from_fn<T>(n_elts: uint, op: init_op<T>) -> ~[T] { +pure fn from_fn<T>(n_elts: uint, op: InitOp<T>) -> ~[T] { let mut v = ~[]; unchecked{reserve(v, n_elts);} let mut i: uint = 0u; @@ -523,7 +523,7 @@ fn pop<T>(&v: ~[const T]) -> T { #[inline(always)] fn push<T>(&v: ~[const T], +initval: T) { unsafe { - let repr: **unsafe::vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **unsafe::VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); let fill = (**repr).fill; if (**repr).alloc > fill { push_fast(v, initval); @@ -537,7 +537,7 @@ fn push<T>(&v: ~[const T], +initval: T) { // This doesn't bother to make sure we have space. #[inline(always)] // really pretty please unsafe fn push_fast<T>(&v: ~[const T], +initval: T) { - let repr: **unsafe::vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **unsafe::VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); let fill = (**repr).fill; (**repr).fill += sys::size_of::<T>(); let p = ptr::addr_of((**repr).data); @@ -640,7 +640,7 @@ fn grow<T: copy>(&v: ~[const T], n: uint, initval: T) { * * init_op - A function to call to retreive each appended element's * value */ -fn grow_fn<T>(&v: ~[const T], n: uint, op: init_op<T>) { +fn grow_fn<T>(&v: ~[const T], n: uint, op: InitOp<T>) { reserve_at_least(v, len(v) + n); let mut i: uint = 0u; while i < n { push(v, op(i)); i += 1u; } @@ -1304,14 +1304,14 @@ impl<T: copy> ~[mut T]: add<&[const T],~[mut T]> { } } -trait const_vector { +trait ConstVector { pure fn is_empty() -> bool; pure fn is_not_empty() -> bool; pure fn len() -> uint; } /// Extension methods for vectors -impl<T> &[const T]: const_vector { +impl<T> &[const T]: ConstVector { /// Returns true if a vector contains no elements #[inline] pure fn is_empty() -> bool { is_empty(self) } @@ -1323,7 +1323,7 @@ impl<T> &[const T]: const_vector { pure fn len() -> uint { len(self) } } -trait copyable_vector<T> { +trait CopyableVector<T> { pure fn head() -> T; pure fn init() -> ~[T]; pure fn last() -> T; @@ -1332,7 +1332,7 @@ trait copyable_vector<T> { } /// Extension methods for vectors -impl<T: copy> &[const T]: copyable_vector<T> { +impl<T: copy> &[const T]: CopyableVector<T> { /// Returns the first element of a vector #[inline] pure fn head() -> T { head(self) } @@ -1350,7 +1350,7 @@ impl<T: copy> &[const T]: copyable_vector<T> { pure fn tail() -> ~[T] { tail(self) } } -trait immutable_vector<T> { +trait ImmutableVector<T> { pure fn foldr<U: copy>(z: U, p: fn(T, U) -> U) -> U; pure fn iter(f: fn(T)); pure fn iteri(f: fn(uint, T)); @@ -1369,7 +1369,7 @@ trait immutable_vector<T> { } /// Extension methods for vectors -impl<T> &[T]: immutable_vector<T> { +impl<T> &[T]: ImmutableVector<T> { /// Reduce a vector from right to left #[inline] pure fn foldr<U: copy>(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) } @@ -1477,14 +1477,14 @@ impl<T> &[T]: immutable_vector<T> { } } -trait immutable_copyable_vector<T> { +trait ImmutableCopyableVector<T> { pure fn filter(f: fn(T) -> bool) -> ~[T]; pure fn find(f: fn(T) -> bool) -> option<T>; pure fn rfind(f: fn(T) -> bool) -> option<T>; } /// Extension methods for vectors -impl<T: copy> &[T]: immutable_copyable_vector<T> { +impl<T: copy> &[T]: ImmutableCopyableVector<T> { /** * Construct a new vector from the elements of a vector for which some * predicate holds. @@ -1518,14 +1518,14 @@ impl<T: copy> &[T]: immutable_copyable_vector<T> { mod unsafe { // FIXME: This should have crate visibility (#1893 blocks that) /// The internal representation of a vector - type vec_repr = { + type VecRepr = { box_header: (uint, uint, uint, uint), mut fill: uint, mut alloc: uint, data: u8 }; - type slice_repr = { + type SliceRepr = { mut data: *u8, mut len: uint }; @@ -1555,7 +1555,7 @@ mod unsafe { */ #[inline(always)] unsafe fn set_len<T>(&&v: ~[const T], new_len: uint) { - let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); (**repr).fill = new_len * sys::size_of::<T>(); } @@ -1570,14 +1570,14 @@ mod unsafe { */ #[inline(always)] unsafe fn to_ptr<T>(v: ~[const T]) -> *T { - let repr: **vec_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **VecRepr = ::unsafe::reinterpret_cast(addr_of(v)); return ::unsafe::reinterpret_cast(addr_of((**repr).data)); } #[inline(always)] unsafe fn to_ptr_slice<T>(v: &[const T]) -> *T { - let repr: **slice_repr = ::unsafe::reinterpret_cast(addr_of(v)); + let repr: **SliceRepr = ::unsafe::reinterpret_cast(addr_of(v)); return ::unsafe::reinterpret_cast(addr_of((**repr).data)); } @@ -1729,12 +1729,12 @@ mod u8 { // This cannot be used with iter-trait.rs because of the region pointer // required in the slice. -impl<A> &[A]: iter::base_iter<A> { +impl<A> &[A]: iter::BaseIter<A> { fn each(blk: fn(A) -> bool) { each(self, blk) } fn size_hint() -> option<uint> { some(len(self)) } } -impl<A> &[A]: iter::extended_iter<A> { +impl<A> &[A]: iter::ExtendedIter<A> { fn eachi(blk: fn(uint, A) -> bool) { iter::eachi(self, blk) } fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) } fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) } @@ -1746,7 +1746,7 @@ impl<A> &[A]: iter::extended_iter<A> { fn position(f: fn(A) -> bool) -> option<uint> { iter::position(self, f) } } -trait iter_trait_extensions<A> { +trait IterTraitExtensions<A> { fn filter_to_vec(pred: fn(A) -> bool) -> ~[A]; fn map_to_vec<B>(op: fn(A) -> B) -> ~[B]; fn to_vec() -> ~[A]; @@ -1754,7 +1754,7 @@ trait iter_trait_extensions<A> { fn max() -> A; } -impl<A: copy> &[A]: iter_trait_extensions<A> { +impl<A: copy> &[A]: IterTraitExtensions<A> { fn filter_to_vec(pred: fn(A) -> bool) -> ~[A] { iter::filter_to_vec(self, pred) } diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 8bb7ae64825..7b8c0e9fcad 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -1,7 +1,7 @@ //! A deque. Untested as of yet. Likely buggy import option::{some, none}; -import dvec::dvec; +import dvec::{DVec, dvec}; trait t<T> { fn size() -> uint; @@ -40,14 +40,14 @@ fn create<T: copy>() -> t<T> { return rv; } - fn get<T: copy>(elts: dvec<cell<T>>, i: uint) -> T { + fn get<T: copy>(elts: DVec<cell<T>>, i: uint) -> T { match elts.get_elt(i) { some(t) => t, _ => fail } } type repr<T> = {mut nelts: uint, mut lo: uint, mut hi: uint, - elts: dvec<cell<T>>}; + elts: DVec<cell<T>>}; impl <T: copy> repr<T>: t<T> { fn size() -> uint { return self.nelts; } diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index 927fe75b1a9..0c8d974a6d7 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -3,7 +3,7 @@ import map; import map::{hashmap, str_hash}; import io::Reader; -import dvec::dvec; +import dvec::{DVec, dvec}; export url, userinfo, query; export from_str, to_str; @@ -176,7 +176,7 @@ fn encode_plus(s: ~str) -> ~str { /** * Encode a hashmap to the 'application/x-www-form-urlencoded' media type. */ -fn encode_form_urlencoded(m: hashmap<~str, @dvec<@~str>>) -> ~str { +fn encode_form_urlencoded(m: hashmap<~str, @DVec<@~str>>) -> ~str { let mut out = ~""; let mut first = true; @@ -203,7 +203,7 @@ fn encode_form_urlencoded(m: hashmap<~str, @dvec<@~str>>) -> ~str { * type into a hashmap. */ fn decode_form_urlencoded(s: ~[u8]) -> - map::hashmap<~str, @dvec::dvec<@~str>> { + map::hashmap<~str, @dvec::DVec<@~str>> { do io::with_bytes_reader(s) |rdr| { let m = str_hash(); let mut key = ~""; diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 4248cec854f..a7b40bbb0f9 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -4,12 +4,12 @@ */ import core::option; import core::option::{some, none}; -import dvec::dvec; +import dvec::{DVec, dvec}; import map::map; // FIXME (#2347): Should not be @; there's a bug somewhere in rustc that // requires this to be. -type smallintmap_<T: copy> = {v: dvec<option<T>>}; +type smallintmap_<T: copy> = {v: DVec<option<T>>}; enum smallintmap<T:copy> { smallintmap_(@smallintmap_<T>) diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 9d33431f000..6b78fa9b032 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -5,7 +5,7 @@ // simplest interface possible for representing and running tests // while providing a base that other test frameworks may build off of. -import either::either; +import either::Either; import result::{ok, err}; import io::WriterUtil; import libc::size_t; @@ -53,8 +53,8 @@ type test_desc = { fn test_main(args: ~[~str], tests: ~[test_desc]) { let opts = match parse_opts(args) { - either::left(o) => o, - either::right(m) => fail m + either::Left(o) => o, + either::Right(m) => fail m }; if !run_tests_console(opts, tests) { fail ~"Some tests failed"; } } @@ -62,7 +62,7 @@ fn test_main(args: ~[~str], tests: ~[test_desc]) { type test_opts = {filter: option<~str>, run_ignored: bool, logfile: option<~str>}; -type opt_res = either<test_opts, ~str>; +type opt_res = Either<test_opts, ~str>; // Parses command line arguments into test options fn parse_opts(args: ~[~str]) -> opt_res { @@ -71,7 +71,7 @@ fn parse_opts(args: ~[~str]) -> opt_res { let matches = match getopts::getopts(args_, opts) { ok(m) => m, - err(f) => return either::right(getopts::fail_str(f)) + err(f) => return either::Right(getopts::fail_str(f)) }; let filter = @@ -85,7 +85,7 @@ fn parse_opts(args: ~[~str]) -> opt_res { let test_opts = {filter: filter, run_ignored: run_ignored, logfile: logfile}; - return either::left(test_opts); + return either::Left(test_opts); } enum test_result { tr_ok, tr_failed, tr_ignored, } @@ -479,7 +479,7 @@ mod tests { fn first_free_arg_should_be_a_filter() { let args = ~[~"progname", ~"filter"]; let opts = match parse_opts(args) { - either::left(o) => o, + either::Left(o) => o, _ => fail ~"Malformed arg in first_free_arg_should_be_a_filter" }; assert ~"filter" == option::get(opts.filter); @@ -489,7 +489,7 @@ mod tests { fn parse_ignored_flag() { let args = ~[~"progname", ~"filter", ~"--ignored"]; let opts = match parse_opts(args) { - either::left(o) => o, + either::Left(o) => o, _ => fail ~"Malformed arg in parse_ignored_flag" }; assert (opts.run_ignored); diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs index 14db589db8e..96b7e46dabf 100644 --- a/src/libstd/uv_global_loop.rs +++ b/src/libstd/uv_global_loop.rs @@ -9,7 +9,7 @@ import iotask::{iotask, spawn_iotask}; import priv::{chan_from_global_ptr, weaken_task}; import comm::{port, chan, select2, listen}; import task::task_builder; -import either::{left, right}; +import either::{Left, Right}; extern mod rustrt { fn rust_uv_get_kernel_global_chan_ptr() -> *libc::uintptr_t; @@ -58,14 +58,14 @@ fn get_monitor_task_gl() -> iotask unsafe { loop { debug!{"in outer_loop..."}; match select2(weak_exit_po, msg_po) { - left(weak_exit) => { + Left(weak_exit) => { // all normal tasks have ended, tell the // libuv loop to tear_down, then exit debug!{"weak_exit_po recv'd msg: %?", weak_exit}; iotask::exit(hl_loop); break; } - right(fetch_ch) => { + Right(fetch_ch) => { debug!{"hl_loop req recv'd: %?", fetch_ch}; fetch_ch.send(hl_loop); } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 241a212c2ac..5b2b4fb0561 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -205,8 +205,8 @@ fn map_item(i: @item, cx: ctx, v: vt) { } item_foreign_mod(nm) => { let abi = match attr::foreign_abi(i.attrs) { - either::left(msg) => cx.diag.span_fatal(i.span, msg), - either::right(abi) => abi + either::Left(msg) => cx.diag.span_fatal(i.span, msg), + either::Right(abi) => abi }; for nm.items.each |nitem| { cx.map.insert(nitem.id, diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 65c2e00faca..7c04d6e4570 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -2,7 +2,7 @@ import std::map; import std::map::hashmap; -import either::either; +import either::Either; import diagnostic::span_handler; import ast_util::{spanned, dummy_spanned}; import parse::comments::{doc_comment_style, strip_doc_comment_decoration}; @@ -330,22 +330,22 @@ fn find_linkage_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] { } } -fn foreign_abi(attrs: ~[ast::attribute]) -> either<~str, ast::foreign_abi> { +fn foreign_abi(attrs: ~[ast::attribute]) -> Either<~str, ast::foreign_abi> { return match attr::first_attr_value_str_by_name(attrs, ~"abi") { option::none => { - either::right(ast::foreign_abi_cdecl) + either::Right(ast::foreign_abi_cdecl) } option::some(@~"rust-intrinsic") => { - either::right(ast::foreign_abi_rust_intrinsic) + either::Right(ast::foreign_abi_rust_intrinsic) } option::some(@~"cdecl") => { - either::right(ast::foreign_abi_cdecl) + either::Right(ast::foreign_abi_cdecl) } option::some(@~"stdcall") => { - either::right(ast::foreign_abi_stdcall) + either::Right(ast::foreign_abi_stdcall) } option::some(t) => { - either::left(~"unsupported abi: " + *t) + either::Left(~"unsupported abi: " + *t) } }; } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 0d8566ae42c..e0e93b1eda5 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -1,4 +1,4 @@ -import dvec::dvec; +import dvec::{DVec, dvec}; export filename; export filemap; @@ -48,7 +48,7 @@ type filemap = @{name: filename, substr: file_substr, src: @~str, start_pos: file_pos, mut lines: ~[file_pos]}; -type codemap = @{files: dvec<filemap>}; +type codemap = @{files: DVec<filemap>}; type loc = {file: filemap, line: uint, col: uint}; diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index 5fba31ed6e7..100f248a7ad 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -1,5 +1,5 @@ import to_str::ToStr; -import dvec::dvec; +import dvec::{DVec, dvec}; import ast::{ident}; @@ -62,7 +62,7 @@ enum state { span: span, dir: direction, ty_params: ~[ast::ty_param], - messages: dvec<message>, + messages: DVec<message>, proto: protocol, }), } @@ -112,7 +112,7 @@ fn protocol(name: ident, +span: span) -> protocol { class protocol_ { let name: ident; let span: span; - let states: dvec<state>; + let states: DVec<state>; let mut bounded: option<bool>; diff --git a/src/libsyntax/ext/qquote.rs b/src/libsyntax/ext/qquote.rs index c5af28bc0b3..6b5dce312d6 100644 --- a/src/libsyntax/ext/qquote.rs +++ b/src/libsyntax/ext/qquote.rs @@ -2,7 +2,7 @@ import ast::{crate, expr_, mac_invoc, mac_aq, mac_var}; import parse::parser; import parse::parser::parse_from_source_str; -import dvec::dvec; +import dvec::{DVec, dvec}; import fold::*; import visit::*; @@ -20,7 +20,7 @@ struct gather_item { constr: ~str; } -type aq_ctxt = @{lo: uint, gather: dvec<gather_item>}; +type aq_ctxt = @{lo: uint, gather: DVec<gather_item>}; enum fragment { from_expr(@ast::expr), from_ty(@ast::ty) diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs index 98289152d33..e8899a2e541 100644 --- a/src/libsyntax/ext/simplext.rs +++ b/src/libsyntax/ext/simplext.rs @@ -1,6 +1,6 @@ import codemap::span; import std::map::{hashmap, str_hash, box_str_hash}; -import dvec::dvec; +import dvec::{DVec, dvec}; import base::*; @@ -124,7 +124,7 @@ fn compose_sels(s1: selector, s2: selector) -> selector { type binders = {real_binders: hashmap<ident, selector>, - literal_ast_matchers: dvec<selector>}; + literal_ast_matchers: DVec<selector>}; type bindings = hashmap<ident, arb_depth<matchable>>; fn acumm_bindings(_cx: ext_ctxt, _b_dest: bindings, _b_src: bindings) { } diff --git a/src/libsyntax/ext/tt/earley_parser.rs b/src/libsyntax/ext/tt/earley_parser.rs index 7cc9b0e1dc2..b6dc1c05a2c 100644 --- a/src/libsyntax/ext/tt/earley_parser.rs +++ b/src/libsyntax/ext/tt/earley_parser.rs @@ -7,7 +7,7 @@ import parse::parser::{parser,SOURCE_FILE}; //import parse::common::parser_common; import parse::common::*; //resolve bug? import parse::parse_sess; -import dvec::dvec; +import dvec::{DVec, dvec}; import ast::{matcher, match_tok, match_seq, match_nonterminal, ident}; import ast_util::mk_sp; import std::map::{hashmap, box_str_hash}; @@ -42,7 +42,7 @@ type matcher_pos = ~{ sep: option<token>, mut idx: uint, mut up: matcher_pos_up, // mutable for swapping only - matches: ~[dvec<@named_match>], + matches: ~[DVec<@named_match>], match_lo: uint, match_hi: uint, sp_lo: uint, }; diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index a93d25ced00..cbb6709d9c8 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -1,4 +1,4 @@ -import either::{either, left, right}; +import either::{Either, Left, Right}; import ast_util::spanned; import common::*; //resolve bug? @@ -7,7 +7,7 @@ export parser_attr; // A type to distingush between the parsing of item attributes or syntax // extensions, which both begin with token.POUND -type attr_or_ext = option<either<~[ast::attribute], @ast::expr>>; +type attr_or_ext = option<Either<~[ast::attribute], @ast::expr>>; trait parser_attr { fn parse_outer_attrs_or_ext(first_item_attrs: ~[ast::attribute]) @@ -36,18 +36,18 @@ impl parser: parser_attr { self.bump(); let first_attr = self.parse_attribute_naked(ast::attr_outer, lo); - return some(left(vec::append(~[first_attr], + return some(Left(vec::append(~[first_attr], self.parse_outer_attributes()))); } else if !(self.look_ahead(1u) == token::LT || self.look_ahead(1u) == token::LBRACKET || self.look_ahead(1u) == token::POUND || expect_item_next) { self.bump(); - return some(right(self.parse_syntax_ext_naked(lo))); + return some(Right(self.parse_syntax_ext_naked(lo))); } else { return none; } } token::DOC_COMMENT(_) => { - return some(left(self.parse_outer_attributes())); + return some(Left(self.parse_outer_attributes())); } _ => return none } diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index 23f5eac07df..99768d558ab 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -340,40 +340,40 @@ fn scan_number(c: char, rdr: string_reader) -> token::token { if c == 'u' || c == 'i' { let signed = c == 'i'; let mut tp = { - if signed { either::left(ast::ty_i) } - else { either::right(ast::ty_u) } + if signed { either::Left(ast::ty_i) } + else { either::Right(ast::ty_u) } }; bump(rdr); c = rdr.curr; if c == '8' { bump(rdr); - tp = if signed { either::left(ast::ty_i8) } - else { either::right(ast::ty_u8) }; + tp = if signed { either::Left(ast::ty_i8) } + else { either::Right(ast::ty_u8) }; } n = nextch(rdr); if c == '1' && n == '6' { bump(rdr); bump(rdr); - tp = if signed { either::left(ast::ty_i16) } - else { either::right(ast::ty_u16) }; + tp = if signed { either::Left(ast::ty_i16) } + else { either::Right(ast::ty_u16) }; } else if c == '3' && n == '2' { bump(rdr); bump(rdr); - tp = if signed { either::left(ast::ty_i32) } - else { either::right(ast::ty_u32) }; + tp = if signed { either::Left(ast::ty_i32) } + else { either::Right(ast::ty_u32) }; } else if c == '6' && n == '4' { bump(rdr); bump(rdr); - tp = if signed { either::left(ast::ty_i64) } - else { either::right(ast::ty_u64) }; + tp = if signed { either::Left(ast::ty_i64) } + else { either::Right(ast::ty_u64) }; } if str::len(num_str) == 0u { rdr.fatal(~"no valid digits found for number"); } let parsed = option::get(u64::from_str_radix(num_str, base as u64)); match tp { - either::left(t) => return token::LIT_INT(parsed as i64, t), - either::right(t) => return token::LIT_UINT(parsed, t) + either::Left(t) => return token::LIT_INT(parsed as i64, t), + either::Right(t) => return token::LIT_UINT(parsed, t) } } let mut is_float = false; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index feb19d6780c..f894f6fae82 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1,7 +1,7 @@ import print::pprust::expr_to_str; import result::result; -import either::{either, left, right}; +import either::{Either, Left, Right}; import std::map::{hashmap, str_hash}; import token::{can_begin_expr, is_ident, is_ident_or_path, is_plain_ident, INTERPOLATED}; @@ -102,7 +102,7 @@ enum class_contents { ctor_decl(fn_decl, ~[attribute], blk, codemap::span), dtor_decl(blk, ~[attribute], codemap::span), members(~[@class_member]) } -type arg_or_capture_item = either<arg, capture_item>; +type arg_or_capture_item = Either<arg, capture_item>; type item_info = (ident, item_, option<~[attribute]>); enum item_or_view_item { @@ -557,9 +557,9 @@ class parser { } if self.eat_keyword(~"move") { - either::right(parse_capture_item(self, true)) + either::Right(parse_capture_item(self, true)) } else if self.eat_keyword(~"copy") { - either::right(parse_capture_item(self, false)) + either::Right(parse_capture_item(self, false)) } else { parse_arg_fn(self) } @@ -570,7 +570,7 @@ class parser { let i = self.parse_value_ident(); self.expect(token::COLON); let t = self.parse_ty(false); - either::left({mode: m, ty: t, ident: i, id: self.get_id()}) + either::Left({mode: m, ty: t, ident: i, id: self.get_id()}) } fn parse_arg_or_capture_item() -> arg_or_capture_item { @@ -588,7 +588,7 @@ class parser { node: ty_infer, span: mk_sp(p.span.lo, p.span.hi)} }; - either::left({mode: m, ty: t, ident: i, id: p.get_id()}) + either::Left({mode: m, ty: t, ident: i, id: p.get_id()}) } } @@ -2051,8 +2051,8 @@ class parser { let mut item_attrs; match self.parse_outer_attrs_or_ext(first_item_attrs) { none => item_attrs = ~[], - some(left(attrs)) => item_attrs = attrs, - some(right(ext)) => { + some(Left(attrs)) => item_attrs = attrs, + some(Right(ext)) => { return @spanned(lo, ext.span.hi, stmt_expr(ext, self.get_id())); } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 0d81d40ca8c..7282eaafb79 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -1,5 +1,5 @@ import io::WriterUtil; -import dvec::dvec; +import dvec::{DVec, dvec}; /* * This pretty-printer is a direct reimplementation of Philip Karlton's @@ -222,7 +222,7 @@ type printer_ = { mut top: uint, // index of top of scan_stack mut bottom: uint, // index of bottom of scan_stack // stack of blocks-in-progress being flushed by print - print_stack: dvec<print_stack_elt>, + print_stack: DVec<print_stack_elt>, // buffered indentation to avoid writing trailing whitespace mut pending_indentation: int, mut token_tree_last_was_ident: bool diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 05b6ca8c504..de1cd2c3df0 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -7,7 +7,7 @@ import pp::{break_offset, word, printer, import diagnostic; import ast::{required, provided}; import ast_util::{operator_prec}; -import dvec::dvec; +import dvec::{DVec, dvec}; import parse::classify::*; import util::interner; @@ -35,7 +35,7 @@ type ps = literals: option<~[comments::lit]>, mut cur_cmnt: uint, mut cur_lit: uint, - boxes: dvec<pp::breaks>, + boxes: DVec<pp::breaks>, ann: pp_ann}; fn ibox(s: ps, u: uint) { diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index e003408f3fd..9b7398d16c7 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -3,11 +3,11 @@ // type, and vice versa. import std::map; import std::map::{hashmap, hashfn, eqfn}; -import dvec::dvec; +import dvec::{DVec, dvec}; type hash_interner<T: const> = {map: hashmap<T, uint>, - vect: dvec<T>, + vect: DVec<T>, hasher: hashfn<T>, eqer: eqfn<T>}; diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs index 2f892c9ba9d..90de6a4335f 100644 --- a/src/rustc/front/test.rs +++ b/src/rustc/front/test.rs @@ -9,7 +9,7 @@ import syntax::codemap::span; import driver::session; import session::session; import syntax::attr; -import dvec::dvec; +import dvec::{DVec, dvec}; export modify_for_testing; @@ -22,7 +22,7 @@ type test_ctxt = @{sess: session::session, crate: @ast::crate, mut path: ~[ast::ident], - testfns: dvec<test>}; + testfns: DVec<test>}; // Traverse the crate, collecting all the test functions, eliding any // existing main functions, and synthesizing a main test harness diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs index 13c85d02b73..744ee50da8b 100644 --- a/src/rustc/metadata/creader.rs +++ b/src/rustc/metadata/creader.rs @@ -9,7 +9,7 @@ import std::map::{hashmap, int_hash}; import syntax::print::pprust; import filesearch::filesearch; import common::*; -import dvec::dvec; +import dvec::{DVec, dvec}; export read_crates; @@ -42,7 +42,7 @@ type cache_entry = { metas: @~[@ast::meta_item] }; -fn dump_crates(crate_cache: dvec<cache_entry>) { +fn dump_crates(crate_cache: DVec<cache_entry>) { debug!{"resolved crates:"}; for crate_cache.each |entry| { debug!{"cnum: %?", entry.cnum}; @@ -67,9 +67,9 @@ fn warn_if_multiple_versions(diag: span_handler, partition(crate_cache.map_to_vec(|entry| { let othername = loader::crate_name_from_metas(*entry.metas); if name == othername { - left(entry) + Left(entry) } else { - right(entry) + Right(entry) } })); @@ -96,7 +96,7 @@ type env = @{diag: span_handler, cstore: cstore::cstore, os: loader::os, static: bool, - crate_cache: dvec<cache_entry>, + crate_cache: DVec<cache_entry>, mut next_crate_num: ast::crate_num}; fn visit_view_item(e: env, i: @ast::view_item) { @@ -114,11 +114,11 @@ fn visit_item(e: env, i: @ast::item) { match i.node { ast::item_foreign_mod(m) => { match attr::foreign_abi(i.attrs) { - either::right(abi) => { + either::Right(abi) => { if abi != ast::foreign_abi_cdecl && abi != ast::foreign_abi_stdcall { return; } } - either::left(msg) => e.diag.span_fatal(i.span, msg) + either::Left(msg) => e.diag.span_fatal(i.span, msg) } let cstore = e.cstore; diff --git a/src/rustc/metadata/csearch.rs b/src/rustc/metadata/csearch.rs index 985cdd9c2d1..69c76e40417 100644 --- a/src/rustc/metadata/csearch.rs +++ b/src/rustc/metadata/csearch.rs @@ -10,7 +10,7 @@ import syntax::diagnostic::span_handler; import syntax::diagnostic::expect; import common::*; import std::map::hashmap; -import dvec::dvec; +import dvec::{DVec, dvec}; export class_dtor; export get_symbol; @@ -144,7 +144,7 @@ fn get_trait_methods(tcx: ty::ctxt, def: ast::def_id) -> @~[ty::method] { } fn get_method_names_if_trait(cstore: cstore::cstore, def: ast::def_id) - -> option<@dvec<(@~str, ast::self_ty_)>> { + -> option<@DVec<(@~str, ast::self_ty_)>> { let cdata = cstore::get_crate_data(cstore, def.crate); return decoder::get_method_names_if_trait(cdata, def.node); diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs index d6d9b2701e4..70754ccdd82 100644 --- a/src/rustc/metadata/decoder.rs +++ b/src/rustc/metadata/decoder.rs @@ -2,8 +2,8 @@ import std::{ebml, map}; import std::map::{hashmap, str_hash}; -import dvec::dvec; import io::WriterUtil; +import dvec::{DVec, dvec}; import syntax::{ast, ast_util}; import syntax::attr; import middle::ty; @@ -684,7 +684,7 @@ fn get_trait_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) // their self types. Otherwise, returns none. This overlaps in an // annoying way with get_trait_methods. fn get_method_names_if_trait(cdata: cmd, node_id: ast::node_id) - -> option<@dvec<(@~str, ast::self_ty_)>> { + -> option<@DVec<(@~str, ast::self_ty_)>> { let item = lookup_item(node_id, cdata.data); if item_family(item) != 'I' { diff --git a/src/rustc/middle/borrowck.rs b/src/rustc/middle/borrowck.rs index 61caf4a2509..83b8666f7c4 100644 --- a/src/rustc/middle/borrowck.rs +++ b/src/rustc/middle/borrowck.rs @@ -229,7 +229,7 @@ import syntax::print::pprust; import util::common::indenter; import ty::to_str; import driver::session::session; -import dvec::dvec; +import dvec::{DVec, dvec}; import mem_categorization::*; export check_crate, root_map, mutbl_map; @@ -339,7 +339,7 @@ type loan = {lp: @loan_path, cmt: cmt, mutbl: ast::mutability}; /// - `pure_map`: map from block/expr that must be pure to the error message /// that should be reported if they are not pure type req_maps = { - req_loan_map: hashmap<ast::node_id, @dvec<@dvec<loan>>>, + req_loan_map: hashmap<ast::node_id, @DVec<@DVec<loan>>>, pure_map: hashmap<ast::node_id, bckerr> }; diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs index bcf36b4cb1a..3541ddad626 100644 --- a/src/rustc/middle/borrowck/gather_loans.rs +++ b/src/rustc/middle/borrowck/gather_loans.rs @@ -393,7 +393,7 @@ impl gather_loan_ctxt { } } - fn add_loans(scope_id: ast::node_id, loans: @dvec<loan>) { + fn add_loans(scope_id: ast::node_id, loans: @DVec<loan>) { match self.req_maps.req_loan_map.find(scope_id) { some(l) => { (*l).push(loans); diff --git a/src/rustc/middle/borrowck/loan.rs b/src/rustc/middle/borrowck/loan.rs index ea917ec60d2..66b786ca791 100644 --- a/src/rustc/middle/borrowck/loan.rs +++ b/src/rustc/middle/borrowck/loan.rs @@ -8,7 +8,7 @@ import result::{result, ok, err}; impl borrowck_ctxt { fn loan(cmt: cmt, scope_region: ty::region, - mutbl: ast::mutability) -> bckres<@dvec<loan>> { + mutbl: ast::mutability) -> bckres<@DVec<loan>> { let lc = loan_ctxt_(@{bccx: self, scope_region: scope_region, loans: @dvec()}); @@ -26,7 +26,7 @@ type loan_ctxt_ = { scope_region: ty::region, // accumulated list of loans that will be required - loans: @dvec<loan> + loans: @DVec<loan> }; enum loan_ctxt { diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs index 545cc049f48..3dc016e021d 100644 --- a/src/rustc/middle/check_const.rs +++ b/src/rustc/middle/check_const.rs @@ -2,7 +2,7 @@ import syntax::ast::*; import syntax::{visit, ast_util, ast_map}; import driver::session::session; import std::map::hashmap; -import dvec::dvec; +import dvec::{DVec, dvec}; fn check_crate(sess: session, crate: @crate, ast_map: ast_map::map, def_map: resolve3::DefMap, @@ -150,7 +150,7 @@ fn check_item_recursion(sess: session, ast_map: ast_map::map, sess: session, ast_map: ast_map::map, def_map: resolve3::DefMap, - idstack: @dvec<node_id>, + idstack: @DVec<node_id>, }; let env = { diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs index ca4a5866a0a..31bb20a47d0 100644 --- a/src/rustc/middle/lint.rs +++ b/src/rustc/middle/lint.rs @@ -415,7 +415,7 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) { match it.node { ast::item_foreign_mod(nmod) if attr::foreign_abi(it.attrs) != - either::right(ast::foreign_abi_rust_intrinsic) => { + either::Right(ast::foreign_abi_rust_intrinsic) => { for nmod.items.each |ni| { match ni.node { ast::foreign_item_fn(decl, tps) => { diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index 61feb22f1b4..f8983f2bebb 100644 --- a/src/rustc/middle/liveness.rs +++ b/src/rustc/middle/liveness.rs @@ -100,7 +100,7 @@ * - `self_var`: a variable representing 'self' */ -import dvec::dvec; +import dvec::{DVec, dvec}; import std::map::{hashmap, int_hash, str_hash, box_str_hash}; import syntax::{visit, ast_util}; import syntax::print::pprust::{expr_to_str}; @@ -122,7 +122,7 @@ export last_use_map; // // Very subtle (#2633): borrowck will remove entries from this table // if it detects an outstanding loan (that is, the addr is taken). -type last_use_map = hashmap<node_id, @dvec<node_id>>; +type last_use_map = hashmap<node_id, @DVec<node_id>>; enum variable = uint; enum live_node = uint; diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs index c4ab394aca0..e226e0ef9c5 100644 --- a/src/rustc/middle/region.rs +++ b/src/rustc/middle/region.rs @@ -14,7 +14,7 @@ import syntax::codemap::span; import syntax::print::pprust; import syntax::ast_util::new_def_hash; import syntax::ast_map; -import dvec::dvec; +import dvec::{DVec, dvec}; import metadata::csearch; import std::list; @@ -343,7 +343,7 @@ fn resolve_crate(sess: session, def_map: resolve3::DefMap, // dependencies until a fixed point is reached. type region_paramd_items = hashmap<ast::node_id, ()>; -type dep_map = hashmap<ast::node_id, @dvec<ast::node_id>>; +type dep_map = hashmap<ast::node_id, @DVec<ast::node_id>>; type determine_rp_ctxt_ = { sess: session, @@ -351,7 +351,7 @@ type determine_rp_ctxt_ = { def_map: resolve3::DefMap, region_paramd_items: region_paramd_items, dep_map: dep_map, - worklist: dvec<ast::node_id>, + worklist: DVec<ast::node_id>, // the innermost enclosing item id mut item_id: ast::node_id, diff --git a/src/rustc/middle/resolve3.rs b/src/rustc/middle/resolve3.rs index 6212b79e1e5..a06e6ea1dba 100644 --- a/src/rustc/middle/resolve3.rs +++ b/src/rustc/middle/resolve3.rs @@ -52,7 +52,7 @@ import syntax::visit::{visit_foreign_item, visit_item, visit_method_helper}; import syntax::visit::{visit_mod, visit_ty, vt}; import box::ptr_eq; -import dvec::dvec; +import dvec::{DVec, dvec}; import option::{get, is_some}; import str::{connect, split_str}; import vec::pop; @@ -89,7 +89,7 @@ type ImplScopes = @list<ImplScope>; type ImplMap = hashmap<node_id,ImplScopes>; // Trait method resolution -type TraitMap = @hashmap<node_id,@dvec<def_id>>; +type TraitMap = @hashmap<node_id,@DVec<def_id>>; // Export mapping type Export = { reexp: bool, id: def_id }; @@ -116,7 +116,7 @@ enum NamespaceResult { enum ImplNamespaceResult { UnknownImplResult, UnboundImplResult, - BoundImplResult(@dvec<@Target>) + BoundImplResult(@DVec<@Target>) } enum NameDefinition { @@ -250,7 +250,7 @@ fn Atom(n: uint) -> Atom { class AtomTable { let atoms: hashmap<@~str,Atom>; - let strings: dvec<@~str>; + let strings: DVec<@~str>; let mut atom_count: uint; new() { @@ -326,11 +326,11 @@ class Rib { /// One import directive. class ImportDirective { - let module_path: @dvec<Atom>; + let module_path: @DVec<Atom>; let subclass: @ImportDirectiveSubclass; let span: span; - new(module_path: @dvec<Atom>, + new(module_path: @DVec<Atom>, subclass: @ImportDirectiveSubclass, span: span) { @@ -363,7 +363,7 @@ class ImportResolution { let mut module_target: option<Target>; let mut value_target: option<Target>; let mut type_target: option<Target>; - let mut impl_target: @dvec<@Target>; + let mut impl_target: @DVec<@Target>; let mut used: bool; @@ -409,7 +409,7 @@ class Module { let mut def_id: option<def_id>; let children: hashmap<Atom,@NameBindings>; - let imports: dvec<@ImportDirective>; + let imports: DVec<@ImportDirective>; // The anonymous children of this node. Anonymous children are pseudo- // modules that are implicitly created around items contained within @@ -677,17 +677,17 @@ class Resolver { // The current set of local scopes, for values. // XXX: Reuse ribs to avoid allocation. - let value_ribs: @dvec<@Rib>; + let value_ribs: @DVec<@Rib>; // The current set of local scopes, for types. - let type_ribs: @dvec<@Rib>; + let type_ribs: @DVec<@Rib>; // Whether the current context is an X-ray context. An X-ray context is // allowed to access private names of any module. let mut xray_context: XrayFlag; // The trait that the current context can refer to. - let mut current_trait_refs: option<@dvec<def_id>>; + let mut current_trait_refs: option<@DVec<def_id>>; // The atom for the keyword "self". let self_atom: Atom; @@ -1571,7 +1571,7 @@ class Resolver { /// Creates and adds an import directive to the given module. fn build_import_directive(module_: @Module, - module_path: @dvec<Atom>, + module_path: @DVec<Atom>, subclass: @ImportDirectiveSubclass, span: span) { @@ -2181,7 +2181,7 @@ class Resolver { } fn resolve_module_path_from_root(module_: @Module, - module_path: @dvec<Atom>, + module_path: @DVec<Atom>, index: uint, xray: XrayFlag, span: span) @@ -2238,7 +2238,7 @@ class Resolver { * the given module. */ fn resolve_module_path_for_import(module_: @Module, - module_path: @dvec<Atom>, + module_path: @DVec<Atom>, xray: XrayFlag, span: span) -> ResolveResult<@Module> { @@ -2932,7 +2932,7 @@ class Resolver { // Wraps the given definition in the appropriate number of `def_upvar` // wrappers. - fn upvarify(ribs: @dvec<@Rib>, rib_index: uint, def_like: def_like, + fn upvarify(ribs: @DVec<@Rib>, rib_index: uint, def_like: def_like, span: span, allow_capturing_self: AllowCapturingSelfFlag) -> option<def_like> { @@ -3031,7 +3031,7 @@ class Resolver { return some(dl_def(def)); } - fn search_ribs(ribs: @dvec<@Rib>, name: Atom, span: span, + fn search_ribs(ribs: @DVec<@Rib>, name: Atom, span: span, allow_capturing_self: AllowCapturingSelfFlag) -> option<def_like> { @@ -4150,7 +4150,7 @@ class Resolver { } } - fn intern_module_part_of_path(path: @path) -> @dvec<Atom> { + fn intern_module_part_of_path(path: @path) -> @DVec<Atom> { let module_path_atoms = @dvec(); for path.idents.eachi |index, ident| { if index == path.idents.len() - 1u { @@ -4508,7 +4508,7 @@ class Resolver { } } - fn search_for_traits_containing_method(name: Atom) -> @dvec<def_id> { + fn search_for_traits_containing_method(name: Atom) -> @DVec<def_id> { let found_traits = @dvec(); let mut search_module = self.current_module; loop { @@ -4577,7 +4577,7 @@ class Resolver { return found_traits; } - fn add_trait_info_if_containing_method(found_traits: @dvec<def_id>, + fn add_trait_info_if_containing_method(found_traits: @DVec<def_id>, trait_def_id: def_id, name: Atom) { diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs index eaf1011f181..e12070e265d 100644 --- a/src/rustc/middle/trans/alt.rs +++ b/src/rustc/middle/trans/alt.rs @@ -13,7 +13,7 @@ import syntax::print::pprust::pat_to_str; import middle::resolve3::DefMap; import back::abi; import std::map::hashmap; -import dvec::dvec; +import dvec::{DVec, dvec}; import common::*; @@ -277,7 +277,7 @@ fn enter_uniq(bcx: block, dm: DefMap, m: match_, col: uint, val: ValueRef) } fn get_options(ccx: @crate_ctxt, m: match_, col: uint) -> ~[opt] { - fn add_to_set(tcx: ty::ctxt, &&set: dvec<opt>, val: opt) { + fn add_to_set(tcx: ty::ctxt, &&set: DVec<opt>, val: opt) { if set.any(|l| opt_eq(tcx, l, val)) {return;} set.push(val); } diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index 7b901ae9739..23f5c69caa1 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -5015,8 +5015,8 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) { ast::item_const(_, expr) => consts::trans_const(ccx, expr, item.id), ast::item_foreign_mod(foreign_mod) => { let abi = match attr::foreign_abi(item.attrs) { - either::right(abi_) => abi_, - either::left(msg) => ccx.sess.span_fatal(item.span, msg) + either::Right(abi_) => abi_, + either::Left(msg) => ccx.sess.span_fatal(item.span, msg) }; foreign::trans_foreign_mod(ccx, foreign_mod, abi); } diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs index 6df5a00f21d..fdde26d6718 100644 --- a/src/rustc/middle/trans/foreign.rs +++ b/src/rustc/middle/trans/foreign.rs @@ -1168,8 +1168,8 @@ fn abi_of_foreign_fn(ccx: @crate_ctxt, i: @ast::foreign_item) ast_map::node_foreign_item(_, abi, _) => abi }, some(_) => match attr::foreign_abi(i.attrs) { - either::right(abi) => abi, - either::left(msg) => ccx.sess.span_fatal(i.span, msg) + either::Right(abi) => abi, + either::Left(msg) => ccx.sess.span_fatal(i.span, msg) } } } diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs index 68bddb8d151..78eb527b785 100644 --- a/src/rustc/middle/trans/shape.rs +++ b/src/rustc/middle/trans/shape.rs @@ -15,7 +15,7 @@ import syntax::ast_util::{dummy_sp, new_def_hash}; import syntax::util::interner; import util::ppaux::ty_to_str; import syntax::codemap::span; -import dvec::dvec; +import dvec::{DVec, dvec}; import std::map::hashmap; import option::is_some; @@ -65,7 +65,7 @@ type ctxt = {mut next_tag_id: u16, pad: u16, tag_id_to_index: hashmap<nominal_id, u16>, - tag_order: dvec<enum_data>, + tag_order: DVec<enum_data>, resources: interner::interner<nominal_id>, llshapetablesty: TypeRef, llshapetables: ValueRef}; diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index 5cb886a36f0..3bc4e578c74 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -501,7 +501,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) { } ast::item_foreign_mod(m) => { if syntax::attr::foreign_abi(it.attrs) == - either::right(ast::foreign_abi_rust_intrinsic) { + either::Right(ast::foreign_abi_rust_intrinsic) { for m.items.each |item| { check_intrinsic_type(ccx, item); } diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs index c5d3dd765ab..9de5aa98e5f 100644 --- a/src/rustc/middle/typeck/check/method.rs +++ b/src/rustc/middle/typeck/check/method.rs @@ -9,7 +9,7 @@ import syntax::ast::{sty_value}; import syntax::ast_map; import syntax::ast_map::node_id_to_str; import syntax::ast_util::{dummy_sp, new_def_hash}; -import dvec::dvec; +import dvec::{DVec, dvec}; type candidate = { self_ty: ty::t, // type of a in a.b() @@ -57,7 +57,7 @@ class lookup { let m_name: ast::ident; let mut self_ty: ty::t; let mut derefs: uint; - let candidates: dvec<candidate>; + let candidates: DVec<candidate>; let candidate_impls: hashmap<def_id, ()>; let supplied_tps: ~[ty::t]; let include_private: bool; @@ -435,7 +435,7 @@ class lookup { } fn add_inherent_and_extension_candidates(optional_inherent_methods: - option<@dvec<@Impl>>, + option<@DVec<@Impl>>, use_assignability: bool) { // Add inherent methods. diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs index e54238e6c69..bc6342dbce1 100644 --- a/src/rustc/middle/typeck/coherence.rs +++ b/src/rustc/middle/typeck/coherence.rs @@ -30,7 +30,7 @@ import syntax::visit::{mk_simple_visitor, mk_vt, visit_crate, visit_item}; import syntax::visit::{visit_mod}; import util::ppaux::ty_to_str; -import dvec::dvec; +import dvec::{DVec, dvec}; import result::ok; import std::map::{hashmap, int_hash}; import uint::range; @@ -121,11 +121,11 @@ fn method_to_MethodInfo(ast_method: @method) -> @MethodInfo { class CoherenceInfo { // Contains implementations of methods that are inherent to a type. // Methods in these implementations don't need to be exported. - let inherent_methods: hashmap<def_id,@dvec<@Impl>>; + let inherent_methods: hashmap<def_id,@DVec<@Impl>>; // Contains implementations of methods associated with a trait. For these, // the associated trait must be imported at the call site. - let extension_methods: hashmap<def_id,@dvec<@Impl>>; + let extension_methods: hashmap<def_id,@DVec<@Impl>>; new() { self.inherent_methods = new_def_hash(); @@ -356,7 +356,7 @@ class CoherenceChecker { } fn check_implementation_coherence(_trait_def_id: def_id, - implementations: @dvec<@Impl>) { + implementations: @DVec<@Impl>) { // Unify pairs of polytypes. for range(0, implementations.len()) |i| { @@ -540,7 +540,7 @@ class CoherenceChecker { return trait_id; } - fn gather_privileged_types(items: ~[@item]) -> @dvec<def_id> { + fn gather_privileged_types(items: ~[@item]) -> @DVec<def_id> { let results = @dvec(); for items.each |item| { match item.node { diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs index cc0ed23ac72..36461b44b75 100644 --- a/src/rustc/middle/typeck/infer.rs +++ b/src/rustc/middle/typeck/infer.rs @@ -262,7 +262,7 @@ import driver::session::session; import util::common::{indent, indenter}; import ast::{unsafe_fn, impure_fn, pure_fn, extern_fn}; import ast::{m_const, m_imm, m_mutbl}; -import dvec::dvec; +import dvec::{DVec, dvec}; export infer_ctxt; export new_infer_ctxt; @@ -402,7 +402,7 @@ enum infer_ctxt = @{ ty_var_integral_counter: @mut uint, region_var_counter: @mut uint, - borrowings: dvec<{expr_id: ast::node_id, + borrowings: DVec<{expr_id: ast::node_id, span: span, scope: ty::region, mutbl: ast::mutability}> diff --git a/src/test/auxiliary/cci_nested_lib.rs b/src/test/auxiliary/cci_nested_lib.rs index 38bc20f637b..b96745890f9 100644 --- a/src/test/auxiliary/cci_nested_lib.rs +++ b/src/test/auxiliary/cci_nested_lib.rs @@ -1,7 +1,7 @@ -import dvec::dvec; +import dvec::{DVec, dvec}; type entry<A,B> = {key: A, value: B}; -type alist<A,B> = { eq_fn: fn@(A,A) -> bool, data: dvec<entry<A,B>> }; +type alist<A,B> = { eq_fn: fn@(A,A) -> bool, data: DVec<entry<A,B>> }; fn alist_add<A: copy, B: copy>(lst: alist<A,B>, k: A, v: B) { lst.data.push({key:k, value:v}); diff --git a/src/test/auxiliary/issue-2631-a.rs b/src/test/auxiliary/issue-2631-a.rs index dd8ace9ee74..9d69cf15562 100644 --- a/src/test/auxiliary/issue-2631-a.rs +++ b/src/test/auxiliary/issue-2631-a.rs @@ -4,10 +4,10 @@ use std; import dvec::*; -import dvec::dvec; +import dvec::DVec; import std::map::hashmap; -type header_map = hashmap<~str, @dvec<@~str>>; +type header_map = hashmap<~str, @DVec<@~str>>; // the unused ty param is necessary so this gets monomorphized fn request<T: copy>(req: header_map) { diff --git a/src/test/compile-fail/issue-2590.rs b/src/test/compile-fail/issue-2590.rs index c0a378491f9..ffbc7a3018b 100644 --- a/src/test/compile-fail/issue-2590.rs +++ b/src/test/compile-fail/issue-2590.rs @@ -1,7 +1,7 @@ -import dvec::dvec; +import dvec::DVec; type parser = { - tokens: dvec<int>, + tokens: DVec<int>, }; trait parse { diff --git a/src/test/compile-fail/regions-glb-free-free.rs b/src/test/compile-fail/regions-glb-free-free.rs index 94cf76330a9..08c4286a011 100644 --- a/src/test/compile-fail/regions-glb-free-free.rs +++ b/src/test/compile-fail/regions-glb-free-free.rs @@ -2,7 +2,7 @@ mod argparse { use std; import std::map; - import either::{either, left, right}; + import either::{Either, Left, Right}; struct Flag { name: &str; diff --git a/src/test/run-pass/pipe-select.rs b/src/test/run-pass/pipe-select.rs index 6c315123f53..209dc515bd0 100644 --- a/src/test/run-pass/pipe-select.rs +++ b/src/test/run-pass/pipe-select.rs @@ -79,8 +79,8 @@ fn test_select2() { stream::client::send(ac, 42); match pipes::select2(ap, bp) { - either::left(*) => { } - either::right(*) => { fail } + either::Left(*) => { } + either::Right(*) => { fail } } stream::client::send(bc, ~"abc"); @@ -93,8 +93,8 @@ fn test_select2() { stream::client::send(bc, ~"abc"); match pipes::select2(ap, bp) { - either::left(*) => { fail } - either::right(*) => { } + either::Left(*) => { fail } + either::Right(*) => { } } stream::client::send(ac, 42); diff --git a/src/test/run-pass/static-method-test.rs b/src/test/run-pass/static-method-test.rs index 99c5776a5ac..c221b091acb 100644 --- a/src/test/run-pass/static-method-test.rs +++ b/src/test/run-pass/static-method-test.rs @@ -49,7 +49,7 @@ pure fn build<A, B: buildable<A>>(builder: fn(push: pure fn(+A))) -> B { } /// Apply a function to each element of an iterable and return the results -fn map<T, IT: base_iter<T>, U, BU: buildable<U>> +fn map<T, IT: BaseIter<T>, U, BU: buildable<U>> (v: IT, f: fn(T) -> U) -> BU { do build |push| { for v.each() |elem| { |