diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 767828408be86..dccc688f90342 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -65,7 +65,7 @@ use default::Default;
 use marker;
 use mem;
 use num::{ToPrimitive, Int};
-use ops::{Add, Deref, FnMut};
+use ops::{Add, Deref, Fn, FnMut};
 use option::Option;
 use option::Option::{Some, None};
 use marker::Sized;
@@ -537,7 +537,7 @@ pub trait IteratorExt: Iterator + Sized {
     fn inspect<F>(self, f: F) -> Inspect<Self, F> where
         F: FnMut(&Self::Item),
     {
-        Inspect{iter: self, f: f}
+        Inspect{iter: self, f: DoInspect{f: f}}
     }
 
     /// Creates a wrapper around a mutable reference to the iterator.
@@ -983,7 +983,7 @@ pub trait IteratorExt: Iterator + Sized {
         Self::Item: Deref,
         <Self::Item as Deref>::Target: Clone,
     {
-        Cloned { it: self }
+        Cloned { iter: self, f: DoClone }
     }
 
     /// Repeats an iterator endlessly
@@ -1087,10 +1087,6 @@ impl<'a, I: ExactSizeIterator + ?Sized> ExactSizeIterator for &'a mut I {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<I> ExactSizeIterator for Enumerate<I> where I: ExactSizeIterator {}
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<I: ExactSizeIterator, F> ExactSizeIterator for Inspect<I, F> where
-    F: FnMut(&I::Item),
-{}
-#[stable(feature = "rust1", since = "1.0.0")]
 impl<I> ExactSizeIterator for Rev<I> where I: ExactSizeIterator + DoubleEndedIterator {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<B, I: ExactSizeIterator, F> ExactSizeIterator for Map<I, F> where
@@ -1273,60 +1269,21 @@ impl<T: Clone> MinMaxResult<T> {
 /// An iterator that clones the elements of an underlying iterator
 #[unstable(feature = "core", reason = "recent addition")]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[derive(Clone)]
-pub struct Cloned<I> {
-    it: I,
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, D, I> Iterator for Cloned<I> where
-    T: Clone,
-    D: Deref<Target=T>,
-    I: Iterator<Item=D>,
-{
-    type Item = T;
-
-    fn next(&mut self) -> Option<T> {
-        self.it.next().cloned()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.it.size_hint()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, D, I> DoubleEndedIterator for Cloned<I> where
-    T: Clone,
-    D: Deref<Target=T>,
-    I: DoubleEndedIterator<Item=D>,
-{
-    fn next_back(&mut self) -> Option<T> {
-        self.it.next_back().cloned()
-    }
-}
+pub type Cloned<I> = Map<I, DoClone>;
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, D, I> ExactSizeIterator for Cloned<I> where
-    T: Clone,
-    D: Deref<Target=T>,
-    I: ExactSizeIterator<Item=D>,
-{}
+/// clone an element
+#[derive(Clone)]
+pub struct DoClone;
 
-#[unstable(feature = "core", reason = "trait is experimental")]
-impl<T, D, I> RandomAccessIterator for Cloned<I> where
-    T: Clone,
-    D: Deref<Target=T>,
-    I: RandomAccessIterator<Item=D>
+#[unstable(feature = "core", reason = "recent addition")]
+impl<D> Fn<(D,)> for DoClone where
+    D: Deref,
+    <D as Deref>::Target: Clone,
 {
-    #[inline]
-    fn indexable(&self) -> usize {
-        self.it.indexable()
-    }
+    type Output = <D as Deref>::Target;
 
-    #[inline]
-    fn idx(&mut self, index: usize) -> Option<T> {
-        self.it.idx(index).cloned()
+    extern "rust-call" fn call(&self, (a,): (D,)) -> <D as Deref>::Target {
+        a.deref().clone()
     }
 }
 
@@ -2231,64 +2188,20 @@ impl<I> Fuse<I> {
 /// element before yielding it.
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Clone)]
-pub struct Inspect<I, F> {
-    iter: I,
-    f: F,
-}
-
-impl<I: Iterator, F> Inspect<I, F> where F: FnMut(&I::Item) {
-    #[inline]
-    fn do_inspect(&mut self, elt: Option<I::Item>) -> Option<I::Item> {
-        match elt {
-            Some(ref a) => (self.f)(a),
-            None => ()
-        }
-
-        elt
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<I: Iterator, F> Iterator for Inspect<I, F> where F: FnMut(&I::Item) {
-    type Item = I::Item;
-
-    #[inline]
-    fn next(&mut self) -> Option<I::Item> {
-        let next = self.iter.next();
-        self.do_inspect(next)
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
+pub type Inspect<I, F> = Map<I, DoInspect<F>>;
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<I: DoubleEndedIterator, F> DoubleEndedIterator for Inspect<I, F>
-    where F: FnMut(&I::Item),
-{
-    #[inline]
-    fn next_back(&mut self) -> Option<I::Item> {
-        let next = self.iter.next_back();
-        self.do_inspect(next)
-    }
-}
+/// Inspect a element and return it
+#[derive(Clone)]
+pub struct DoInspect<F> { f: F, }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
-impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
-    where F: FnMut(&I::Item),
+#[unstable(feature = "core", reason = "recent addition")]
+impl<D, F: FnMut(&D)> FnMut<(D,)> for DoInspect<F>
 {
-    #[inline]
-    fn indexable(&self) -> usize {
-        self.iter.indexable()
-    }
+    type Output = D;
 
-    #[inline]
-    fn idx(&mut self, index: usize) -> Option<I::Item> {
-        let element = self.iter.idx(index);
-        self.do_inspect(element)
+    extern "rust-call" fn call_mut(&mut self, (a,): (D,)) -> D {
+        (self.f)(&a);
+        a
     }
 }