auto merge of #14709 : alexcrichton/rust/collections, r=brson

This is mostly just a cosmetic change, continuing the work from #14333.

diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs
index 79e0c2ffea877772a93700e26780ee0a0adc2f39..42c8177977057323d89d71363dab68d1defd5390 100644 (file)
--- a/src/libcollections/bitv.rs
+++ b/src/libcollections/bitv.rs
@@ -20,6 +20,7 @@
 use core::uint;
 use std::hash;
 
+use {Collection, Mutable, Set, MutableSet};
 use vec::Vec;
 
 #[deriving(Clone)]
@@ -857,7 +858,7 @@ fn hash(&self, state: &mut S) {
     }
 }
 
-impl Container for BitvSet {
+impl Collection for BitvSet {
     #[inline]
     fn len(&self) -> uint { self.size }
 }
@@ -1008,6 +1009,7 @@ mod tests {
     use std::rand::Rng;
     use test::Bencher;
 
+    use {Set, Mutable, MutableSet};
     use bitv::{Bitv, SmallBitv, BigBitv, BitvSet, from_bools, from_fn,
                from_bytes};
     use bitv;

diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs
index ebca0157da40be19d728e74ce87f758485ae8480..82abe69a63996fb3aad41a1f4deb81a8a6070a97 100644 (file)
--- a/src/libcollections/btree.rs
+++ b/src/libcollections/btree.rs
@@ -24,6 +24,7 @@
 use core::fmt;
 use core::fmt::Show;
 
+use Collection;
 use vec::Vec;
 
 #[allow(missing_doc)]

diff --git a/src/libcollections/deque.rs b/src/libcollections/deque.rs
index 5624c67f1084089da0583545b17c269e5f5acd1d..1faa9be99e3a54e919643e4be4f4409d223c5f5b 100644 (file)
--- a/src/libcollections/deque.rs
+++ b/src/libcollections/deque.rs
@@ -10,41 +10,13 @@
 
 //! Container traits for collections
 
-use core::prelude::*;
-
-/// A double-ended sequence that allows querying, insertion and deletion at both ends.
-pub trait Deque<T> : Mutable {
-    /// Provide a reference to the front element, or None if the sequence is empty
-    fn front<'a>(&'a self) -> Option<&'a T>;
-
-    /// Provide a mutable reference to the front element, or None if the sequence is empty
-    fn front_mut<'a>(&'a mut self) -> Option<&'a mut T>;
-
-    /// Provide a reference to the back element, or None if the sequence is empty
-    fn back<'a>(&'a self) -> Option<&'a T>;
-
-    /// Provide a mutable reference to the back element, or None if the sequence is empty
-    fn back_mut<'a>(&'a mut self) -> Option<&'a mut T>;
-
-    /// Insert an element first in the sequence
-    fn push_front(&mut self, elt: T);
-
-    /// Insert an element last in the sequence
-    fn push_back(&mut self, elt: T);
-
-    /// Remove the last element and return it, or None if the sequence is empty
-    fn pop_back(&mut self) -> Option<T>;
-
-    /// Remove the first element and return it, or None if the sequence is empty
-    fn pop_front(&mut self) -> Option<T>;
-}
-
 #[cfg(test)]
 pub mod bench {
     use std::prelude::*;
     use std::rand;
     use std::rand::Rng;
     use test::Bencher;
+    use MutableMap;
 
     pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
                                                   map: &mut M,
@@ -121,3 +93,4 @@ pub fn find_seq_n<M:MutableMap<uint,uint>>(n: uint,
         })
      }
 }
+

diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 9d0e8e83698d8bac04832f23bcb5a63a7580d447..5a2312456913824a385371596b0b46597620418f 100644 (file)
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -13,7 +13,7 @@
 //! The DList allows pushing and popping elements at either end.
 //!
 //! DList implements the trait Deque. It should be imported with `use
-//! collections::deque::Deque`.
+//! collections::Deque`.
 
 // DList is constructed like a singly-linked list over the field `next`.
 // including the last link being None; each Node owns its `next` field.
@@ -29,7 +29,7 @@
 use core::mem;
 use core::ptr;
 
-use deque::Deque;
+use {Collection, Mutable, Deque};
 
 /// A doubly-linked list.
 pub struct DList<T> {
@@ -125,7 +125,7 @@ fn link_with_prev<T>(mut next: Box<Node<T>>, prev: Rawlink<Node<T>>)
     Some(next)
 }
 
