From d36a8f3f9c70c63ed9042d83cdc47392d12b3886 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 11 Jul 2014 10:12:38 -0700 Subject: [PATCH 01/11] collections: Move push/pop to MutableSeq Implement for Vec, DList, RingBuf. Add MutableSeq to the prelude. Since the collections traits are in the prelude most consumers of these methods will continue to work without change. [breaking-change] --- src/liballoc/arc.rs | 1 + src/libcollections/bitv.rs | 2 +- src/libcollections/btree.rs | 2 +- src/libcollections/dlist.rs | 9 +- src/libcollections/hash/sip.rs | 2 + src/libcollections/lib.rs | 11 ++- src/libcollections/macros.rs | 18 ++++ src/libcollections/priority_queue.rs | 3 +- src/libcollections/ringbuf.rs | 7 +- src/libcollections/slice.rs | 5 +- src/libcollections/str.rs | 2 +- src/libcollections/string.rs | 2 +- src/libcollections/treemap.rs | 4 +- src/libcollections/vec.rs | 129 ++++++++++++++------------- src/librustrt/at_exit_imp.rs | 1 + src/librustrt/local_data.rs | 1 + src/libstd/collections/mod.rs | 2 +- src/libstd/dynamic_lib.rs | 1 + src/libstd/io/extensions.rs | 2 +- src/libstd/io/fs.rs | 2 +- src/libstd/io/signal.rs | 1 + src/libstd/lib.rs | 2 + src/libstd/macros.rs | 3 + src/libstd/num/strconv.rs | 2 +- src/libstd/os.rs | 2 +- src/libstd/path/mod.rs | 2 +- src/libstd/path/posix.rs | 2 +- src/libstd/path/windows.rs | 2 +- src/libstd/prelude.rs | 2 +- src/libsync/deque.rs | 2 +- src/libsync/raw.rs | 2 +- 31 files changed, 142 insertions(+), 86 deletions(-) diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 9b4f879e61ea4..27174de8e7416 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -268,6 +268,7 @@ impl Drop for Weak { #[allow(experimental)] mod tests { use std::clone::Clone; + use std::collections::MutableSeq; use std::comm::channel; use std::mem::drop; use std::ops::Drop; diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index f1e9eabe8d1ed..e7190a810e47f 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -72,7 +72,7 @@ use core::slice; use core::uint; use std::hash; -use {Collection, Mutable, Set, MutableSet}; +use {Collection, Mutable, Set, MutableSet, MutableSeq}; use vec::Vec; diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs index e4605527ce550..096b0c7f5172c 100644 --- a/src/libcollections/btree.rs +++ b/src/libcollections/btree.rs @@ -24,7 +24,7 @@ use alloc::boxed::Box; use core::fmt; use core::fmt::Show; -use Collection; +use {Collection, MutableSeq}; use vec::Vec; #[allow(missing_doc)] diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 48ea1bd1c0150..24df95e77c480 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -30,7 +30,7 @@ use core::iter; use core::mem; use core::ptr; -use {Collection, Mutable, Deque}; +use {Collection, Mutable, Deque, MutableSeq}; /// A doubly-linked list. pub struct DList { @@ -265,6 +265,11 @@ impl Deque for DList { } } +impl MutableSeq for DList { + fn push(&mut self, elt: T) { self.push_back(elt) } + fn pop(&mut self) -> Option { self.pop_back() } +} + impl Default for DList { #[inline] fn default() -> DList { DList::new() } @@ -719,7 +724,7 @@ mod tests { use test::Bencher; use test; - use Deque; + use {Deque, MutableSeq}; use super::{DList, Node, ListInsertion}; use vec::Vec; diff --git a/src/libcollections/hash/sip.rs b/src/libcollections/hash/sip.rs index 7168af89b59ea..485dc8c5959b7 100644 --- a/src/libcollections/hash/sip.rs +++ b/src/libcollections/hash/sip.rs @@ -281,6 +281,8 @@ mod tests { use super::super::{Hash, Writer}; use super::{SipState, hash, hash_with_keys}; + use MutableSeq; + // Hash just the bytes of the slice, without length prefix struct Bytes<'a>(&'a [u8]); diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index fba89df1bbc6b..2b1d8b140ae58 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -325,6 +325,11 @@ pub trait MutableSet: Set + Mutable { fn remove(&mut self, value: &T) -> bool; } +pub trait MutableSeq: Mutable { + fn push(&mut self, t: T); + fn pop(&mut self) -> Option; +} + /// A double-ended sequence that allows querying, insertion and deletion at both /// ends. /// @@ -384,7 +389,7 @@ pub trait MutableSet: Set + Mutable { /// println!("{}", (f, b)); /// } /// ``` -pub trait Deque : Mutable { +pub trait Deque : MutableSeq { /// Provide a reference to the front element, or `None` if the sequence is /// empty. /// @@ -535,4 +540,8 @@ mod std { pub use core::clone; // deriving(Clone) pub use core::cmp; // deriving(Eq, Ord, etc.) pub use hash; // deriving(Hash) + + pub mod collections { + pub use MutableSeq; + } } diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs index db062a70bbb67..0e4b46cfc56fb 100644 --- a/src/libcollections/macros.rs +++ b/src/libcollections/macros.rs @@ -11,8 +11,26 @@ #![macro_escape] /// Create a `std::vec::Vec` containing the arguments. +#[cfg(not(test))] macro_rules! vec( ($($e:expr),*) => ({ + #[allow(unused_imports)] + use std::collections::MutableSeq; + + // leading _ to allow empty construction without a warning. + let mut _temp = ::vec::Vec::new(); + $(_temp.push($e);)* + _temp + }); + ($($e:expr),+,) => (vec!($($e),+)) +) + +#[cfg(test)] +macro_rules! vec( + ($($e:expr),*) => ({ + #[allow(unused_imports)] + use MutableSeq; + // leading _ to allow empty construction without a warning. let mut _temp = ::vec::Vec::new(); $(_temp.push($e);)* diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs index 9451f2521c89a..6e1a3ec1cb6c8 100644 --- a/src/libcollections/priority_queue.rs +++ b/src/libcollections/priority_queue.rs @@ -154,7 +154,7 @@ use core::default::Default; use core::mem::{zeroed, replace, swap}; use core::ptr; -use {Collection, Mutable}; +use {Collection, Mutable, MutableSeq}; use slice; use vec::Vec; @@ -388,6 +388,7 @@ mod tests { use priority_queue::PriorityQueue; use vec::Vec; + use MutableSeq; #[test] fn test_iterator() { diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index 5e19accdd6715..05dda93039861 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -20,7 +20,7 @@ use core::default::Default; use core::fmt; use core::iter::RandomAccessIterator; -use {Deque, Collection, Mutable}; +use {Deque, Collection, Mutable, MutableSeq}; use vec::Vec; static INITIAL_CAPACITY: uint = 8u; // 2^3 @@ -114,6 +114,11 @@ impl Deque for RingBuf { } } +impl MutableSeq for RingBuf { + fn push(&mut self, t: T) { self.push_back(t) } + fn pop(&mut self) -> Option { self.pop_back() } +} + impl Default for RingBuf { #[inline] fn default() -> RingBuf { RingBuf::new() } diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 6c3c8437e255a..64062dc0ccbf8 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -107,7 +107,7 @@ use core::mem; use core::ptr; use core::iter::{range_step, MultiplicativeIterator}; -use Collection; +use {Collection, MutableSeq}; use vec::Vec; pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows}; @@ -731,7 +731,7 @@ mod tests { use std::rt; use slice::*; - use Mutable; + use {Mutable, MutableSeq}; use vec::Vec; fn square(n: uint) -> uint { n * n } @@ -2133,6 +2133,7 @@ mod bench { use test::Bencher; use vec::Vec; + use MutableSeq; #[bench] fn iterator(b: &mut Bencher) { diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 48bc492e25ce4..653f6bae26c2b 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -77,7 +77,7 @@ use core::cmp; use core::iter::AdditiveIterator; use core::mem; -use Collection; +use {Collection, MutableSeq}; use hash; use string::String; use unicode; diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index b19bef685901f..10cc446abcdaf 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -20,7 +20,7 @@ use core::mem; use core::ptr; use core::raw::Slice; -use {Collection, Mutable}; +use {Collection, Mutable, MutableSeq}; use hash; use str; use str::{CharRange, StrAllocating, MaybeOwned, Owned, Slice}; diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs index 8c24326c84092..124209ba52e2a 100644 --- a/src/libcollections/treemap.rs +++ b/src/libcollections/treemap.rs @@ -40,7 +40,7 @@ use core::mem::{replace, swap}; use core::ptr; use std::hash::{Writer, Hash}; -use {Collection, Mutable, Set, MutableSet, MutableMap, Map}; +use {Collection, Mutable, Set, MutableSet, MutableMap, Map, MutableSeq}; use vec::Vec; // This is implemented as an AA tree, which is a simplified variation of @@ -1127,7 +1127,7 @@ mod test_treemap { use std::rand::Rng; use std::rand; - use {Map, MutableMap, Mutable}; + use {Map, MutableMap, Mutable, MutableSeq}; use super::{TreeMap, TreeNode}; #[test] diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 0002867495c78..2338b5ff7e97a 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -23,7 +23,7 @@ use core::num; use core::ptr; use core::uint; -use {Collection, Mutable}; +use {Collection, Mutable, MutableSeq}; use slice::{MutableOrdVector, MutableVectorAllocating, CloneableVector}; use slice::{Items, MutItems}; @@ -666,67 +666,6 @@ impl Vec { } } - /// Remove the last element from a vector and return it, or `None` if it is - /// empty. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2, 3]; - /// assert_eq!(vec.pop(), Some(3)); - /// assert_eq!(vec, vec![1, 2]); - /// ``` - #[inline] - pub fn pop(&mut self) -> Option { - if self.len == 0 { - None - } else { - unsafe { - self.len -= 1; - Some(ptr::read(self.as_slice().unsafe_ref(self.len()))) - } - } - } - - /// Append an element to a vector. - /// - /// # Failure - /// - /// Fails if the number of elements in the vector overflows a `uint`. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2]; - /// vec.push(3); - /// assert_eq!(vec, vec![1, 2, 3]); - /// ``` - #[inline] - pub fn push(&mut self, value: T) { - if mem::size_of::() == 0 { - // zero-size types consume no memory, so we can't rely on the address space running out - self.len = self.len.checked_add(&1).expect("length overflow"); - unsafe { mem::forget(value); } - return - } - if self.len == self.cap { - let old_size = self.cap * mem::size_of::(); - let size = max(old_size, 2 * mem::size_of::()) * 2; - if old_size > size { fail!("capacity overflow") } - unsafe { - self.ptr = alloc_or_realloc(self.ptr, size, - self.cap * mem::size_of::()); - } - self.cap = max(self.cap, 2) * 2; - } - - unsafe { - let end = (self.ptr as *const T).offset(self.len as int) as *mut T; - ptr::write(&mut *end, value); - self.len += 1; - } - } - /// Appends one element to the vector provided. The vector itself is then /// returned for use again. /// @@ -1615,6 +1554,70 @@ impl fmt::Show for Vec { } } +impl MutableSeq for Vec { + /// Append an element to a vector. + /// + /// # Failure + /// + /// Fails if the number of elements in the vector overflows a `uint`. + /// + /// # Example + /// + /// ```rust + /// let mut vec = vec!(1i, 2); + /// vec.push(3); + /// assert_eq!(vec, vec!(1, 2, 3)); + /// ``` + #[inline] + fn push(&mut self, value: T) { + if mem::size_of::() == 0 { + // zero-size types consume no memory, so we can't rely on the address space running out + self.len = self.len.checked_add(&1).expect("length overflow"); + unsafe { mem::forget(value); } + return + } + if self.len == self.cap { + let old_size = self.cap * mem::size_of::(); + let size = max(old_size, 2 * mem::size_of::()) * 2; + if old_size > size { fail!("capacity overflow") } + unsafe { + self.ptr = alloc_or_realloc(self.ptr, size, + self.cap * mem::size_of::()); + } + self.cap = max(self.cap, 2) * 2; + } + + unsafe { + let end = (self.ptr as *const T).offset(self.len as int) as *mut T; + ptr::write(&mut *end, value); + self.len += 1; + } + } + + /// Remove the last element from a vector and return it, or `None` if it is + /// empty. + /// + /// # Example + /// + /// ```rust + /// let mut vec = vec!(1i, 2, 3); + /// assert_eq!(vec.pop(), Some(3)); + /// assert_eq!(vec, vec!(1, 2)); + /// ``` + #[inline] + fn pop(&mut self) -> Option { + if self.len == 0 { + None + } else { + unsafe { + self.len -= 1; + Some(ptr::read(self.as_slice().unsafe_ref(self.len()))) + } + } + } + +} + /// An iterator that moves out of a vector. pub struct MoveItems { allocation: *mut T, // the block of memory allocated for the vector @@ -1704,6 +1707,8 @@ mod tests { use test::Bencher; use super::{unzip, raw, Vec}; + use MutableSeq; + #[test] fn test_small_vec_struct() { assert!(size_of::>() == size_of::() * 3); diff --git a/src/librustrt/at_exit_imp.rs b/src/librustrt/at_exit_imp.rs index 1faf492e498ac..c9188e81975c6 100644 --- a/src/librustrt/at_exit_imp.rs +++ b/src/librustrt/at_exit_imp.rs @@ -15,6 +15,7 @@ use core::prelude::*; use alloc::boxed::Box; +use collections::MutableSeq; use collections::vec::Vec; use core::atomics; use core::mem; diff --git a/src/librustrt/local_data.rs b/src/librustrt/local_data.rs index 7434951d3ee91..b7366f440d034 100644 --- a/src/librustrt/local_data.rs +++ b/src/librustrt/local_data.rs @@ -41,6 +41,7 @@ assert_eq!(*key_vector.get().unwrap(), vec![4]); use core::prelude::*; use alloc::boxed::Box; +use collections::MutableSeq; use collections::vec::Vec; use core::kinds::marker; use core::mem; diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index ccef1c0fd2adb..d98d490a84b27 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -15,7 +15,7 @@ #![experimental] pub use core_collections::{Collection, Mutable, Map, MutableMap}; -pub use core_collections::{Set, MutableSet, Deque}; +pub use core_collections::{Set, MutableSet, Deque, MutableSeq}; pub use core_collections::{Bitv, BitvSet, BTree, DList, EnumSet}; pub use core_collections::{PriorityQueue, RingBuf, SmallIntMap}; pub use core_collections::{TreeMap, TreeSet, TrieMap, TrieSet}; diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 86283f03381dd..5980245fa79a2 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -20,6 +20,7 @@ A simple wrapper over the platform's dynamic library facilities #![allow(missing_doc)] use clone::Clone; +use collections::MutableSeq; use c_str::ToCStr; use iter::Iterator; use mem; diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index ca3eee01575fd..5215aec5dfbfa 100644 --- 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 collections::Collection; +use collections::{Collection, MutableSeq}; use iter::Iterator; use option::{Option, Some, None}; use result::{Ok, Err}; diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index afd88ee0ed91b..c7dec49a76d1f 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -53,7 +53,7 @@ fs::unlink(&path); use c_str::ToCStr; use clone::Clone; -use collections::Collection; +use collections::{Collection, MutableSeq}; use io::standard_error; use io::{FilePermission, Write, UnstableFileStat, Open, FileAccess, FileMode}; use io::{IoResult, IoError, FileStat, SeekStyle, Seek, Writer, Reader}; diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs index d46f437cddd50..c126866e7159a 100644 --- a/src/libstd/io/signal.rs +++ b/src/libstd/io/signal.rs @@ -20,6 +20,7 @@ definitions for a number of signals. */ use clone::Clone; +use collections::MutableSeq; use comm::{Sender, Receiver, channel}; use io; use iter::Iterator; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index e14092bc8dc16..125c3fdf5d90c 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -288,4 +288,6 @@ mod std { #[cfg(test)] pub use os = realstd::os; // The test runner requires std::slice::Vector, so re-export std::slice just for it. #[cfg(test)] pub use slice; + + pub use collections; // vec!() uses MutableSeq } diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 3c6c860f516bb..6de6b9d680f75 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -315,6 +315,9 @@ macro_rules! try( #[macro_export] macro_rules! vec( ($($e:expr),*) => ({ + #[allow(unused_imports)] + use std::collections::MutableSeq; + // leading _ to allow empty construction without a warning. let mut _temp = ::std::vec::Vec::new(); $(_temp.push($e);)* diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index cc30acf064b82..c8528e752e89a 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -14,7 +14,7 @@ use char; use clone::Clone; -use collections::Collection; +use collections::{Collection, MutableSeq}; 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 96d3b3e3e6a53..f71f1d22d009d 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -32,7 +32,7 @@ #![allow(non_snake_case_functions)] use clone::Clone; -use collections::Collection; +use collections::{Collection, MutableSeq}; use fmt; use io::{IoResult, IoError}; use iter::Iterator; diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index ececfab5f7433..0c93f8e6de979 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -65,7 +65,7 @@ println!("path exists: {}", path.exists()); #![experimental] -use collections::Collection; +use collections::{Collection, MutableSeq}; use c_str::CString; use clone::Clone; use fmt; diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 007686aa05cd5..877ca2c7e013f 100644 --- 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, PartialOrd, Ord, Ordering}; -use collections::Collection; +use collections::{Collection, MutableSeq}; use from_str::FromStr; use hash; use io::Writer; diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 4a6ed5612334c..d9b802b38fdeb 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -16,7 +16,7 @@ use ascii::AsciiCast; use c_str::{CString, ToCStr}; use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; -use collections::Collection; +use collections::{Collection, MutableSeq}; use from_str::FromStr; use hash; use io::Writer; diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index 0fa223305a669..0ce7497cf300e 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -63,7 +63,7 @@ #[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 collections::{Collection, Mutable, Map, MutableMap}; +#[doc(no_inline)] pub use collections::{Collection, Mutable, Map, MutableMap, MutableSeq}; #[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}; diff --git a/src/libsync/deque.rs b/src/libsync/deque.rs index 913a58010d496..c541cc02774e0 100644 --- a/src/libsync/deque.rs +++ b/src/libsync/deque.rs @@ -55,7 +55,7 @@ use core::prelude::*; use alloc::arc::Arc; use alloc::heap::{allocate, deallocate}; use alloc::boxed::Box; -use collections::Vec; +use collections::{Vec, MutableSeq}; use core::kinds::marker; use core::mem::{forget, min_align_of, size_of, transmute}; use core::ptr; diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs index d056566bb9a97..1bdf24ea7dd51 100644 --- a/src/libsync/raw.rs +++ b/src/libsync/raw.rs @@ -22,7 +22,7 @@ use core::finally::Finally; use core::kinds::marker; use core::mem; use core::ty::Unsafe; -use collections::Vec; +use collections::{Vec, MutableSeq}; use mutex; use comm::{Receiver, Sender, channel}; From 79a980558b826b8ee722cf00409c65e8b2f24583 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 11 Jul 2014 10:19:27 -0700 Subject: [PATCH 02/11] collections: Deprecate push_back/pop_back --- src/libcollections/dlist.rs | 2 ++ src/libcollections/lib.rs | 2 ++ src/libcollections/ringbuf.rs | 2 ++ 3 files changed, 6 insertions(+) diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 24df95e77c480..f4d0763421c76 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -253,6 +253,7 @@ impl Deque for DList { /// Add an element last in the list /// /// O(1) + #[deprecated = "use the `push` method"] fn push_back(&mut self, elt: T) { self.push_back_node(box Node::new(elt)) } @@ -260,6 +261,7 @@ impl Deque for DList { /// Remove the last element and return it, or None if the list is empty /// /// O(1) + #[deprecated = "use the `pop` method"] fn pop_back(&mut self) -> Option { self.pop_back_node().map(|box Node{value, ..}| value) } diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 2b1d8b140ae58..1cf660e0938d1 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -492,6 +492,7 @@ pub trait Deque : MutableSeq { /// d.push_back(2i); /// assert_eq!(d.front(), Some(&1i)); /// ``` + #[deprecated = "use the `push` method"] fn push_back(&mut self, elt: T); /// Remove the last element and return it, or `None` if the sequence is empty. @@ -509,6 +510,7 @@ pub trait Deque : MutableSeq { /// assert_eq!(d.pop_back(), Some(1i)); /// assert_eq!(d.pop_back(), None); /// ``` + #[deprecated = "use the `pop` method"] fn pop_back(&mut self) -> Option; /// Remove the first element and return it, or `None` if the sequence is empty. diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index 05dda93039861..9d24b349c975c 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -81,6 +81,7 @@ impl Deque for RingBuf { } /// Remove and return the last element in the RingBuf, or None if it is empty + #[deprecated = "use the `pop` method"] fn pop_back(&mut self) -> Option { if self.nelts > 0 { self.nelts -= 1; @@ -104,6 +105,7 @@ impl Deque for RingBuf { } /// Append an element to the RingBuf + #[deprecated = "use the `push` method"] fn push_back(&mut self, t: T) { if self.nelts == self.elts.len() { grow(self.nelts, &mut self.lo, &mut self.elts); From 5599b69b6d3cb7ba9eb30b155aa580865b99d90e Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 11 Jul 2014 11:29:38 -0700 Subject: [PATCH 03/11] Convert some push_back users to push --- src/libserialize/collection_impls.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs index b74d20ffc54fa..79166935a5e7f 100644 --- a/src/libserialize/collection_impls.rs +++ b/src/libserialize/collection_impls.rs @@ -15,7 +15,7 @@ use std::default::Default; use std::hash::{Hash, Hasher}; use {Decodable, Encodable, Decoder, Encoder}; -use std::collections::{DList, RingBuf, TreeMap, TreeSet, Deque, HashMap, HashSet, +use std::collections::{DList, RingBuf, TreeMap, TreeSet, HashMap, HashSet, TrieMap, TrieSet}; use std::collections::enum_set::{EnumSet, CLike}; @@ -39,7 +39,7 @@ impl,T:Decodable> Decodable for DList { d.read_seq(|d, len| { let mut list = DList::new(); for i in range(0u, len) { - list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); + list.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); } Ok(list) }) @@ -66,7 +66,7 @@ impl,T:Decodable> Decodable for RingBuf { d.read_seq(|d, len| { let mut deque: RingBuf = RingBuf::new(); for i in range(0u, len) { - deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); + deque.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d)))); } Ok(deque) }) From 7c61bb72130415006b505f12970b72bd96a7bc70 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 11 Jul 2014 12:01:06 -0700 Subject: [PATCH 04/11] collections: Move push/pop docs to MutableSeq --- src/libcollections/lib.rs | 23 +++++++++++++++++++++++ src/libcollections/vec.rs | 23 ----------------------- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 1cf660e0938d1..1d1907f454193 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -326,7 +326,30 @@ pub trait MutableSet: Set + Mutable { } pub trait MutableSeq: Mutable { + /// Append an element to the back of a collection. + /// + /// # Failure + /// + /// Fails if the number of elements in the vector overflows a `uint`. + /// + /// # Example + /// + /// ```rust + /// let mut vec = vec!(1i, 2); + /// vec.push(3); + /// assert_eq!(vec, vec!(1, 2, 3)); + /// ``` fn push(&mut self, t: T); + /// Remove the last element from a collection and return it, or `None` if it is + /// empty. + /// + /// # Example + /// + /// ```rust + /// let mut vec = vec!(1i, 2, 3); + /// assert_eq!(vec.pop(), Some(3)); + /// assert_eq!(vec, vec!(1, 2)); + /// ``` fn pop(&mut self) -> Option; } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 2338b5ff7e97a..3c23550909bc5 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1555,19 +1555,6 @@ impl fmt::Show for Vec { } impl MutableSeq for Vec { - /// Append an element to a vector. - /// - /// # Failure - /// - /// Fails if the number of elements in the vector overflows a `uint`. - /// - /// # Example - /// - /// ```rust - /// let mut vec = vec!(1i, 2); - /// vec.push(3); - /// assert_eq!(vec, vec!(1, 2, 3)); - /// ``` #[inline] fn push(&mut self, value: T) { if mem::size_of::() == 0 { @@ -1594,16 +1581,6 @@ impl MutableSeq for Vec { } } - /// Remove the last element from a vector and return it, or `None` if it is - /// empty. - /// - /// # Example - /// - /// ```rust - /// let mut vec = vec!(1i, 2, 3); - /// assert_eq!(vec.pop(), Some(3)); - /// assert_eq!(vec, vec!(1, 2)); - /// ``` #[inline] fn pop(&mut self) -> Option { if self.len == 0 { From 2d79bfa4150c356240d934b14623d6e90f7e48c4 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 11 Jul 2014 18:00:43 -0700 Subject: [PATCH 05/11] vim: Add MutableSeq --- src/etc/vim/syntax/rust.vim | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim index e3fadccd1c9fd..0204d42a726ff 100644 --- a/src/etc/vim/syntax/rust.vim +++ b/src/etc/vim/syntax/rust.vim @@ -100,7 +100,7 @@ syn keyword rustTrait Clone syn keyword rustTrait PartialEq PartialOrd Eq Ord Equiv syn keyword rustEnum Ordering syn keyword rustEnumVariant Less Equal Greater -syn keyword rustTrait Collection Mutable Map MutableMap +syn keyword rustTrait Collection Mutable Map MutableMap MutableSeq syn keyword rustTrait Set MutableSet syn keyword rustTrait FromIterator Extendable ExactSize syn keyword rustTrait Iterator DoubleEndedIterator From 94e42c2d896cd26c1a48fa4a1748f2c62089fc2a Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 11 Jul 2014 18:08:46 -0700 Subject: [PATCH 06/11] collections: Make push_back/pop_back default methods --- src/libcollections/dlist.rs | 20 ++++---------------- src/libcollections/lib.rs | 4 ++-- src/libcollections/ringbuf.rs | 32 ++++++++++++-------------------- 3 files changed, 18 insertions(+), 38 deletions(-) diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index f4d0763421c76..19488ee9f8543 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -249,29 +249,17 @@ impl Deque for DList { fn pop_front(&mut self) -> Option { self.pop_front_node().map(|box Node{value, ..}| value) } +} - /// Add an element last in the list - /// - /// O(1) - #[deprecated = "use the `push` method"] - fn push_back(&mut self, elt: T) { +impl MutableSeq for DList { + fn push(&mut self, elt: T) { self.push_back_node(box Node::new(elt)) } - - /// Remove the last element and return it, or None if the list is empty - /// - /// O(1) - #[deprecated = "use the `pop` method"] - fn pop_back(&mut self) -> Option { + fn pop(&mut self) -> Option { self.pop_back_node().map(|box Node{value, ..}| value) } } -impl MutableSeq for DList { - fn push(&mut self, elt: T) { self.push_back(elt) } - fn pop(&mut self) -> Option { self.pop_back() } -} - impl Default for DList { #[inline] fn default() -> DList { DList::new() } diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 1d1907f454193..8d008f921da17 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -516,7 +516,7 @@ pub trait Deque : MutableSeq { /// assert_eq!(d.front(), Some(&1i)); /// ``` #[deprecated = "use the `push` method"] - fn push_back(&mut self, elt: T); + fn push_back(&mut self, elt: T) { self.push(elt) } /// Remove the last element and return it, or `None` if the sequence is empty. /// @@ -534,7 +534,7 @@ pub trait Deque : MutableSeq { /// assert_eq!(d.pop_back(), None); /// ``` #[deprecated = "use the `pop` method"] - fn pop_back(&mut self) -> Option; + fn pop_back(&mut self) -> Option { self.pop() } /// Remove the first element and return it, or `None` if the sequence is empty. /// diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index 9d24b349c975c..c56781ec30b72 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -80,18 +80,6 @@ impl Deque for RingBuf { result } - /// Remove and return the last element in the RingBuf, or None if it is empty - #[deprecated = "use the `pop` method"] - fn pop_back(&mut self) -> Option { - if self.nelts > 0 { - self.nelts -= 1; - let hi = self.raw_index(self.nelts); - self.elts.get_mut(hi).take() - } else { - None - } - } - /// Prepend an element to the RingBuf fn push_front(&mut self, t: T) { if self.nelts == self.elts.len() { @@ -103,10 +91,10 @@ impl Deque for RingBuf { *self.elts.get_mut(self.lo) = Some(t); self.nelts += 1u; } +} - /// Append an element to the RingBuf - #[deprecated = "use the `push` method"] - fn push_back(&mut self, t: T) { +impl MutableSeq for RingBuf { + fn push(&mut self, t: T) { if self.nelts == self.elts.len() { grow(self.nelts, &mut self.lo, &mut self.elts); } @@ -114,11 +102,15 @@ impl Deque for RingBuf { *self.elts.get_mut(hi) = Some(t); self.nelts += 1u; } -} - -impl MutableSeq for RingBuf { - fn push(&mut self, t: T) { self.push_back(t) } - fn pop(&mut self) -> Option { self.pop_back() } + fn pop(&mut self) -> Option { + if self.nelts > 0 { + self.nelts -= 1; + let hi = self.raw_index(self.nelts); + self.elts.get_mut(hi).take() + } else { + None + } + } } impl Default for RingBuf { From 9db1d356878aa6384df10c75c08f21dc1540495a Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Mon, 14 Jul 2014 13:54:10 -0700 Subject: [PATCH 07/11] collections: Deprecate shift/unshift Use insert/remove instead. --- src/compiletest/runtest.rs | 2 +- src/libcollections/vec.rs | 2 ++ src/libregex/parse.rs | 2 +- src/librustdoc/lib.rs | 2 +- src/librustdoc/markdown.rs | 2 +- src/librustdoc/test.rs | 2 +- src/librustuv/access.rs | 2 +- src/libterm/terminfo/parm.rs | 4 ++-- 8 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index c3ac40e8f08d4..6720b9a530f23 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -1178,7 +1178,7 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) -> // Add the arguments in the run_flags directive args.push_all_move(split_maybe_args(&props.run_flags)); - let prog = args.shift().unwrap(); + let prog = args.remove(0).unwrap(); return ProcArgs { prog: prog, args: args, diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 3c23550909bc5..1f2b7617dfbb9 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -987,6 +987,7 @@ impl Vec { /// assert_eq!(vec, vec![4, 1, 2, 3]); /// ``` #[inline] + #[deprecated = "use insert(0, ...)"] pub fn unshift(&mut self, element: T) { self.insert(0, element) } @@ -1007,6 +1008,7 @@ impl Vec { /// assert_eq!(vec, vec![2, 3]); /// ``` #[inline] + #[deprecated = "use remove(0)"] pub fn shift(&mut self) -> Option { self.remove(0) } diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs index d53fed7aa80fc..a1fd62cecbed9 100644 --- a/src/libregex/parse.rs +++ b/src/libregex/parse.rs @@ -998,7 +998,7 @@ fn concat_flatten(x: Ast, y: Ast) -> Ast { match (x, y) { (Cat(mut xs), Cat(ys)) => { xs.push_all_move(ys); Cat(xs) } (Cat(mut xs), ast) => { xs.push(ast); Cat(xs) } - (ast, Cat(mut xs)) => { xs.unshift(ast); Cat(xs) } + (ast, Cat(mut xs)) => { xs.insert(0, ast); Cat(xs) } (ast1, ast2) => Cat(vec!(ast1, ast2)), } } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 76b3a012dbfb0..b992a11bc6483 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -361,7 +361,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche } if default_passes { for name in DEFAULT_PASSES.iter().rev() { - passes.unshift(name.to_string()); + passes.insert(0, name.to_string()); } } diff --git a/src/librustdoc/markdown.rs b/src/librustdoc/markdown.rs index 47009c1f2cc15..416018cadd2a8 100644 --- a/src/librustdoc/markdown.rs +++ b/src/librustdoc/markdown.rs @@ -136,7 +136,7 @@ pub fn test(input: &str, libs: HashSet, externs: core::Externs, let mut collector = Collector::new(input.to_string(), libs, externs, true); find_testable_code(input_str.as_slice(), &mut collector); - test_args.unshift("rustdoctest".to_string()); + test_args.insert(0, "rustdoctest".to_string()); testing::test_main(test_args.as_slice(), collector.tests); 0 } diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 2ed35469dfa8d..aef6af1677ab0 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -97,7 +97,7 @@ pub fn run(input: &str, false); collector.fold_crate(krate); - test_args.unshift("rustdoctest".to_string()); + test_args.insert(0, "rustdoctest".to_string()); testing::test_main(test_args.as_slice(), collector.tests.move_iter().collect()); diff --git a/src/librustuv/access.rs b/src/librustuv/access.rs index 63d9aa7ead0a0..bcbcde3fba515 100644 --- a/src/librustuv/access.rs +++ b/src/librustuv/access.rs @@ -114,7 +114,7 @@ impl<'a> Drop for Guard<'a> { mem::transmute(self.access.inner.get()) }; - match inner.queue.shift() { + match inner.queue.remove(0) { // Here we have found a task that was waiting for access, and we // current have the "access lock" we need to relinquish access to // this sleeping task. diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs index db76e78d1617c..1410f225a298b 100644 --- a/src/libterm/terminfo/parm.rs +++ b/src/libterm/terminfo/parm.rs @@ -514,12 +514,12 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result ,String> { FormatDigit => { if flags.space && !(s[0] == '-' as u8 || s[0] == '+' as u8) { - s.unshift(' ' as u8); + s.insert(0, ' ' as u8); } } FormatOctal => { if flags.alternate && s[0] != '0' as u8 { - s.unshift('0' as u8); + s.insert(0, '0' as u8); } } FormatHex => { From 054b1ff989e278ad1ea278c87beda25a8587d367 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Mon, 14 Jul 2014 14:45:10 -0700 Subject: [PATCH 08/11] Remove kludgy imports from vec! macro --- src/libcollections/bitv.rs | 2 +- src/libcollections/btree.rs | 2 ++ src/libcollections/enum_set.rs | 2 ++ src/libcollections/macros.rs | 18 ------------------ src/libcollections/ringbuf.rs | 2 +- src/libcollections/smallintmap.rs | 2 +- src/libcollections/str.rs | 4 +++- src/libcollections/treemap.rs | 2 +- src/libcollections/trie.rs | 4 ++-- src/libstd/io/net/tcp.rs | 1 + src/libstd/macros.rs | 3 --- 11 files changed, 14 insertions(+), 28 deletions(-) diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index e7190a810e47f..44af3d52db982 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -1574,7 +1574,7 @@ mod tests { use std::rand::Rng; use test::Bencher; - use {Set, Mutable, MutableSet}; + use {Set, Mutable, MutableSet, MutableSeq}; use bitv::{Bitv, BitvSet, from_fn, from_bytes}; use bitv; use vec::Vec; diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs index 096b0c7f5172c..947c87daa8460 100644 --- a/src/libcollections/btree.rs +++ b/src/libcollections/btree.rs @@ -782,6 +782,8 @@ mod test_btree { use super::{BTree, Node, LeafElt}; + use MutableSeq; + //Tests the functionality of the insert methods (which are unfinished). #[test] fn insert_test_one() { diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 1360b412c2370..ca3f6a746f335 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -141,6 +141,8 @@ mod test { use enum_set::{EnumSet, CLike}; + use MutableSeq; + #[deriving(PartialEq, Show)] #[repr(uint)] enum Foo { diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs index 0e4b46cfc56fb..db062a70bbb67 100644 --- a/src/libcollections/macros.rs +++ b/src/libcollections/macros.rs @@ -11,26 +11,8 @@ #![macro_escape] /// Create a `std::vec::Vec` containing the arguments. -#[cfg(not(test))] macro_rules! vec( ($($e:expr),*) => ({ - #[allow(unused_imports)] - use std::collections::MutableSeq; - - // leading _ to allow empty construction without a warning. - let mut _temp = ::vec::Vec::new(); - $(_temp.push($e);)* - _temp - }); - ($($e:expr),+,) => (vec!($($e),+)) -) - -#[cfg(test)] -macro_rules! vec( - ($($e:expr),*) => ({ - #[allow(unused_imports)] - use MutableSeq; - // leading _ to allow empty construction without a warning. let mut _temp = ::vec::Vec::new(); $(_temp.push($e);)* diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index c56781ec30b72..3a4e66b38ae3f 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -422,7 +422,7 @@ mod tests { use test::Bencher; use test; - use {Deque, Mutable}; + use {Deque, Mutable, MutableSeq}; use super::RingBuf; use vec::Vec; diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs index ca62b1235d554..eb97215c721bc 100644 --- a/src/libcollections/smallintmap.rs +++ b/src/libcollections/smallintmap.rs @@ -22,7 +22,7 @@ use core::fmt; use core::iter::{Enumerate, FilterMap}; use core::mem::replace; -use {Collection, Mutable, Map, MutableMap}; +use {Collection, Mutable, Map, MutableMap, MutableSeq}; use {vec, slice}; use vec::Vec; diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 653f6bae26c2b..c0e903677de35 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -562,6 +562,8 @@ pub mod raw { use string::String; use vec::Vec; + use MutableSeq; + pub use core::str::raw::{from_utf8, c_str_to_static_slice, slice_bytes}; pub use core::str::raw::{slice_unchecked}; @@ -818,7 +820,7 @@ mod tests { use std::option::{Some, None}; use std::ptr::RawPtr; use std::iter::{Iterator, DoubleEndedIterator}; - use Collection; + use {Collection, MutableSeq}; use super::*; use std::slice::{Vector, ImmutableVector}; diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs index 124209ba52e2a..5658d07a1d175 100644 --- a/src/libcollections/treemap.rs +++ b/src/libcollections/treemap.rs @@ -1659,7 +1659,7 @@ mod test_set { use std::prelude::*; use std::hash; - use {Set, MutableSet, Mutable, MutableMap}; + use {Set, MutableSet, Mutable, MutableMap, MutableSeq}; use super::{TreeMap, TreeSet}; #[test] diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs index 424cda92c12d4..5a00c4b85dafa 100644 --- a/src/libcollections/trie.rs +++ b/src/libcollections/trie.rs @@ -682,7 +682,7 @@ mod test_map { use std::uint; use std::hash; - use {MutableMap, Map}; + use {MutableMap, Map, MutableSeq}; use super::{TrieMap, TrieNode, Internal, External, Nothing}; fn check_integrity(trie: &TrieNode) { @@ -1105,7 +1105,7 @@ mod test_set { use std::prelude::*; use std::uint; - use {MutableSet, Set}; + use {MutableSet, Set, MutableSeq}; use super::TrieSet; #[test] diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index 642654ba6ed81..cb754135bc152 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -18,6 +18,7 @@ //! listener (socket server) implements the `Listener` and `Acceptor` traits. use clone::Clone; +use collections::MutableSeq; use io::IoResult; use iter::Iterator; use slice::ImmutableVector; diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 6de6b9d680f75..3c6c860f516bb 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -315,9 +315,6 @@ macro_rules! try( #[macro_export] macro_rules! vec( ($($e:expr),*) => ({ - #[allow(unused_imports)] - use std::collections::MutableSeq; - // leading _ to allow empty construction without a warning. let mut _temp = ::std::vec::Vec::new(); $(_temp.push($e);)* From 63d1137d68d1394e66815675921210ed8487c01e Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Mon, 14 Jul 2014 14:51:54 -0700 Subject: [PATCH 09/11] collections: Tweak docs for push --- src/libcollections/lib.rs | 4 ---- src/libcollections/vec.rs | 13 +++++++++++++ 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 8d008f921da17..6882ad9a68932 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -328,10 +328,6 @@ pub trait MutableSet: Set + Mutable { pub trait MutableSeq: Mutable { /// Append an element to the back of a collection. /// - /// # Failure - /// - /// Fails if the number of elements in the vector overflows a `uint`. - /// /// # Example /// /// ```rust diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 1f2b7617dfbb9..17b32e5699d59 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1557,6 +1557,19 @@ impl fmt::Show for Vec { } impl MutableSeq for Vec { + /// Append an element to the back of a collection. + /// + /// # Failure + /// + /// Fails if the number of elements in the vector overflows a `uint`. + /// + /// # Example + /// + /// ```rust + /// let mut vec = vec!(1i, 2); + /// vec.push(3); + /// assert_eq!(vec, vec!(1, 2, 3)); + /// ``` #[inline] fn push(&mut self, value: T) { if mem::size_of::() == 0 { From 27e70c5d4946e07dc25b8fb86ecc379b8b3eeb5f Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Mon, 14 Jul 2014 15:03:15 -0700 Subject: [PATCH 10/11] Remove stray llvmdeps.rs --- src/librustc/lib/llvmdeps.rs | 64 ------------------------------------ 1 file changed, 64 deletions(-) delete mode 100644 src/librustc/lib/llvmdeps.rs diff --git a/src/librustc/lib/llvmdeps.rs b/src/librustc/lib/llvmdeps.rs deleted file mode 100644 index 05e5e585a63ab..0000000000000 --- a/src/librustc/lib/llvmdeps.rs +++ /dev/null @@ -1,64 +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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// WARNING: THIS IS A GENERATED FILE, DO NOT MODIFY -// take a look at src/etc/mklldeps.py if you're interested - -#[cfg(target_arch = "x86_64", target_os = "linux")] -#[link(name = "LLVMInstrumentation", kind = "static")] -#[link(name = "LLVMInterpreter", kind = "static")] -#[link(name = "LLVMMCJIT", kind = "static")] -#[link(name = "LLVMRuntimeDyld", kind = "static")] -#[link(name = "LLVMJIT", kind = "static")] -#[link(name = "LLVMExecutionEngine", kind = "static")] -#[link(name = "LLVMAsmParser", kind = "static")] -#[link(name = "LLVMLinker", kind = "static")] -#[link(name = "LLVMBitWriter", kind = "static")] -#[link(name = "LLVMipo", kind = "static")] -#[link(name = "LLVMVectorize", kind = "static")] -#[link(name = "LLVMMipsDisassembler", kind = "static")] -#[link(name = "LLVMMipsCodeGen", kind = "static")] -#[link(name = "LLVMMipsAsmParser", kind = "static")] -#[link(name = "LLVMMipsDesc", kind = "static")] -#[link(name = "LLVMMipsInfo", kind = "static")] -#[link(name = "LLVMMipsAsmPrinter", kind = "static")] -#[link(name = "LLVMARMDisassembler", kind = "static")] -#[link(name = "LLVMARMCodeGen", kind = "static")] -#[link(name = "LLVMARMAsmParser", kind = "static")] -#[link(name = "LLVMARMDesc", kind = "static")] -#[link(name = "LLVMARMInfo", kind = "static")] -#[link(name = "LLVMARMAsmPrinter", kind = "static")] -#[link(name = "LLVMX86Disassembler", kind = "static")] -#[link(name = "LLVMX86AsmParser", kind = "static")] -#[link(name = "LLVMX86CodeGen", kind = "static")] -#[link(name = "LLVMSelectionDAG", kind = "static")] -#[link(name = "LLVMAsmPrinter", kind = "static")] -#[link(name = "LLVMMCParser", kind = "static")] -#[link(name = "LLVMCodeGen", kind = "static")] -#[link(name = "LLVMScalarOpts", kind = "static")] -#[link(name = "LLVMInstCombine", kind = "static")] -#[link(name = "LLVMTransformUtils", kind = "static")] -#[link(name = "LLVMipa", kind = "static")] -#[link(name = "LLVMAnalysis", kind = "static")] -#[link(name = "LLVMTarget", kind = "static")] -#[link(name = "LLVMX86Desc", kind = "static")] -#[link(name = "LLVMX86Info", kind = "static")] -#[link(name = "LLVMX86AsmPrinter", kind = "static")] -#[link(name = "LLVMMC", kind = "static")] -#[link(name = "LLVMObject", kind = "static")] -#[link(name = "LLVMBitReader", kind = "static")] -#[link(name = "LLVMCore", kind = "static")] -#[link(name = "LLVMX86Utils", kind = "static")] -#[link(name = "LLVMSupport", kind = "static")] -#[link(name = "pthread")] -#[link(name = "dl")] -#[link(name = "m")] -#[link(name = "stdc++")] -extern {} From 71a75cc2ce6d6eed2557e6c585e81abcdad86827 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sun, 20 Jul 2014 17:57:29 -0700 Subject: [PATCH 11/11] Just land already --- src/libcollections/dlist.rs | 46 +++++++++++++++---------------- src/libcollections/lib.rs | 36 ++++++++++++------------ src/libcollections/string.rs | 2 +- src/libcollections/vec.rs | 2 +- src/libstd/collections/hashmap.rs | 2 +- 5 files changed, 44 insertions(+), 44 deletions(-) diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 19488ee9f8543..68b6416b69bf5 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -279,12 +279,12 @@ impl DList { /// # Example /// /// ```rust - /// use std::collections::{DList, Deque}; + /// use std::collections::DList; /// /// let mut dl = DList::new(); - /// dl.push_back(1i); - /// dl.push_back(2); - /// dl.push_back(3); + /// dl.push(1i); + /// dl.push(2); + /// dl.push(3); /// /// dl.rotate_forward(); /// @@ -306,12 +306,12 @@ impl DList { /// # Example /// /// ```rust - /// use std::collections::{DList, Deque}; + /// use std::collections::DList; /// /// let mut dl = DList::new(); - /// dl.push_back(1i); - /// dl.push_back(2); - /// dl.push_back(3); + /// dl.push(1i); + /// dl.push(2); + /// dl.push(3); /// /// dl.rotate_backward(); /// @@ -333,14 +333,14 @@ impl DList { /// # Example /// /// ```rust - /// use std::collections::{DList, Deque}; + /// use std::collections::DList; /// /// let mut a = DList::new(); /// let mut b = DList::new(); - /// a.push_back(1i); - /// a.push_back(2); - /// b.push_back(3i); - /// b.push_back(4); + /// a.push(1i); + /// a.push(2); + /// b.push(3i); + /// b.push(4); /// /// a.append(b); /// @@ -374,14 +374,14 @@ impl DList { /// # Example /// /// ```rust - /// use std::collections::{DList, Deque}; + /// use std::collections::DList; /// /// let mut a = DList::new(); /// let mut b = DList::new(); - /// a.push_back(1i); - /// a.push_back(2); - /// b.push_back(3i); - /// b.push_back(4); + /// a.push(1i); + /// a.push(2); + /// b.push(3i); + /// b.push(4); /// /// a.prepend(b); /// @@ -403,13 +403,13 @@ impl DList { /// # Example /// /// ```rust - /// use std::collections::{DList, Deque}; + /// use std::collections::DList; /// /// let mut a: DList = DList::new(); - /// a.push_back(2i); - /// a.push_back(4); - /// a.push_back(7); - /// a.push_back(8); + /// a.push(2i); + /// a.push(4); + /// a.push(7); + /// a.push(8); /// /// // insert 11 before the first odd number in the list /// a.insert_when(11, |&e, _| e % 2 == 1); diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 6882ad9a68932..d2d8ad696d7c5 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -360,9 +360,9 @@ pub trait MutableSeq: Mutable { /// use std::collections::{RingBuf, Deque}; /// /// let mut queue = RingBuf::new(); -/// queue.push_back(1i); -/// queue.push_back(2i); -/// queue.push_back(3i); +/// queue.push(1i); +/// queue.push(2i); +/// queue.push(3i); /// /// // Will print 1, 2, 3 /// while !queue.is_empty() { @@ -398,13 +398,13 @@ pub trait MutableSeq: Mutable { /// // Init deque with 1, 2, 3, 4 /// deque.push_front(2i); /// deque.push_front(1i); -/// deque.push_back(3i); -/// deque.push_back(4i); +/// deque.push(3i); +/// deque.push(4i); /// /// // Will print (1, 4) and (2, 3) /// while !deque.is_empty() { /// let f = deque.pop_front().unwrap(); -/// let b = deque.pop_back().unwrap(); +/// let b = deque.pop().unwrap(); /// println!("{}", (f, b)); /// } /// ``` @@ -420,8 +420,8 @@ pub trait Deque : MutableSeq { /// let mut d = RingBuf::new(); /// assert_eq!(d.front(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push(1i); + /// d.push(2i); /// assert_eq!(d.front(), Some(&1i)); /// ``` fn front<'a>(&'a self) -> Option<&'a T>; @@ -437,8 +437,8 @@ pub trait Deque : MutableSeq { /// let mut d = RingBuf::new(); /// assert_eq!(d.front_mut(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push(1i); + /// d.push(2i); /// match d.front_mut() { /// Some(x) => *x = 9i, /// None => (), @@ -458,8 +458,8 @@ pub trait Deque : MutableSeq { /// let mut d = DList::new(); /// assert_eq!(d.back(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push(1i); + /// d.push(2i); /// assert_eq!(d.back(), Some(&2i)); /// ``` fn back<'a>(&'a self) -> Option<&'a T>; @@ -475,8 +475,8 @@ pub trait Deque : MutableSeq { /// let mut d = DList::new(); /// assert_eq!(d.back(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push(1i); + /// d.push(2i); /// match d.back_mut() { /// Some(x) => *x = 9i, /// None => (), @@ -503,7 +503,7 @@ pub trait Deque : MutableSeq { /// /// # Example /// - /// ``` + /// ```ignore /// use std::collections::{DList, Deque}; /// /// let mut d = DList::new(); @@ -518,7 +518,7 @@ pub trait Deque : MutableSeq { /// /// # Example /// - /// ``` + /// ```ignore /// use std::collections::{RingBuf, Deque}; /// /// let mut d = RingBuf::new(); @@ -540,8 +540,8 @@ pub trait Deque : MutableSeq { /// use std::collections::{RingBuf, Deque}; /// /// let mut d = RingBuf::new(); - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push(1i); + /// d.push(2i); /// /// assert_eq!(d.pop_front(), Some(1i)); /// assert_eq!(d.pop_front(), Some(2i)); diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 10cc446abcdaf..d58dfdd10d131 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -575,7 +575,7 @@ mod tests { use std::prelude::*; use test::Bencher; - use Mutable; + use {Mutable, MutableSeq}; use str; use str::{Str, StrSlice, Owned, Slice}; use super::String; diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 17b32e5699d59..dcee92f6dbced 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -981,7 +981,7 @@ impl Vec { /// /// # Example /// - /// ``` + /// ```ignore /// let mut vec = vec![1i, 2, 3]; /// vec.unshift(4); /// assert_eq!(vec, vec![4, 1, 2, 3]); diff --git a/src/libstd/collections/hashmap.rs b/src/libstd/collections/hashmap.rs index a05fad3705dd5..922858e963c0a 100644 --- a/src/libstd/collections/hashmap.rs +++ b/src/libstd/collections/hashmap.rs @@ -1291,7 +1291,7 @@ impl, V, S, H: Hasher> HashMap { /// // new value based on the first letter of the key. /// |key, already, new| { /// if key.as_slice().starts_with("z") { - /// already.unshift(new); + /// already.insert(0, new); /// } else { /// already.push(new); /// }