Merge pull request #7897 from thestinger/double

rollup of small pull requests

404de4f r=huonw
0cdb0a2 r=pcwalton
b082302 r=sanxiyn
b6a0138 r=huonw
8d64fa3 r=graydon
ddd8c15 r=thestinger
eb74f0c r=thestinger

7 files changed, 153 insertions, 42 deletions

diff --git a/src/libstd/clone.rs b/src/libstd/clone.rs
index f24bc002a2b..6fd06c95191 100644
--- a/src/libstd/clone.rs
+++ b/src/libstd/clone.rs
@@ -21,7 +21,7 @@ the `clone` method.
 
 */
 
-use core::kinds::Freeze;
+use std::kinds::Freeze;
 
 /// A common trait for cloning an object.
 pub trait Clone {
diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs
index 1bb0ff044fe..0acd6fee57e 100644
--- a/src/libstd/comm.rs
+++ b/src/libstd/comm.rs
@@ -382,19 +382,19 @@ mod pipesy {
 
     #[allow(non_camel_case_types)]
     pub mod oneshot {
-        priv use core::kinds::Send;
+        priv use std::kinds::Send;
         use ptr::to_mut_unsafe_ptr;
 
         pub fn init<T: Send>() -> (server::Oneshot<T>, client::Oneshot<T>) {
-            pub use core::pipes::HasBuffer;
+            pub use std::pipes::HasBuffer;
 
-            let buffer = ~::core::pipes::Buffer {
-                header: ::core::pipes::BufferHeader(),
+            let buffer = ~::std::pipes::Buffer {
+                header: ::std::pipes::BufferHeader(),
                 data: __Buffer {
-                    Oneshot: ::core::pipes::mk_packet::<Oneshot<T>>()
+                    Oneshot: ::std::pipes::mk_packet::<Oneshot<T>>()
                 },
             };
-            do ::core::pipes::entangle_buffer(buffer) |buffer, data| {
+            do ::std::pipes::entangle_buffer(buffer) |buffer, data| {
                 data.Oneshot.set_buffer(buffer);
                 to_mut_unsafe_ptr(&mut data.Oneshot)
             }
@@ -403,23 +403,23 @@ mod pipesy {
         pub enum Oneshot<T> { pub send(T), }
         #[allow(non_camel_case_types)]
         pub struct __Buffer<T> {
-            Oneshot: ::core::pipes::Packet<Oneshot<T>>,
+            Oneshot: ::std::pipes::Packet<Oneshot<T>>,
         }
 
         #[allow(non_camel_case_types)]
         pub mod client {
 
-            priv use core::kinds::Send;
+            priv use std::kinds::Send;
 
             #[allow(non_camel_case_types)]
             pub fn try_send<T: Send>(pipe: Oneshot<T>, x_0: T) ->
-                ::core::option::Option<()> {
+                ::std::option::Option<()> {
                 {
                     use super::send;
                     let message = send(x_0);
-                    if ::core::pipes::send(pipe, message) {
-                        ::core::pipes::rt::make_some(())
-                    } else { ::core::pipes::rt::make_none() }
+                    if ::std::pipes::send(pipe, message) {
+                        ::std::pipes::rt::make_some(())
+                    } else { ::std::pipes::rt::make_none() }
                 }
             }
 
@@ -428,13 +428,13 @@ mod pipesy {
                 {
                     use super::send;
                     let message = send(x_0);
-                    ::core::pipes::send(pipe, message);
+                    ::std::pipes::send(pipe, message);
                 }
             }
 
             #[allow(non_camel_case_types)]
             pub type Oneshot<T> =
-                ::core::pipes::SendPacketBuffered<super::Oneshot<T>,
+                ::std::pipes::SendPacketBuffered<super::Oneshot<T>,
             super::__Buffer<T>>;
         }
 
@@ -442,7 +442,7 @@ mod pipesy {
         pub mod server {
             #[allow(non_camel_case_types)]
             pub type Oneshot<T> =
-                ::core::pipes::RecvPacketBuffered<super::Oneshot<T>,
+                ::std::pipes::RecvPacketBuffered<super::Oneshot<T>,
             super::__Buffer<T>>;
         }
     }
@@ -557,11 +557,11 @@ mod pipesy {
 
     #[allow(non_camel_case_types)]
     pub mod streamp {
-        priv use core::kinds::Send;
+        priv use std::kinds::Send;
 
         pub fn init<T: Send>() -> (server::Open<T>, client::Open<T>) {
-            pub use core::pipes::HasBuffer;
-            ::core::pipes::entangle()
+            pub use std::pipes::HasBuffer;
+            ::std::pipes::entangle()
         }
 
         #[allow(non_camel_case_types)]
@@ -569,18 +569,18 @@ mod pipesy {
 
         #[allow(non_camel_case_types)]
         pub mod client {
-            priv use core::kinds::Send;
+            priv use std::kinds::Send;
 
             #[allow(non_camel_case_types)]
             pub fn try_data<T: Send>(pipe: Open<T>, x_0: T) ->
-                ::core::option::Option<Open<T>> {
+                ::std::option::Option<Open<T>> {
                 {
                     use super::data;
-                    let (s, c) = ::core::pipes::entangle();
+                    let (s, c) = ::std::pipes::entangle();
                     let message = data(x_0, s);
-                    if ::core::pipes::send(pipe, message) {
-                        ::core::pipes::rt::make_some(c)
-                    } else { ::core::pipes::rt::make_none() }
+                    if ::std::pipes::send(pipe, message) {
+                        ::std::pipes::rt::make_some(c)
+                    } else { ::std::pipes::rt::make_none() }
                 }
             }
 
@@ -588,21 +588,21 @@ mod pipesy {
             pub fn data<T: Send>(pipe: Open<T>, x_0: T) -> Open<T> {
                 {
                     use super::data;
-                    let (s, c) = ::core::pipes::entangle();
+                    let (s, c) = ::std::pipes::entangle();
                     let message = data(x_0, s);
-                    ::core::pipes::send(pipe, message);
+                    ::std::pipes::send(pipe, message);
                     c
                 }
             }
 
             #[allow(non_camel_case_types)]
-            pub type Open<T> = ::core::pipes::SendPacket<super::Open<T>>;
+            pub type Open<T> = ::std::pipes::SendPacket<super::Open<T>>;
         }
 
         #[allow(non_camel_case_types)]
         pub mod server {
             #[allow(non_camel_case_types)]
-            pub type Open<T> = ::core::pipes::RecvPacket<super::Open<T>>;
+            pub type Open<T> = ::std::pipes::RecvPacket<super::Open<T>>;
         }
     }
 
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index b9593d845a4..c8cde69197b 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -773,6 +773,17 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for ChainIterator<A, T, U> {
     }
 }
 
+impl<A, T: DoubleEndedIterator<A>, U: DoubleEndedIterator<A>> DoubleEndedIterator<A>
+for ChainIterator<A, T, U> {
+    #[inline]
+    fn next_back(&mut self) -> Option<A> {
+        match self.b.next_back() {
+            Some(x) => Some(x),
+            None => self.a.next_back()
+        }
+    }
+}
+
 /// An iterator which iterates two other iterators simultaneously
 // FIXME #6967: Dummy A & B parameters to get around type inference bug
 pub struct ZipIterator<A, T, B, U> {
@@ -828,6 +839,17 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for MapIterator<'self, A, B, T> {
     }
 }
 
+impl<'self, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B>
+for MapIterator<'self, A, B, T> {
+    #[inline]
+    fn next_back(&mut self) -> Option<B> {
+        match self.iter.next_back() {
+            Some(a) => Some((self.f)(a)),
+            _ => None
+        }
+    }
+}
+
 /// An iterator which filters the elements of `iter` with `predicate`
 pub struct FilterIterator<'self, A, T> {
     priv iter: T,
@@ -854,6 +876,24 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for FilterIterator<'self, A, T> {
     }
 }
 
+impl<'self, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for FilterIterator<'self, A, T> {
+    #[inline]
+    fn next_back(&mut self) -> Option<A> {
+        loop {
+            match self.iter.next_back() {
+                None => return None,
+                Some(x) => {
+                    if (self.predicate)(&x) {
+                        return Some(x);
+                    } else {
+                        loop
+                    }
+                }
+            }
+        }
+    }
+}
+
 /// An iterator which uses `f` to both filter and map elements from `iter`
 pub struct FilterMapIterator<'self, A, B, T> {
     priv iter: T,
@@ -879,6 +919,24 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for FilterMapIterator<'self, A, B,
     }
 }
 
+impl<'self, A, B, T: DoubleEndedIterator<A>> DoubleEndedIterator<B>
+for FilterMapIterator<'self, A, B, T> {
+    #[inline]
+    fn next_back(&mut self) -> Option<B> {
+        loop {
+            match self.iter.next_back() {
+                None => return None,
+                Some(x) => {
+                    match (self.f)(x) {
+                        Some(y) => return Some(y),
+                        None => ()
+                    }
+                }
+            }
+        }
+    }
+}
+
 /// An iterator which yields the current count and the element during iteration
 // FIXME #6967: Dummy A parameter to get around type inference bug
 pub struct EnumerateIterator<A, T> {
@@ -1135,6 +1193,20 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for PeekIterator<'self, A, T> {
     }
 }
 
+impl<'self, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for PeekIterator<'self, A, T> {
+    #[inline]
+    fn next_back(&mut self) -> Option<A> {
+        let next = self.iter.next_back();
+
+        match next {
+            Some(ref a) => (self.f)(a),
+            None => ()
+        }
+
+        next
+    }
+}
+
 /// An iterator which just modifies the contained state throughout iteration.
 pub struct UnfoldrIterator<'self, A, St> {
     priv f: &'self fn(&mut St) -> Option<A>,
@@ -1526,4 +1598,53 @@ mod tests {
         it.next();
         assert_eq!(it.invert().transform(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]);
     }
+
+    #[test]
+    fn test_double_ended_map() {
+        let xs = [1, 2, 3, 4, 5, 6];
+        let mut it = xs.iter().transform(|&x| x * -1);
+        assert_eq!(it.next(), Some(-1));
+        assert_eq!(it.next(), Some(-2));
+        assert_eq!(it.next_back(), Some(-6));
+        assert_eq!(it.next_back(), Some(-5));
+        assert_eq!(it.next(), Some(-3));
+        assert_eq!(it.next_back(), Some(-4));
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn test_double_ended_filter() {
+        let xs = [1, 2, 3, 4, 5, 6];
+        let mut it = xs.iter().filter(|&x| *x & 1 == 0);
+        assert_eq!(it.next_back().unwrap(), &6);
+        assert_eq!(it.next_back().unwrap(), &4);
+        assert_eq!(it.next().unwrap(), &2);
+        assert_eq!(it.next_back(), None);
+    }
+
+    #[test]
+    fn test_double_ended_filter_map() {
+        let xs = [1, 2, 3, 4, 5, 6];
+        let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None });
+        assert_eq!(it.next_back().unwrap(), 12);
+        assert_eq!(it.next_back().unwrap(), 8);
+        assert_eq!(it.next().unwrap(), 4);
+        assert_eq!(it.next_back(), None);
+    }
+
+    #[test]
+    fn test_double_ended_chain() {
+        let xs = [1, 2, 3, 4, 5];
+        let ys = ~[7, 9, 11];
+        let mut it = xs.iter().chain_(ys.iter()).invert();
+        assert_eq!(it.next().unwrap(), &11)
+        assert_eq!(it.next().unwrap(), &9)
+        assert_eq!(it.next_back().unwrap(), &1)
+        assert_eq!(it.next_back().unwrap(), &2)
+        assert_eq!(it.next_back().unwrap(), &3)
+        assert_eq!(it.next_back().unwrap(), &4)
+        assert_eq!(it.next_back().unwrap(), &5)
+        assert_eq!(it.next_back().unwrap(), &7)
+        assert_eq!(it.next_back(), None)
+    }
 }
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index ab17c5f175a..8e7f49464ff 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -12,7 +12,7 @@
 
 use clone::Clone;
 use container::Container;
-use core::cmp::{Ord, Eq};
+use std::cmp::{Ord, Eq};
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use option::{None, Option, Some};
 use char;
diff --git a/src/libstd/rt/context.rs b/src/libstd/rt/context.rs
index 09ba869549f..b30a55978f7 100644
--- a/src/libstd/rt/context.rs
+++ b/src/libstd/rt/context.rs
@@ -209,6 +209,6 @@ fn align_down(sp: *mut uint) -> *mut uint {
 // XXX: ptr::offset is positive ints only
 #[inline]
 pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
-    use core::sys::size_of;
+    use std::sys::size_of;
     (ptr as int + count * (size_of::<T>() as int)) as *mut T
 }
diff --git a/src/libstd/std.rs b/src/libstd/std.rs
index 03b895b3860..cbf00f43c61 100644
--- a/src/libstd/std.rs
+++ b/src/libstd/std.rs
@@ -206,16 +206,6 @@ pub mod rt;
 // 'std' so that macro-expanded references to std::error and such
 // can be resolved within libstd.
 #[doc(hidden)]
-mod core {
-    pub use clone;
-    pub use cmp;
-    pub use condition;
-    pub use option;
-    pub use kinds;
-    pub use sys;
-    pub use pipes;
-}
-#[doc(hidden)]
 mod std {
     pub use clone;
     pub use cmp;
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index df6f77fd6ce..822b005de37 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -411,7 +411,7 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
 #[cfg(test)]
 mod test_map {
     use super::*;
-    use core::option::{Some, None};
+    use option::{Some, None};
     use uint;
 
     #[test]