-impl<T> Container for DList<T> {
+impl<T> Collection for DList<T> {
     /// O(1)
     #[inline]
     fn is_empty(&self) -> bool {
@@ -629,7 +629,7 @@ mod tests {
     use test::Bencher;
     use test;
 
-    use deque::Deque;
+    use Deque;
     use super::{DList, Node, ListInsertion};
     use vec::Vec;
 

diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index c46ea84a765cea9adace56d880d220a5f8c6fdb7..602ecf39a836c837374bbe167826a9b4895e0b09 100644 (file)
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -32,9 +32,11 @@
 #[cfg(test)] #[phase(syntax, link)] extern crate std;
 #[cfg(test)] #[phase(syntax, link)] extern crate log;
 
+use core::prelude::*;
+
+pub use core::collections::Collection;
 pub use bitv::{Bitv, BitvSet};
 pub use btree::BTree;
-pub use deque::Deque;
 pub use dlist::DList;
 pub use enum_set::EnumSet;
 pub use priority_queue::PriorityQueue;
@@ -47,7 +49,6 @@
 
 pub mod bitv;
 pub mod btree;
-pub mod deque;
 pub mod dlist;
 pub mod enum_set;
 pub mod priority_queue;
@@ -64,12 +65,120 @@
 // Internal unicode fiddly bits for the str module
 mod unicode;
 
-// FIXME(#14008) should this actually exist, or should a method be added?
-fn expect<T>(a: core::option::Option<T>, b: &str) -> T {
-    match a {
-        core::option::Some(a) => a,
-        core::option::None => fail!("{}", b),
+mod deque;
+
+/// A trait to represent mutable containers
+pub trait Mutable: Collection {
+    /// Clear the container, removing all values.
+    fn clear(&mut self);
+}
+
+/// A map is a key-value store where values may be looked up by their keys. This
+/// trait provides basic operations to operate on these stores.
+pub trait Map<K, V>: Collection {
+    /// Return a reference to the value corresponding to the key
+    fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
+
+    /// Return true if the map contains a value for the specified key
+    #[inline]
+    fn contains_key(&self, key: &K) -> bool {
+        self.find(key).is_some()
+    }
+}
+
+/// This trait provides basic operations to modify the contents of a map.
+pub trait MutableMap<K, V>: Map<K, V> + Mutable {
+    /// Insert a key-value pair into the map. An existing value for a
+    /// key is replaced by the new value. Return true if the key did
+    /// not already exist in the map.
+    #[inline]
+    fn insert(&mut self, key: K, value: V) -> bool {
+        self.swap(key, value).is_none()
+    }
+
+    /// Remove a key-value pair from the map. Return true if the key
+    /// was present in the map, otherwise false.
+    #[inline]
+    fn remove(&mut self, key: &K) -> bool {
+        self.pop(key).is_some()
+    }
+
+    /// Insert a key-value pair from the map. If the key already had a value
+    /// present in the map, that value is returned. Otherwise None is returned.
+    fn swap(&mut self, k: K, v: V) -> Option<V>;
+
+    /// Removes a key from the map, returning the value at the key if the key
+    /// was previously in the map.
+    fn pop(&mut self, k: &K) -> Option<V>;
+
+    /// Return a mutable reference to the value corresponding to the key
+    fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V>;
+}
+
+/// A set is a group of objects which are each distinct from one another. This
+/// trait represents actions which can be performed on sets to iterate over
+/// them.
+pub trait Set<T>: Collection {
+    /// Return true if the set contains a value
+    fn contains(&self, value: &T) -> bool;
+
+    /// Return true if the set has no elements in common with `other`.
+    /// This is equivalent to checking for an empty intersection.
+    fn is_disjoint(&self, other: &Self) -> bool;
+
+    /// Return true if the set is a subset of another
+    fn is_subset(&self, other: &Self) -> bool;
+
+    /// Return true if the set is a superset of another
+    fn is_superset(&self, other: &Self) -> bool {
+        other.is_subset(self)
     }
+
+    // FIXME #8154: Add difference, sym. difference, intersection and union iterators
+}
+
+/// This trait represents actions which can be performed on sets to mutate
+/// them.
+pub trait MutableSet<T>: Set<T> + Mutable {
+    /// Add a value to the set. Return true if the value was not already
+    /// present in the set.
+    fn insert(&mut self, value: T) -> bool;
+
+    /// Remove a value from the set. Return true if the value was
+    /// present in the set.
+    fn remove(&mut self, value: &T) -> bool;
+}
+
+/// A double-ended sequence that allows querying, insertion and deletion at both
+/// ends.
+pub trait Deque<T> : Mutable {
+    /// Provide a reference to the front element, or None if the sequence is
+    /// empty
+    fn front<'a>(&'a self) -> Option<&'a T>;
+
+    /// Provide a mutable reference to the front element, or None if the
+    /// sequence is empty
+    fn front_mut<'a>(&'a mut self) -> Option<&'a mut T>;
+
+    /// Provide a reference to the back element, or None if the sequence is
+    /// empty
+    fn back<'a>(&'a self) -> Option<&'a T>;
+
+    /// Provide a mutable reference to the back element, or None if the sequence
+    /// is empty
+    fn back_mut<'a>(&'a mut self) -> Option<&'a mut T>;
+
+    /// Insert an element first in the sequence
+    fn push_front(&mut self, elt: T);
+
+    /// Insert an element last in the sequence
+    fn push_back(&mut self, elt: T);
+
+    /// Remove the last element and return it, or None if the sequence is empty
+    fn pop_back(&mut self) -> Option<T>;
+
+    /// Remove the first element and return it, or None if the sequence is empty
+    fn pop_front(&mut self) -> Option<T>;
 }
 
 // FIXME(#14344) this shouldn't be necessary

diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs
index 34d6bbbb66567d93ba9f69258ac3d4196b4aa5e5..ea3e7d1747170d0d6a1ba197fc7d61de7069af3f 100644 (file)
--- a/src/libcollections/priority_queue.rs
+++ b/src/libcollections/priority_queue.rs
@@ -17,6 +17,7 @@
 use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
+use {Collection, Mutable};
 use slice;
 use vec::Vec;
 
@@ -26,7 +27,7 @@ pub struct PriorityQueue<T> {
     data: Vec<T>,
 }
 
-impl<T: Ord> Container for PriorityQueue<T> {
+impl<T: Ord> Collection for PriorityQueue<T> {
     /// Returns the length of the queue
     fn len(&self) -> uint { self.data.len() }
 }

diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
index ce4195789fab6a24060acb2aef6cae6910c45da1..addf73d67a88e7f8e0e2cb804c5f8652710f21f6 100644 (file)
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -11,7 +11,7 @@
 //! A double-ended queue implemented as a circular buffer
 //!
 //! RingBuf implements the trait Deque. It should be imported with `use
-//! collections::deque::Deque`.
+//! collections::Deque`.
 
 use core::prelude::*;
 
@@ -19,7 +19,7 @@
 use core::fmt;
 use core::iter::RandomAccessIterator;
 
-use deque::Deque;
+use {Deque, Collection, Mutable};
 use vec::Vec;
 
 static INITIAL_CAPACITY: uint = 8u; // 2^3
@@ -33,7 +33,7 @@ pub struct RingBuf<T> {
     elts: Vec<Option<T>>
 }
 
-impl<T> Container for RingBuf<T> {
+impl<T> Collection for RingBuf<T> {
     /// Return the number of elements in the RingBuf
     fn len(&self) -> uint { self.nelts }
 }
@@ -415,7 +415,7 @@ mod tests {
     use test::Bencher;
     use test;
 
-    use deque::Deque;
+    use {Deque, Mutable};
     use super::RingBuf;
     use vec::Vec;
 

diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 4798218e3ff25dbc9653882f2d64c51c38799b18..1bc563686933e5efa23a23d4407ad8b8c878f55c 100644 (file)
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -109,6 +109,8 @@
 use core::mem;
 use core::ptr;
 use core::iter::{range_step, MultiplicativeIterator};
+
+use Collection;
 use vec::Vec;
 
 pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
@@ -296,9 +298,9 @@ fn to_owned(&self) -> ~[T] {
 
         let len = self.len();
         let data_size = len.checked_mul(&mem::size_of::<T>());
-        let data_size = ::expect(data_size, "overflow in to_owned()");
+        let data_size = data_size.expect("overflow in to_owned()");
         let size = mem::size_of::<RawVec<()>>().checked_add(&data_size);
-        let size = ::expect(size, "overflow in to_owned()");
+        let size = size.expect("overflow in to_owned()");
 
         unsafe {
             // this should pass the real required alignment
@@ -865,6 +867,7 @@ mod tests {
     use std::rt;
     use slice::*;
 
+    use Mutable;
     use vec::Vec;
 
     fn square(n: uint) -> uint { n * n }

diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs
index 45584dd4b28ba4eccda480616bd855e23cbc1bcb..cc901864ab532b3eab8bbb9ba95a1ac5527b59e0 100644 (file)
--- a/src/libcollections/smallintmap.rs
+++ b/src/libcollections/smallintmap.rs
@@ -21,6 +21,7 @@
 use core::iter::{Enumerate, FilterMap};
 use core::mem::replace;
 
+use {Collection, Mutable, Map, MutableMap};
 use {vec, slice};
 use vec::Vec;
 
@@ -29,7 +30,7 @@ pub struct SmallIntMap<T> {
     v: Vec<Option<T>>,
 }
 
-impl<V> Container for SmallIntMap<V> {
+impl<V> Collection for SmallIntMap<V> {
     /// Return the number of elements in the map
     fn len(&self) -> uint {
         self.v.iter().filter(|elt| elt.is_some()).count()
@@ -123,7 +124,7 @@ pub fn with_capacity(capacity: uint) -> SmallIntMap<V> {
     }
 
     pub fn get<'a>(&'a self, key: &uint) -> &'a V {
-        ::expect(self.find(key), "key not present")
+        self.find(key).expect("key not present")
     }
 
     /// An iterator visiting all key-value pairs in ascending order by the keys.
@@ -264,6 +265,7 @@ pub struct MutEntries<'a, T> {
 mod test_map {
     use std::prelude::*;
 
+    use {Map, MutableMap, Mutable};
     use super::SmallIntMap;
 
     #[test]

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 5fd133b450f7610717d4b7eee023daae0808bb52..49d8775dd9cb649a97570ac2416828c7779b7e7d 100644 (file)
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -76,6 +76,7 @@ fn main() {
 use core::iter::AdditiveIterator;
 use core::mem;
 
+use Collection;
 use hash;
 use string::String;
 use vec::Vec;
@@ -610,7 +611,7 @@ fn into_string(self) -> String {
     }
 }
 
-impl<'a> Container for MaybeOwned<'a> {
+impl<'a> Collection for MaybeOwned<'a> {
     #[inline]
     fn len(&self) -> uint { self.as_slice().len() }
 }
@@ -2036,7 +2037,7 @@ fn t<S: Default + Str>() {
 
     #[test]
     fn test_str_container() {
-        fn sum_len<S: Container>(v: &[S]) -> uint {
+        fn sum_len<S: Collection>(v: &[S]) -> uint {
             v.iter().map(|x| x.len()).sum()
         }
 

diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index bd39c74aa840b97c4cb74907c8be13e404c06cf5..76f53c9b257493216ef5ee9e715ac845fd0560de 100644 (file)
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -18,6 +18,7 @@
 use core::ptr;
 use core::raw::Slice;
 
+use {Collection, Mutable};
 use hash;
 use str;
 use str::{CharRange, StrAllocating};
@@ -279,7 +280,7 @@ pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
     }
 }
 
-impl Container for String {
+impl Collection for String {
     #[inline]
     fn len(&self) -> uint {
         self.vec.len()
@@ -356,6 +357,7 @@ mod tests {
     use std::prelude::*;
     use test::Bencher;
 
+    use Mutable;
     use str::{Str, StrSlice};
     use super::String;
 

diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
index def1c353bc1324e3ea41100f96e9f96b0e7f7b0b..489fe60cebf0ec021c8bb744a57dc7ee1be9aa98 100644 (file)
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -22,6 +22,7 @@
 use core::mem::{replace, swap};
 use core::ptr;
 
+use {Collection, Mutable, Set, MutableSet, MutableMap, Map};
 use vec::Vec;
 
 // This is implemented as an AA tree, which is a simplified variation of
@@ -86,7 +87,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
-impl<K: Ord, V> Container for TreeMap<K, V> {
+impl<K: Ord, V> Collection for TreeMap<K, V> {
     fn len(&self) -> uint { self.length }
 }
 
@@ -579,7 +580,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
-impl<T: Ord> Container for TreeSet<T> {
+impl<T: Ord> Collection for TreeSet<T> {
     #[inline]
     fn len(&self) -> uint { self.map.len() }
 }
@@ -1006,6 +1007,7 @@ mod test_treemap {
     use std::rand::Rng;
     use std::rand;
 
+    use {Map, MutableMap, Mutable};
     use super::{TreeMap, TreeNode};
 
     #[test]
@@ -1437,7 +1439,6 @@ fn test_from_iter() {
 
 #[cfg(test)]
 mod bench {
-    use std::prelude::*;
     use test::Bencher;
 
     use super::TreeMap;
@@ -1500,6 +1501,7 @@ pub fn find_seq_10_000(b: &mut Bencher) {
 mod test_set {
     use std::prelude::*;
 
+    use {Set, MutableSet, Mutable, MutableMap};
     use super::{TreeMap, TreeSet};
 
     #[test]

diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs
index c15a6e9e5bf48fae118e367c551d05a9e44796ea..6e99d6054a56453b099a1211c8b89c55040be939 100644 (file)
--- a/src/libcollections/trie.rs
+++ b/src/libcollections/trie.rs
@@ -17,6 +17,7 @@
 use core::mem;
 use core::uint;
 
+use {Collection, Mutable, Map, MutableMap, Set, MutableSet};
 use slice::{Items, MutItems};
 use slice;
 
@@ -38,7 +39,7 @@ pub struct TrieMap<T> {
     length: uint
 }
 
-impl<T> Container for TrieMap<T> {
+impl<T> Collection for TrieMap<T> {
     /// Return the number of elements in the map
     #[inline]
     fn len(&self) -> uint { self.length }
@@ -285,7 +286,7 @@ pub struct TrieSet {
     map: TrieMap<()>
 }
 
-impl Container for TrieSet {
+impl Collection for TrieSet {
     /// Return the number of elements in the set
     #[inline]
     fn len(&self) -> uint { self.map.len() }
@@ -645,6 +646,7 @@ mod test_map {
     use std::iter::range_step;
     use std::uint;
 
+    use {MutableMap, Map};
     use super::{TrieMap, TrieNode, Internal, External, Nothing};
 
     fn check_integrity<T>(trie: &TrieNode<T>) {
@@ -923,6 +925,7 @@ mod bench_map {
     use std::rand::{weak_rng, Rng};
     use test::Bencher;
 
+    use MutableMap;
     use super::TrieMap;
 
     #[bench]
@@ -1031,6 +1034,7 @@ mod test_set {
     use std::prelude::*;
     use std::uint;
 
+    use {MutableSet, Set};
     use super::TrieSet;
 
     #[test]

diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 37546f64d5f7b9690033cba19054f146bd18b322..dbef73efc479462b1539acf7ed8d47eb305648c8 100644 (file)
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -24,6 +24,7 @@
 use core::ptr;
 use core::uint;
 
+use {Collection, Mutable};
 use slice::{MutableOrdVector, OwnedVector, MutableVectorAllocating};
 use slice::{Items, MutItems};
 
@@ -91,8 +92,8 @@ pub fn with_capacity(capacity: uint) -> Vec<T> {
         } else if capacity == 0 {
             Vec::new()
         } else {
-            let size = ::expect(capacity.checked_mul(&mem::size_of::<T>()),
-                                "capacity overflow");
+            let size = capacity.checked_mul(&mem::size_of::<T>())
+                               .expect("capacity overflow");
             let ptr = unsafe { allocate(size, mem::min_align_of::<T>()) };
             Vec { len: 0, cap: capacity, ptr: ptr as *mut T }
         }
@@ -393,7 +394,7 @@ fn cmp(&self, other: &Vec<T>) -> Ordering {
     }
 }
 
-impl<T> Container for Vec<T> {
+impl<T> Collection for Vec<T> {
     #[inline]
     fn len(&self) -> uint {
         self.len
@@ -499,8 +500,8 @@ pub fn reserve_exact(&mut self, capacity: uint) {
         if mem::size_of::<T>() == 0 { return }
 
         if capacity > self.cap {
-            let size = ::expect(capacity.checked_mul(&mem::size_of::<T>()),
-                                "capacity overflow");
+            let size = capacity.checked_mul(&mem::size_of::<T>())
+                               .expect("capacity overflow");
             unsafe {
                 self.ptr = alloc_or_realloc(self.ptr, size,
                                             self.cap * mem::size_of::<T>());
@@ -579,7 +580,7 @@ pub fn pop(&mut self) -> Option<T> {
     pub fn push(&mut self, value: T) {
         if mem::size_of::<T>() == 0 {
             // zero-size types consume no memory, so we can't rely on the address space running out
-            self.len = ::expect(self.len.checked_add(&1), "length overflow");
+            self.len = self.len.checked_add(&1).expect("length overflow");
             unsafe { mem::forget(value); }
             return
         }
@@ -1526,9 +1527,9 @@ impl<T> FromVec<T> for ~[T] {
     fn from_vec(mut v: Vec<T>) -> ~[T] {
         let len = v.len();
         let data_size = len.checked_mul(&mem::size_of::<T>());
-        let data_size = ::expect(data_size, "overflow in from_vec()");
+        let data_size = data_size.expect("overflow in from_vec()");
         let size = mem::size_of::<RawVec<()>>().checked_add(&data_size);
-        let size = ::expect(size, "overflow in from_vec()");
+        let size = size.expect("overflow in from_vec()");
 
         // In a post-DST world, we can attempt to reuse the Vec allocation by calling
         // shrink_to_fit() on it. That may involve a reallocation+memcpy, but that's no

diff --git a/src/libcore/collections.rs b/src/libcore/collections.rs
new file mode 100644 (file)
index 0000000..0bb9289
--- /dev/null
+++ b/src/libcore/collections.rs
@@ -0,0 +1,24 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Traits for generic collections
+
+/// A trait to represent the abstract idea of a container. The only concrete
+/// knowledge known is the number of elements contained within.
+pub trait Collection {
+    /// Return the number of elements in the container
+    fn len(&self) -> uint;
+
+    /// Return true if the container contains no elements
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}

diff --git a/src/libcore/container.rs b/src/libcore/container.rs
deleted file mode 100644 (file)
index e8ee379..0000000
--- a/src/libcore/container.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Traits for generic containers (including `Map` and `Set`)
-
-use option::Option;
-
-/// A trait to represent the abstract idea of a container. The only concrete
-/// knowledge known is the number of elements contained within.
-pub trait Container {
-    /// Return the number of elements in the container
-    fn len(&self) -> uint;
-
-    /// Return true if the container contains no elements
-    #[inline]
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-}
-
-/// A trait to represent mutable containers
-pub trait Mutable: Container {
-    /// Clear the container, removing all values.
-    fn clear(&mut self);
-}
-
-/// A map is a key-value store where values may be looked up by their keys. This
-/// trait provides basic operations to operate on these stores.
-pub trait Map<K, V>: Container {
-    /// Return a reference to the value corresponding to the key
-    fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
-
-    /// Return true if the map contains a value for the specified key
-    #[inline]
-    fn contains_key(&self, key: &K) -> bool {
-        self.find(key).is_some()
-    }
-}
-
-/// This trait provides basic operations to modify the contents of a map.
-pub trait MutableMap<K, V>: Map<K, V> + Mutable {
-    /// Insert a key-value pair into the map. An existing value for a
-    /// key is replaced by the new value. Return true if the key did
-    /// not already exist in the map.
-    #[inline]
-    fn insert(&mut self, key: K, value: V) -> bool {
-        self.swap(key, value).is_none()
-    }
-
-    /// Remove a key-value pair from the map. Return true if the key
-    /// was present in the map, otherwise false.
-    #[inline]
-    fn remove(&mut self, key: &K) -> bool {
-        self.pop(key).is_some()
-    }
-
-    /// Insert a key-value pair from the map. If the key already had a value
-    /// present in the map, that value is returned. Otherwise None is returned.
-    fn swap(&mut self, k: K, v: V) -> Option<V>;
-
-    /// Removes a key from the map, returning the value at the key if the key
-    /// was previously in the map.
-    fn pop(&mut self, k: &K) -> Option<V>;
-
-    /// Return a mutable reference to the value corresponding to the key
-    fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V>;
-}
-
-/// A set is a group of objects which are each distinct from one another. This
-/// trait represents actions which can be performed on sets to iterate over
-/// them.
-pub trait Set<T>: Container {
-    /// Return true if the set contains a value
-    fn contains(&self, value: &T) -> bool;
-
-    /// Return true if the set has no elements in common with `other`.
-    /// This is equivalent to checking for an empty intersection.
-    fn is_disjoint(&self, other: &Self) -> bool;
-
-    /// Return true if the set is a subset of another
-    fn is_subset(&self, other: &Self) -> bool;
-
-    /// Return true if the set is a superset of another
-    fn is_superset(&self, other: &Self) -> bool {
-        other.is_subset(self)
-    }
-
-    // FIXME #8154: Add difference, sym. difference, intersection and union iterators
-}
-
-/// This trait represents actions which can be performed on sets to mutate
-/// them.
-pub trait MutableSet<T>: Set<T> + Mutable {
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
-    fn insert(&mut self, value: T) -> bool;
-
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
-    fn remove(&mut self, value: &T) -> bool;
-}

diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index e5fb148aded341b64fa5db72d5faa8ecfa1dd69e..f326195be1607f270e6283c4a0830b6c9816b563 100644 (file)
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -11,7 +11,7 @@
 #![allow(missing_doc)]
 
 use char;
-use container::Container;
+use collections::Collection;
 use fmt;
 use iter::{Iterator, range, DoubleEndedIterator};
 use num::{Float, FPNaN, FPInfinite, ToPrimitive, Primitive};

diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 2cce68d5f60f2c33198b153fbbfeff78f425eeef..37ef325d937e23d789d968c34fc2f06fdf7872fb 100644 (file)
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -15,7 +15,7 @@
 use any;
 use cell::Cell;
 use char::Char;
-use container::Container;
+use collections::Collection;
 use iter::{Iterator, range};
 use kinds::Copy;
 use mem;

diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 890733dc229afccb033c5759aaed1e8fc290a518..f36acf344e4cfe71adb2bc5c7c59f0a5563345f2 100644 (file)
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -14,7 +14,7 @@
 
 #![allow(unsigned_negate)]
 
-use container::Container;
+use collections::Collection;
 use fmt;
 use iter::{Iterator, DoubleEndedIterator};
 use num::{Int, cast, zero};

diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 2ccf431fc22e138fe1161601eeb8e6cbc7187bdd..5661c6683739b58ffb7b80c7d0a8218265dc7a1e 100644 (file)
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -108,7 +108,7 @@
 #[cfg(not(test))] pub mod cmp;
 pub mod clone;
 pub mod default;
-pub mod container;
+pub mod collections;
 
 /* Core types and methods on primitives */
 

diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index a6a8319ca02a5b2c965b2d480df7f7bb048516bd..df9c0e67b0d6d3ab1176df298b39aacffd3db9d4 100644 (file)
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -47,7 +47,7 @@
 pub use clone::Clone;
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
-pub use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
+pub use collections::Collection;
 pub use iter::{FromIterator, Extendable};
 pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator};
 pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};

diff --git a/src/libcore/should_not_exist.rs b/src/libcore/should_not_exist.rs
index 2c6f2978aa735727b4beb6a4d271ba4a3ce832b2..ed6b73df38d4d42ebb25feaac70186b6a316d2ca 100644 (file)
--- a/src/libcore/should_not_exist.rs
+++ b/src/libcore/should_not_exist.rs
@@ -25,7 +25,7 @@
 // Currently, no progress has been made on this list.
 
 use clone::Clone;
-use container::Container;
+use collections::Collection;
 use finally::try_finally;
 use intrinsics;
 use iter::{range, Iterator};

diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 4dea1fd75a4bf16b5923bfa6295c3ea57da661ee..585373ec70ca560cea9de2e4b4d2b953a8ca29b4 100644 (file)
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -16,7 +16,7 @@
 
 use mem::transmute;
 use clone::Clone;
-use container::Container;
+use collections::Collection;
 use cmp::{PartialEq, Ord, Ordering, Less, Equal, Greater};
 use cmp;
 use default::Default;
@@ -253,7 +253,7 @@ pub mod traits {
 
     use cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering, Equiv};
     use iter::order;
-    use container::Container;
+    use collections::Collection;
 
     impl<'a,T:PartialEq> PartialEq for &'a [T] {
         fn eq(&self, other: & &'a [T]) -> bool {
@@ -347,7 +347,7 @@ impl<T> Vector<T> for ~[T] {
     fn as_slice<'a>(&'a self) -> &'a [T] { let v: &'a [T] = *self; v }
 }
 
-impl<'a, T> Container for &'a [T] {
+impl<'a, T> Collection for &'a [T] {
     /// Returns the length of a vector
     #[inline]
     fn len(&self) -> uint {
@@ -355,7 +355,7 @@ fn len(&self) -> uint {
     }
 }
 
-impl<T> Container for ~[T] {
+impl<T> Collection for ~[T] {
     /// Returns the length of a vector
     #[inline]
     fn len(&self) -> uint {
@@ -1205,7 +1205,7 @@ pub unsafe fn pop_ptr<T>(slice: &mut Slice<T>) -> Option<*T> {
 
 /// Operations on `[u8]`.
 pub mod bytes {
-    use container::Container;
+    use collections::Collection;
     use ptr;
     use slice::MutableVector;
 

diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 87177b4ac90dc50430b94cbc20d8d38897e3df1f..c01997f1c42c75e48491d658d00baab15ea84c80 100644 (file)
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -19,7 +19,7 @@
 use clone::Clone;
 use cmp;
 use cmp::{PartialEq, Eq};
-use container::Container;
+use collections::Collection;
 use default::Default;
 use iter::{Filter, Map, Iterator};
 use iter::{DoubleEndedIterator, ExactSize};
@@ -866,7 +866,7 @@ macro_rules! utf8_acc_cont_byte(
 /// Unsafe operations
 pub mod raw {
     use mem;
-    use container::Container;
+    use collections::Collection;
     use ptr::RawPtr;
     use raw::Slice;
     use slice::{ImmutableVector};
@@ -930,8 +930,8 @@ pub unsafe fn slice_unchecked<'a>(s: &'a str, begin: uint, end: uint) -> &'a str
 #[cfg(not(test))]
 #[allow(missing_doc)]
 pub mod traits {
-    use container::Container;
     use cmp::{Ord, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, Eq};
+    use collections::Collection;
     use iter::Iterator;
     use option::{Some, None};
     use str::{Str, StrSlice, eq_slice};
@@ -987,7 +987,7 @@ impl<'a> Str for &'a str {
     fn as_slice<'a>(&'a self) -> &'a str { *self }
 }
 
-impl<'a> Container for &'a str {
+impl<'a> Collection for &'a str {
     #[inline]
     fn len(&self) -> uint {
         self.repr().len

diff --git a/src/libregex/re.rs b/src/libregex/re.rs
index fbe0359ff6fa2001f7fedc0efd1ff582372cce4e..a499c1e125dede9e2ec300e2caa962a87b2a3189 100644 (file)
--- a/src/libregex/re.rs
+++ b/src/libregex/re.rs
@@ -775,7 +775,7 @@ pub fn expand(&self, text: &str) -> String {
     }
 }
 
-impl<'t> Container for Captures<'t> {
+impl<'t> Collection for Captures<'t> {
     /// Returns the number of captured groups.
     #[inline]
     fn len(&self) -> uint {

diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 5f51f80299f4be21e070459de497ffc6269b5da0..9fe403159f2b7ec3ac23bb86e262b68d194b0102 100644 (file)
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -45,7 +45,6 @@
 
 #![allow(unsigned_negate)]
 
-use std::container::Map;
 use libc::c_ulonglong;
 use std::num::{Bitwise};
 use std::rc::Rc;

diff --git a/src/librustrt/c_str.rs b/src/librustrt/c_str.rs
index 4234c085148cb575acbe2856a8ba099b220c44e2..b4d9ac7efbebcce50deb04af89445f41f9756a37 100644 (file)
--- a/src/librustrt/c_str.rs
+++ b/src/librustrt/c_str.rs
@@ -229,7 +229,7 @@ fn drop(&mut self) {
     }
 }
 
-impl Container for CString {
+impl Collection for CString {
     /// Return the number of bytes in the CString (not including the NUL terminator).
     ///
     /// # Failure

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index e9bb23a75c88f4bd7169ebb46c48cf8414acfbf9..b9edc9a811e43486af96ba81ebc99df56c73a4de 100644 (file)
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -10,7 +10,7 @@
 
 //! Operations on ASCII strings and characters
 
-use container::Container;
+use collections::Collection;
 use fmt;
 use iter::Iterator;
 use mem;

diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 817b54fb692f20b8e5838d53671de59ae7c2b38d..e8a158ad230aa40fac8601942b609f1480fde8ee 100644 (file)
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -33,7 +33,7 @@
 //! handled correctly, i.e. that allocated memory is eventually freed
 //! if necessary.
 
-use container::Container;
+use collections::Collection;
 use kinds::Send;
 use mem;
 use ops::Drop;
@@ -149,7 +149,7 @@ pub unsafe fn unwrap(mut self) -> *mut T {
     }
 }
 
-impl<T> Container for CVec<T> {
+impl<T> Collection for CVec<T> {
     fn len(&self) -> uint { self.len }
 }
 

diff --git a/src/libstd/collections/hashmap.rs b/src/libstd/collections/hashmap.rs
index 571c579470441e92ee8a0ebb0e783be2467aa5ad..a780b63bfd0269c767732ea51d6690d04caa789d 100644 (file)
--- a/src/libstd/collections/hashmap.rs
+++ b/src/libstd/collections/hashmap.rs
@@ -12,7 +12,7 @@
 
 use clone::Clone;
 use cmp::{max, Eq, Equiv, PartialEq};
-use container::{Container, Mutable, Set, MutableSet, Map, MutableMap};
+use collections::{Collection, Mutable, Set, MutableSet, Map, MutableMap};
 use default::Default;
 use fmt::Show;
 use fmt;
@@ -930,7 +930,7 @@ pub fn pop_equiv<Q:Hash<S> + Equiv<K>>(&mut self, k: &Q) -> Option<V> {
     }
 }
 
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Container for HashMap<K, V, H> {
+impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Collection for HashMap<K, V, H> {
     /// Return the number of elements in the map
     fn len(&self) -> uint { self.table.size() }
 }
@@ -1504,7 +1504,7 @@ fn eq(&self, other: &HashSet<T, H>) -> bool {
 
 impl<T: Eq + Hash<S>, S, H: Hasher<S>> Eq for HashSet<T, H> {}
 
-impl<T: Eq + Hash<S>, S, H: Hasher<S>> Container for HashSet<T, H> {
+impl<T: Eq + Hash<S>, S, H: Hasher<S>> Collection for HashSet<T, H> {
     fn len(&self) -> uint { self.map.len() }
 }
 
@@ -2159,8 +2159,8 @@ mod test_set {
     use prelude::*;
 
     use super::HashSet;
-    use container::Container;
     use slice::ImmutableEqVector;
+    use collections::Collection;
 
     #[test]
     fn test_disjoint() {

diff --git a/src/libstd/collections/lru_cache.rs b/src/libstd/collections/lru_cache.rs
index a12b00f34dc4a01fd48fd8d852d4bcf37ab2acce..72d96804d6d7e4dd99a571ff7248c2ca37bb8017 100644 (file)
--- a/src/libstd/collections/lru_cache.rs
+++ b/src/libstd/collections/lru_cache.rs
@@ -38,8 +38,7 @@
 //! ```
 
 use cmp::{PartialEq, Eq};
-use collections::HashMap;
-use container::{Container, Mutable, MutableMap};
+use collections::{HashMap, Collection, Mutable, MutableMap};
 use fmt;
 use hash::Hash;
 use iter::{range, Iterator};
@@ -227,7 +226,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
-impl<K: Hash + Eq, V> Container for LruCache<K, V> {
+impl<K: Hash + Eq, V> Collection for LruCache<K, V> {
     /// Return the number of key-value pairs in the cache.
     fn len(&self) -> uint {
         self.map.len()

diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index 16a6a35d9d5f751970397317196a692ea911e03b..9e5288f9541b8c1869ac400f8936e36998dbe2b2 100644 (file)
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -12,10 +12,12 @@
  * Collection types.
  */
 
-pub use core_collections::{Bitv, BitvSet, BTree, Deque, DList, EnumSet};
+pub use core_collections::{Collection, Mutable, Map, MutableMap};
+pub use core_collections::{Set, MutableSet, Deque};
+pub use core_collections::{Bitv, BitvSet, BTree, DList, EnumSet};
 pub use core_collections::{PriorityQueue, RingBuf, SmallIntMap};
 pub use core_collections::{TreeMap, TreeSet, TrieMap, TrieSet};
-pub use core_collections::{bitv, btree, deque, dlist, enum_set};
+pub use core_collections::{bitv, btree, dlist, enum_set};
 pub use core_collections::{priority_queue, ringbuf, smallintmap, treemap, trie};
 
 pub use self::hashmap::{HashMap, HashSet};

diff --git a/src/libstd/comm/sync.rs b/src/libstd/comm/sync.rs
index 7fe505573b799bb12257a682a043fe6fde04df5d..84ef6d0aa8fcf51ecadb6afdeedd6691a43ed80c 100644 (file)
--- a/src/libstd/comm/sync.rs
+++ b/src/libstd/comm/sync.rs
@@ -33,7 +33,7 @@
 /// of a synchronous channel. There are a few branches for the unbuffered case,
 /// but they're mostly just relevant to blocking senders.
 
-use container::Container;
+use collections::Collection;
 use iter::Iterator;
 use kinds::Send;
 use mem;

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 0d4217601624f760a7a562d5f39e7c258eb4f7a1..9450f7798edcf97c3db3c59cde615ffea6eec4b0 100644 (file)
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -11,7 +11,7 @@
 //! Buffering wrappers for I/O traits
 
 use cmp;
-use container::Container;
+use collections::Collection;
 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
 use iter::ExactSize;
 use ops::Drop;

diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index 84b7242970aade29221014c7b18c6f51a6b7f32a..529536b0a0da78317bae8db7fedef77408c70f4f 100644 (file)
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -10,7 +10,7 @@
 
 use clone::Clone;
 use cmp;
-use container::Container;
+use collections::Collection;
 use comm::{Sender, Receiver};
 use io;
 use option::{None, Option, Some};

diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 29afd2b1d9b2b95c5d97ca2ee9379bfdb9a972d9..d61518d4ee76f9aa36db766b634eebdf4c3a8402 100644 (file)
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -15,7 +15,7 @@
 // FIXME: Not sure how this should be structured
 // FIXME: Iteration should probably be considered separately
 
-use container::Container;
+use collections::Collection;
 use iter::Iterator;
 use option::{Option, Some, None};
 use result::{Ok, Err};
@@ -504,7 +504,7 @@ fn test_u64_from_be_bytes() {
 mod bench {
     extern crate test;
 
-    use container::Container;
+    use collections::Collection;
     use prelude::*;
     use self::test::Bencher;
 

diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 49e8d37923661bf2c614768af0ebbb8d139e4a81..5259200133ae1974e1af84e02146849f8a2110ed 100644 (file)
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -51,7 +51,7 @@
 
 use c_str::ToCStr;
 use clone::Clone;
-use container::Container;
+use collections::Collection;
 use io;
 use iter::Iterator;
 use kinds::Send;

diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 735966d812b92f8c0ec59d18eeda2b312ba03e89..f0fbe4529b0e959c3b6aeb88155400332cf2fdd8 100644 (file)
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -11,7 +11,7 @@
 //! Readers and Writers for in-memory buffers
 
 use cmp::min;
-use container::Container;
+use collections::Collection;
 use option::None;
 use result::{Err, Ok};
 use io;

diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 7b655693395005ccbdb515a1f5a3155ff5a203db..6f3eec01e8e34678b8ed133e57422e44021680ba 100644 (file)
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -214,7 +214,7 @@ fn file_product(p: &Path) -> IoResult<u32> {
 #![deny(unused_must_use)]
 
 use char::Char;
-use container::Container;
+use collections::Collection;
 use fmt;
 use int;
 use iter::Iterator;

diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index bdc4b6071fab420e17893ea9333e754e9f193ba7..2c54bd895e952f59a635bf2041f0cd8d7cb324de 100644 (file)
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -15,7 +15,7 @@
 
 #![allow(missing_doc)]
 
-use container::Container;
+use collections::Collection;
 use fmt;
 use from_str::FromStr;
 use iter::Iterator;

diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index bac4d26b4e49a6e8ce114fd5ce816efd671c449b..fbdbc13e1b430ed1ea95462c2e802e970c6a3a90 100644 (file)
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -144,7 +144,6 @@
 pub use core::char;
 pub use core::clone;
 #[cfg(not(test))] pub use core::cmp;
-pub use core::container;
 pub use core::default;
 pub use core::finally;
 pub use core::intrinsics;

diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index 48962ca59d890235b768d8df95fea332b3b64660..5028987f44fdd239e85d9421e6867e5482d68fb1 100644 (file)
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -12,7 +12,7 @@
 
 use char;
 use clone::Clone;
-use container::Container;
+use collections::Collection;
 use num::{NumCast, Zero, One, cast, Int};
 use num::{Float, FPNaN, FPInfinite, ToPrimitive};
 use num;

diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index dd692d3fc016bdcf7544477c140e3630cb6ed0ce..90df18106f0a5b758f8a0ecf18e321ed830b346f 100644 (file)
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -30,7 +30,7 @@
 #![allow(non_snake_case_functions)]
 
 use clone::Clone;
-use container::Container;
+use collections::Collection;
 use fmt;
 use iter::Iterator;
 use libc::{c_void, c_int};

diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 681b19a2d1ab5eb3c3a06eb4bfefdcab89e198da..a101f0432126e2ff4de213bd9303071fc42f9514 100644 (file)
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -65,7 +65,7 @@
 
 #![deny(deprecated_owned_vector)]
 
-use container::Container;
+use collections::Collection;
 use c_str::CString;
 use clone::Clone;
 use fmt;

diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 8dfb64194e7977d1b0809d5fcbe9cf96583e1e99..171535edbeb346b2ac4ce429a9e4f3609db81eba 100644 (file)
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -13,7 +13,7 @@
 use c_str::{CString, ToCStr};
 use clone::Clone;
 use cmp::{PartialEq, Eq};
-use container::Container;
+use collections::Collection;
 use from_str::FromStr;
 use hash;
 use io::Writer;

diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 9bb137edb82811a912391f590e1abad2f5e91562..011dfa6eeacc1e5f629164ff2b1d69b3b89fa86e 100644 (file)
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -14,7 +14,7 @@
 use c_str::{CString, ToCStr};
 use clone::Clone;
 use cmp::{PartialEq, Eq};
-use container::Container;
+use collections::Collection;
 use from_str::FromStr;
 use hash;
 use io::Writer;

diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 54dcbd1812fccaad8feb7eb32ec90580e9d9a34f..485c2140a8d1b035f8b2271a8dba3f4394ff6517 100644 (file)
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -60,8 +60,8 @@
 #[doc(no_inline)] pub use clone::Clone;
 #[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 #[doc(no_inline)] pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
-#[doc(no_inline)] pub use container::{Container, Mutable, Map, MutableMap};
-#[doc(no_inline)] pub use container::{Set, MutableSet};
+#[doc(no_inline)] pub use collections::{Collection, Mutable, Map, MutableMap};
+#[doc(no_inline)] pub use collections::{Set, MutableSet};
 #[doc(no_inline)] pub use iter::{FromIterator, Extendable, ExactSize};
 #[doc(no_inline)] pub use iter::{Iterator, DoubleEndedIterator};
 #[doc(no_inline)] pub use iter::{RandomAccessIterator, CloneableIterator};

diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index 284d41d3208a382ed72974cda74b4adef7538744..2654b7a1acc6af5145592e931b67a66e1ccb071d 100644 (file)
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -62,7 +62,7 @@ fn fill_bytes(&mut self, v: &mut [u8]) {
 mod imp {
     extern crate libc;
 
-    use container::Container;
+    use core_collections::Collection;
     use io::{IoResult, IoError};
     use mem;
     use ops::Drop;

diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index 170884073f3c3310df9bb277752fe82c0f4a0f76..8655d1e47d51a01772f112c8fde0102bc45c2a82 100644 (file)
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -10,7 +10,7 @@
 
 //! A wrapper around any Reader to treat it as an RNG.
 
-use container::Container;
+use collections::Collection;
 use io::Reader;
 use rand::Rng;
 use result::{Ok, Err};

diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 766901fa04f32f663e559c16cda477b6ee2f9606..83fc95267afdf3333d82335e367bf18e793514c5 100644 (file)
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -13,7 +13,7 @@
 #![allow(non_camel_case_types)]
 
 use char::Char;
-use container::Container;
+use collections::Collection;
 use from_str::from_str;
 use io::{IoResult, Writer};
 use iter::Iterator;
@@ -348,7 +348,7 @@ fn dladdr(addr: *libc::c_void,
 
     #[cfg(not(target_os = "macos"))]
     fn print(w: &mut Writer, idx: int, addr: *libc::c_void) -> IoResult<()> {
-        use container::Container;
+        use collections::Collection;
         use iter::Iterator;
         use os;
         use path::GenericPath;
@@ -602,7 +602,7 @@ pub unsafe fn _Unwind_FindEnclosingFunction(pc: *libc::c_void)
 #[allow(dead_code, uppercase_variables)]
 mod imp {
     use c_str::CString;
-    use container::Container;
+    use core_collections::Collection;
     use intrinsics;
     use io::{IoResult, Writer};
     use libc;

diff --git a/src/libsyntax/owned_slice.rs b/src/libsyntax/owned_slice.rs
index 28d63ea071a757c02721a9c57e9883de4b9d6ec9..016dd879dcd838c3ee2f915a29fe269b6117daf6 100644 (file)
--- a/src/libsyntax/owned_slice.rs
+++ b/src/libsyntax/owned_slice.rs
@@ -121,7 +121,7 @@ fn eq(&self, other: &OwnedSlice<T>) -> bool {
 
 impl<T: Eq> Eq for OwnedSlice<T> {}
 
-impl<T> Container for OwnedSlice<T> {
+impl<T> Collection for OwnedSlice<T> {
     fn len(&self) -> uint { self.len }
 }
 

diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
index 693407b854fb923e9a3038333071d435cbaabd4c..a3b2c23dfdf2d9b7219fdb187171a7023c187735 100644 (file)
--- a/src/libsyntax/util/small_vector.rs
+++ b/src/libsyntax/util/small_vector.rs
@@ -23,7 +23,7 @@ enum SmallVectorRepr<T> {
     Many(Vec<T> ),
 }
 
-impl<T> Container for SmallVector<T> {
+impl<T> Collection for SmallVector<T> {
     fn len(&self) -> uint {
         match self.repr {
             Zero => 0,

diff --git a/src/test/compile-fail/map-types.rs b/src/test/compile-fail/map-types.rs
index 0c9a7cc8bde4fbf691c00f97b24a4a3b5325b40e..bb5f020e78c9d9ac1d1bd78f805e15278575f580 100644 (file)
--- a/src/test/compile-fail/map-types.rs
+++ b/src/test/compile-fail/map-types.rs
@@ -18,6 +18,6 @@ fn main() {
     let x: Box<HashMap<int, int>> = box HashMap::new();
     let x: Box<Map<int, int>> = x;
     let y: Box<Map<uint, int>> = box x;
-    //~^ ERROR failed to find an implementation of trait core::container::Map<uint,int>
-    //         for ~core::container::Map<int,int>:Send
+    //~^ ERROR failed to find an implementation of trait collections::Map<uint,int>
+    //         for ~collections::Map<int,int>:Send
 }

diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs
index 865984844c0b54314766c68be80ade3cd3a59017..924625faa1010a87338d6f025674716ae56bcee9 100644 (file)
--- a/src/test/run-pass/class-impl-very-parameterized-trait.rs
+++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs
@@ -48,7 +48,7 @@ pub fn eat(&mut self) -> bool {
     }
 }
 
-impl<T> Container for cat<T> {
+impl<T> Collection for cat<T> {
     fn len(&self) -> uint { self.meows as uint }
     fn is_empty(&self) -> bool { self.meows == 0 }
 }

diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs
index 750235ce6afedaa33caf6755081e157e76330071..8b041ed3a3e768bba07762abe4d789cec5838de3 100644 (file)
--- a/src/test/run-pass/send_str_hashmap.rs
+++ b/src/test/run-pass/send_str_hashmap.rs
@@ -10,7 +10,7 @@
 
 extern crate collections;
 
-use std::container::{Map, MutableMap};
+use std::collections::{Map, MutableMap};
 use std::str::{SendStr, Owned, Slice};
 use std::collections::HashMap;
 use std::option::Some;

diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs
index 5604093ea9c8add7e0e0c4930b17a76c36bb2b49..68eca8f21a7f5d37c9b4a94e55a96034593bd648 100644 (file)
--- a/src/test/run-pass/send_str_treemap.rs
+++ b/src/test/run-pass/send_str_treemap.rs
@@ -10,7 +10,7 @@
 
 extern crate collections;
 
-use std::container::{ Map, MutableMap};
+use std::collections::{ Map, MutableMap};
 use std::str::{SendStr, Owned, Slice};
 use std::to_str::ToStr;
 use self::collections::TreeMap;