std: fix spelling in docs.

Author: huonw

src/libstd/cell.rs

@@ -81,7 +81,7 @@ impl<T> RefCell<T> {
 
     /// Mutably borrows the wrapped value.
     ///
-    /// The borrow lasts untile the returned `RefMut` exits scope. The value
+    /// The borrow lasts until the returned `RefMut` exits scope. The value
     /// cannot be borrowed while this borrow is active.
     ///
     /// Returns `None` if the value is currently borrowed.
@@ -98,7 +98,7 @@ impl<T> RefCell<T> {
 
     /// Mutably borrows the wrapped value.
     ///
-    /// The borrow lasts untile the returned `RefMut` exits scope. The value
+    /// The borrow lasts until the returned `RefMut` exits scope. The value
     /// cannot be borrowed while this borrow is active.
     ///
     /// # Failure

src/libstd/char.rs

@@ -256,7 +256,7 @@ fn decompose_hangul(s: char, f: |char|) {
     }
 }
 
-/// Returns the canonical decompostion of a character
+/// Returns the canonical decomposition of a character.
 pub fn decompose_canonical(c: char, f: |char|) {
     if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
         decompose::canonical(c, f);
@@ -265,7 +265,7 @@ pub fn decompose_canonical(c: char, f: |char|) {
     }
 }
 
-/// Returns the compatibility decompostion of a character
+/// Returns the compatibility decomposition of a character.
 pub fn decompose_compatible(c: char, f: |char|) {
     if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
         decompose::compatibility(c, f);

src/libstd/clone.rs

@@ -33,7 +33,7 @@ pub trait Clone {
     /// Perform copy-assignment from `source`.
     ///
     /// `a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality,
-    /// but can be overriden to reuse the resources of `a` to avoid unnecessary
+    /// but can be overridden to reuse the resources of `a` to avoid unnecessary
     /// allocations.
     #[inline(always)]
     fn clone_from(&mut self, source: &Self) {
@@ -141,7 +141,7 @@ pub trait DeepClone: Clone {
     /// Perform deep copy-assignment from `source`.
     ///
     /// `a.deep_clone_from(&b)` is equivalent to `a = b.deep_clone()` in
-    /// functionality, but can be overriden to reuse the resources of `a` to
+    /// functionality, but can be overridden to reuse the resources of `a` to
     /// avoid unnecessary allocations.
     #[inline(always)]
     fn deep_clone_from(&mut self, source: &Self) {

src/libstd/condition.rs

@@ -81,7 +81,7 @@ pub struct Handler<T, U> {
 /// the condition (useful for debugging).
 ///
 /// This struct should never be created directly, but rather only through the
-/// `condition!` macro provided to all libraries using libstd.
+/// `condition!` macro provided to all libraries using `std`.
 pub struct Condition<T, U> {
     /// Name of the condition handler
     name: &'static str,

src/libstd/fmt/mod.rs

@@ -606,9 +606,9 @@ pub fn writeln(output: &mut io::Writer, args: &Arguments) {
 /// See the documentation for `format` for why this function is unsafe and care
 /// should be taken if calling it manually.
 ///
-/// Thankfully the rust compiler provides the macro `fmtf!` which will perform
-/// all of this validation at compile-time and provides a safe interface for
-/// invoking this function.
+/// Thankfully the rust compiler provides macros like `write!` and
+/// `format_args!` which perform all of this validation at compile-time
+/// and provide a safe interface for invoking this function.
 ///
 /// # Arguments
 ///

src/libstd/io/buffered.rs

@@ -202,8 +202,8 @@ impl<W: Writer> Decorator<W> for BufferedWriter<W> {
     fn inner_mut_ref<'a>(&'a mut self) -> &'a mut W { &mut self.inner }
 }
 
-/// Wraps a Writer and buffers output to it, flushing whenever a newline (0xa,
-/// '\n') is detected.
+/// Wraps a Writer and buffers output to it, flushing whenever a newline (`0x0a`,
+/// `'\n'`) is detected.
 ///
 /// Note that this structure does NOT flush the output when dropped.
 pub struct LineBufferedWriter<W> {

src/libstd/io/fs.rs

@@ -249,7 +249,7 @@ pub fn unlink(path: &Path) {
 /// directory, etc. This function will traverse symlinks to query
 /// information about the destination file.
 ///
-/// Returns a fully-filled out stat structure on succes, and on failure it
+/// Returns a fully-filled out stat structure on success, and on failure it
 /// will return a dummy stat structure (it is expected that the condition
 /// raised is handled as well).
 ///
@@ -342,7 +342,7 @@ pub fn rename(from: &Path, to: &Path) {
 ///
 /// # Errors
 ///
-/// Will raise an `io_error` condition is the following situtations, but is
+/// Will raise an `io_error` condition is the following situations, but is
 /// not limited to just these cases:
 ///
 /// * The `from` path is not a file
@@ -391,7 +391,7 @@ pub fn copy(from: &Path, to: &Path) {
 ///
 /// # Errors
 ///
-/// If this funciton encounters an I/O error, it will raise on the `io_error`
+/// If this function encounters an I/O error, it will raise on the `io_error`
 /// condition. Some possible error situations are not having the permission to
 /// change the attributes of a file or the file not existing.
 pub fn chmod(path: &Path, mode: io::FilePermission) {
@@ -402,7 +402,7 @@ pub fn chmod(path: &Path, mode: io::FilePermission) {
 ///
 /// # Errors
 ///
-/// This funtion will raise on the `io_error` condition on failure.
+/// This function will raise on the `io_error` condition on failure.
 pub fn chown(path: &Path, uid: int, gid: int) {
     io_raise(|io| io.fs_chown(&path.to_c_str(), uid, gid));
 }
@@ -448,7 +448,7 @@ pub fn readlink(path: &Path) -> Option<Path> {
 ///
 ///     let p = Path::new("/some/dir");
 ///     fs::mkdir(&p, S_IRWXU as int);
-///     // If we got here, our directory exists! Horray!
+///     // If we got here, our directory exists! Hooray!
 ///
 /// # Errors
 ///
@@ -665,7 +665,7 @@ impl path::Path {
         io::result(|| self.stat()).is_ok()
     }
 
-    /// Whether the underlying implemention (be it a file path, or something
+    /// Whether the underlying implementation (be it a file path, or something
     /// else) points at a "regular file" on the FS. Will return false for paths
     /// to non-existent locations or directories or other non-regular files
     /// (named pipes, etc).
@@ -680,7 +680,7 @@ impl path::Path {
         }
     }
 
-    /// Whether the underlying implemention (be it a file path,
+    /// Whether the underlying implementation (be it a file path,
     /// or something else) is pointing at a directory in the underlying FS.
     /// Will return false for paths to non-existent locations or if the item is
     /// not a directory (eg files, named pipes, links, etc)

src/libstd/io/mod.rs

@@ -835,7 +835,7 @@ pub trait Writer {
     /// Flush this output stream, ensuring that all intermediately buffered
     /// contents reach their destination.
     ///
-    /// This is by default a no-op and implementors of the `Writer` trait should
+    /// This is by default a no-op and implementers of the `Writer` trait should
     /// decide whether their stream needs to be buffered or not.
     fn flush(&mut self) {}
 
@@ -1057,7 +1057,7 @@ pub trait Buffer: Reader {
         }
     }
 
-    /// Reads a sequence of bytes leading up to a specified delimeter. Once the
+    /// Reads a sequence of bytes leading up to a specified delimiter. Once the
     /// specified byte is encountered, reading ceases and the bytes up to and
     /// including the delimiter are returned.
     ///
@@ -1156,7 +1156,7 @@ pub trait Seek {
 /// A listener is a value that can consume itself to start listening for connections.
 /// Doing so produces some sort of Acceptor.
 pub trait Listener<T, A: Acceptor<T>> {
-    /// Spin up the listener and start queueing incoming connections
+    /// Spin up the listener and start queuing incoming connections
     ///
     /// # Failure
     ///

src/libstd/io/native/process.rs

@@ -50,7 +50,7 @@ impl Process {
     /// * prog - the program to run
     /// * args - the arguments to pass to the program, not including the program
     ///          itself
-    /// * env - an optional envrionment to specify for the child process. If
+    /// * env - an optional environment to specify for the child process. If
     ///         this value is `None`, then the child will inherit the parent's
     ///         environment
     /// * cwd - an optionally specified current working directory of the child,

src/libstd/io/signal.rs

@@ -34,7 +34,7 @@ pub enum Signum {
     Break = 21i,
     /// Equivalent to SIGHUP, delivered when the user closes the terminal
     /// window. On delivery of HangUp, the program is given approximately
-    /// 10 seconds to perfom any cleanup. After that, Windows will
+    /// 10 seconds to perform any cleanup. After that, Windows will
     /// unconditionally terminate it.
     HangUp = 1i,
     /// Equivalent to SIGINT, delivered when the user presses Ctrl-c.

src/libstd/iter.rs

@@ -15,7 +15,7 @@ Composable external iterators
 # The `Iterator` trait
 
 This module defines Rust's core iteration trait. The `Iterator` trait has one
-un-implemented method, `next`. All other methods are derived through default
+unimplemented method, `next`. All other methods are derived through default
 methods to perform operations such as `zip`, `chain`, `enumerate`, and `fold`.
 
 The goal of this module is to unify iteration across all containers in Rust.
@@ -1688,7 +1688,7 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Fuse<T> {
 
 impl<T> Fuse<T> {
     /// Resets the fuse such that the next call to .next() or .next_back() will
-    /// call the underlying iterator again even if it prevously returned None.
+    /// call the underlying iterator again even if it previously returned None.
     #[inline]
     pub fn reset_fuse(&mut self) {
         self.done = false

src/libstd/local_data.rs

@@ -18,7 +18,7 @@ the TLS slot.  Useful for dynamic variables, singletons, and interfacing with
 foreign code with bad callback interfaces.
 
 To declare a new key for storing local data of a particular type, use the
-`local_data_key!` macro. This macro will expand to a `static` item apppriately
+`local_data_key!` macro. This macro will expand to a `static` item appropriately
 named and annotated. This name is then passed to the functions in this module to
 modify/read the slot specified by the key.
 

src/libstd/num/mod.rs

@@ -209,7 +209,7 @@ pub trait Fractional: Num
 pub trait Algebraic {
     /// Raise a number to a power.
     fn pow(&self, n: &Self) -> Self;
-    /// Take the squre root of a number.
+    /// Take the square root of a number.
     fn sqrt(&self) -> Self;
     /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
     fn rsqrt(&self) -> Self;
@@ -229,7 +229,7 @@ pub trait Algebraic {
 /// assert_eq!(sixteen, 16.0);
 /// ```
 #[inline(always)] pub fn pow<T: Algebraic>(value: T, n: T) -> T { value.pow(&n) }
-/// Take the squre root of a number.
+/// Take the square root of a number.
 #[inline(always)] pub fn sqrt<T: Algebraic>(value: T) -> T { value.sqrt() }
 /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
 #[inline(always)] pub fn rsqrt<T: Algebraic>(value: T) -> T { value.rsqrt() }

src/libstd/ops.rs

@@ -352,7 +352,7 @@ pub trait BitOr<RHS,Result> {
  * # Example
  *
  * A trivial implementation of `BitXor`. When `Foo ^ Foo` happens, it ends up
- * calling `bixtor`, and therefore, `main` prints `Bitwise Xor-ing!`.
+ * calling `bitxor`, and therefore, `main` prints `Bitwise Xor-ing!`.
  *
  * ```
  * struct Foo;

src/libstd/rand/distributions/mod.rs

@@ -45,7 +45,7 @@ pub trait Sample<Support> {
 
 /// `Sample`s that do not require keeping track of state.
 ///
-/// Since no state is recored, each sample is (statistically)
+/// Since no state is recorded, each sample is (statistically)
 /// independent of all others, assuming the `Rng` used has this
 /// property.
 // XXX maybe having this separate is overkill (the only reason is to
@@ -84,15 +84,15 @@ pub struct Weighted<T> {
 /// is to be chosen: higher weight is more likely.
 ///
 /// The `Clone` restriction is a limitation of the `Sample` and
-/// `IndepedentSample` traits. Note that `&T` is (cheaply) `Clone` for
+/// `IndependentSample` traits. Note that `&T` is (cheaply) `Clone` for
 /// all `T`, as is `uint`, so one can store references or indices into
 /// another vector.
 ///
 /// # Example
 ///
 /// ```rust
 /// use std::rand;
-/// use std::rand::distributions::{Weighted, WeightedChoice, IndepedentSample};
+/// use std::rand::distributions::{Weighted, WeightedChoice, IndependentSample};
 ///
 /// fn main() {
 ///     let wc = WeightedChoice::new(~[Weighted { weight: 2, item: 'a' },

src/libstd/rand/mod.rs

@@ -119,7 +119,7 @@ pub trait Rng {
     /// Fill `dest` with random data.
     ///
     /// This has a default implementation in terms of `next_u64` and
-    /// `next_u32`, but should be overriden by implementations that
+    /// `next_u32`, but should be overridden by implementations that
     /// offer a more efficient solution than just calling those
     /// methods repeatedly.
     ///

src/libstd/rt/sched.rs

@@ -75,7 +75,7 @@ pub struct Scheduler {
     friend_handle: Option<SchedHandle>,
     /// A fast XorShift rng for scheduler use
     rng: XorShiftRng,
-    /// A toggleable idle callback
+    /// A togglable idle callback
     idle_callback: Option<~PausibleIdleCallback>,
     /// A countdown that starts at a random value and is decremented
     /// every time a yield check is performed. When it hits 0 a task

src/libstd/str.rs

@@ -963,10 +963,9 @@ pub fn utf8_char_width(b: u8) -> uint {
     return UTF8_CHAR_WIDTH[b] as uint;
 }
 
-/// Struct that contains a `char` and
-/// the index of the first byte of the next `char` in a string.
-/// This is being used as a datastructure for iterating over
-/// the utf8 bytes of a string.
+/// Struct that contains a `char` and the index of the first byte of
+/// the next `char` in a string.  This can be used as a data structure
+/// for iterating over the UTF-8 bytes of a string.
 pub struct CharRange {
     /// Current `char`
     ch: char,
@@ -1570,7 +1569,8 @@ pub trait StrSlice<'a> {
     /// ```
     fn is_whitespace(&self) -> bool;
 
-    /// Returns true if the string contains only alphanumerics.
+    /// Returns true if the string contains only alphanumeric code
+    /// points.
     ///
     /// Alphanumeric characters are determined by `char::is_alphanumeric`.
     ///
@@ -2518,7 +2518,7 @@ impl<'a> StrSlice<'a> for &'a str {
 
 /// Methods for owned strings
 pub trait OwnedStr {
-    /// Appends a string slice to the back of a string, without overallocating
+    /// Appends a string slice to the back of a string, without overallocating.
     fn push_str_no_overallocate(&mut self, rhs: &str);
 
     /// Appends a string slice to the back of a string

src/libstd/unstable/mutex.rs

@@ -37,7 +37,7 @@
 //!         lock.unlock();
 //!     }
 //!
-//!     // Use a normally initialied mutex
+//!     // Use a normally initialized mutex
 //!     let mut lock = Mutex::new();
 //!     unsafe {
 //!         lock.lock();

src/libstd/vec.rs

@@ -402,7 +402,7 @@ pub fn unzip<T, U, V: Iterator<(T, U)>>(mut iter: V) -> (~[T], ~[U]) {
 ///
 /// The Steinhaus–Johnson–Trotter algorithm is used.
 ///
-/// Generates even and odd permutations alternatingly.
+/// Generates even and odd permutations alternately.
 ///
 /// The last generated swap is always (0, 1), and it returns the
 /// sequence to its initial order.
@@ -480,7 +480,7 @@ impl Iterator<(uint, uint)> for ElementSwaps {
 /// then each successive element is the vector with one
 /// swap applied.
 ///
-/// Generates even and odd permutations alternatingly.
+/// Generates even and odd permutations alternately.
 pub struct Permutations<T> {
     priv swaps: ElementSwaps,
     priv v: ~[T],
@@ -940,7 +940,7 @@ pub trait ImmutableVector<'a, T> {
     fn tailn(&self, n: uint) -> &'a [T];
     /// Returns all but the last element of a vector
     fn init(&self) -> &'a [T];
-    /// Returns all but the last `n' elemnts of a vector
+    /// Returns all but the last `n' elements of a vector
     fn initn(&self, n: uint) -> &'a [T];
     /// Returns the last element of a vector, failing if the vector is empty.
     fn last(&self) -> &'a T;
@@ -958,9 +958,10 @@ pub trait ImmutableVector<'a, T> {
     /**
      * Binary search a sorted vector with a comparator function.
      *
-     * The comparator should implement an order consistent with the sort
-     * order of the underlying vector, returning an order code that indicates
-     * whether its argument is `Less`, `Equal` or `Greater` the desired target.
+     * The comparator function should implement an order consistent
+     * with the sort order of the underlying vector, returning an
+     * order code that indicates whether its argument is `Less`,
+     * `Equal` or `Greater` the desired target.
      *
      * Returns the index where the comparator returned `Equal`, or `None` if
      * not found.
@@ -1436,14 +1437,14 @@ pub trait OwnedVector<T> {
 
     /**
      * Expands a vector in place, initializing the new elements to the result of
-     * a function
+     * a function.
      *
      * Function `init_op` is called `n` times with the values [0..`n`)
      *
      * # Arguments
      *
      * * n - The number of elements to add
-     * * init_op - A function to call to retreive each appended element's
+     * * init_op - A function to call to retrieve each appended element's
      *             value
      */
     fn grow_fn(&mut self, n: uint, op: |uint| -> T);