fix typos with with repeated words, just like this sentence.

5 files changed, 8 insertions, 8 deletions

diff --git a/src/libstd/comm/shared.rs b/src/libstd/comm/shared.rs
index 444f2d14dba..328dd70223b 100644
--- a/src/libstd/comm/shared.rs
+++ b/src/libstd/comm/shared.rs
@@ -302,7 +302,7 @@ impl<T: Send> Packet<T> {
             }
         };
         match ret {
-            // See the discussion in the stream implementation for why we we
+            // See the discussion in the stream implementation for why we
             // might decrement steals.
             Some(data) => {
                 if self.steals > MAX_STEALS {
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 5a69815fa29..fa122fa8c11 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -50,7 +50,7 @@ pub struct BufferedReader<R> {
 }
 
 impl<R: Reader> BufferedReader<R> {
-    /// Creates a new `BufferedReader` with with the specified buffer capacity
+    /// Creates a new `BufferedReader` with the specified buffer capacity
     pub fn with_capacity(cap: uint, inner: R) -> BufferedReader<R> {
         // It's *much* faster to create an uninitialized buffer than it is to
         // fill everything in with 0. This buffer is entirely an implementation
@@ -137,7 +137,7 @@ pub struct BufferedWriter<W> {
 }
 
 impl<W: Writer> BufferedWriter<W> {
-    /// Creates a new `BufferedWriter` with with the specified buffer capacity
+    /// Creates a new `BufferedWriter` with the specified buffer capacity
     pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
         // See comments in BufferedReader for why this uses unsafe code.
         let mut buf = vec::with_capacity(cap);
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 5f070ef782b..79e191a9ec9 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -103,7 +103,7 @@ impl File {
     /// `FileMode` and `FileAccess` provide information about the permissions
     /// context in which a given stream is created. More information about them
     /// can be found in `std::io`'s docs. If a file is opened with `Write`
-    /// or `ReadWrite` access, then it will be created it it does not already
+    /// or `ReadWrite` access, then it will be created it does not already
     /// exist.
     ///
     /// Note that, with this function, a `File` is returned regardless of the
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index d9811e3a900..7a18f24140a 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -377,7 +377,7 @@ pub trait Reader {
     ///
     /// # Error
     ///
-    /// Fails with the same conditions as `read`. Additionally returns error on
+    /// Fails with the same conditions as `read`. Additionally returns error
     /// on EOF. Note that if an error is returned, then some number of bytes may
     /// have already been consumed from the underlying reader, and they are lost
     /// (not returned as part of the error). If this is unacceptable, then it is
diff --git a/src/libstd/kinds.rs b/src/libstd/kinds.rs
index 61b24f67f66..da17119fd98 100644
--- a/src/libstd/kinds.rs
+++ b/src/libstd/kinds.rs
@@ -84,10 +84,10 @@ pub mod marker {
     /// The type system would currently infer that the value of
     /// the type parameter `T` is irrelevant, and hence a `S<int>` is
     /// a subtype of `S<~[int]>` (or, for that matter, `S<U>` for
-    /// for any `U`). But this is incorrect because `get()` converts the
+    /// any `U`). But this is incorrect because `get()` converts the
     /// `*()` into a `*T` and reads from it. Therefore, we should include the
     /// a marker field `CovariantType<T>` to inform the type checker that
-    /// `S<T>` is a subtype of `S<U>` if `T` is a a subtype of `U`
+    /// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
     /// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
     /// for some lifetime `'a`, but not the other way around).
     #[lang="covariant_type"]
@@ -125,7 +125,7 @@ pub mod marker {
     /// The type system would currently infer that the value of
     /// the type parameter `T` is irrelevant, and hence a `S<int>` is
     /// a subtype of `S<~[int]>` (or, for that matter, `S<U>` for
-    /// for any `U`). But this is incorrect because `get()` converts the
+    /// any `U`). But this is incorrect because `get()` converts the
     /// `*()` into a `fn(T)` and then passes a value of type `T` to it.
     ///
     /// Supplying a `ContravariantType` marker would correct the