auto merge of #10974 : huonw/rust/spellck, r=alexcrichton

Author: bors

src/libextra/arc.rs

@@ -276,7 +276,7 @@ impl<T:Freeze + Send> MutexArc<T> {
      * might contain nested MutexArcs inside.
      *
      * The purpose of this is to offer a safe implementation of MutexArc to be
-     * used instead of RWArc in cases where no readers are needed and sightly
+     * used instead of RWArc in cases where no readers are needed and slightly
      * better performance is required.
      *
      * Both methods have the same failure behaviour as unsafe_access and

src/libextra/getopts.rs

@@ -30,7 +30,7 @@
 //! file name following `-o`, and accepts both `-h` and `--help` as optional flags.
 //!
 //! ~~~{.rust}
-//! exter mod extra;
+//! extern mod extra;
 //! use extra::getopts::*;
 //! use std::os;
 //!
@@ -114,7 +114,7 @@ pub enum Occur {
 pub struct Opt {
     /// Name of the option
     name: Name,
-    /// Wheter it has an argument
+    /// Whether it has an argument
     hasarg: HasArg,
     /// How often it can occur
     occur: Occur,
@@ -154,7 +154,7 @@ pub enum Fail_ {
     UnexpectedArgument(~str),
 }
 
-/// The type of failure that occured.
+/// The type of failure that occurred.
 #[deriving(Eq)]
 #[allow(missing_doc)]
 pub enum FailType {

src/libextra/tempfile.rs

@@ -18,7 +18,7 @@ use std::io;
 use std::io::fs;
 
 /// A wrapper for a path to temporary directory implementing automatic
-/// scope-pased deletion.
+/// scope-based deletion.
 pub struct TempDir {
     priv path: Option<Path>
 }

src/libextra/uuid.rs

@@ -17,7 +17,7 @@ identifiers to entities without requiring a central allocating authority.
 
 They are particularly useful in distributed systems, though can be used in
 disparate areas, such as databases and network protocols.  Typically a UUID is
-displayed in a readable string form as a sequence of hexadecimals digits,
+displayed in a readable string form as a sequence of hexadecimal digits,
 separated into groups by hyphens.
 
 The uniqueness property is not strictly guaranteed, however for all practical
@@ -89,11 +89,11 @@ pub enum UuidVersion {
 /// The reserved variants of UUIDs
 #[deriving(Eq)]
 pub enum UuidVariant {
-    /// Reserved by the NCS for backward compatability
+    /// Reserved by the NCS for backward compatibility
     VariantNCS,
     /// As described in the RFC4122 Specification (default)
     VariantRFC4122,
-    /// Resreved by Microsoft for backward compatability
+    /// Reserved by Microsoft for backward compatibility
     VariantMicrosoft,
     /// Reserved for future expansion
     VariantFuture,
@@ -313,7 +313,7 @@ impl Uuid {
         str::from_utf8_owned(s)
     }
 
-    /// Returns a string of hexadecimal digits, separated into groups with a hypen
+    /// Returns a string of hexadecimal digits, separated into groups with a hyphen.
     ///
     /// Example: `550e8400-e29b-41d4-a716-446655440000`
     pub fn to_hyphenated_str(&self) -> ~str {

src/librustuv/idle.rs

@@ -13,7 +13,7 @@ use std::libc::{c_int, c_void};
 
 use uvll;
 use super::{Loop, UvHandle};
-use std::rt::rtio::{Callback, PausibleIdleCallback};
+use std::rt::rtio::{Callback, PausableIdleCallback};
 
 pub struct IdleWatcher {
     handle: *uvll::uv_idle_t,
@@ -63,7 +63,7 @@ impl IdleWatcher {
     }
 }
 
-impl PausibleIdleCallback for IdleWatcher {
+impl PausableIdleCallback for IdleWatcher {
     fn pause(&mut self) {
         if self.idle_flag == true {
             assert_eq!(unsafe {uvll::uv_idle_stop(self.handle) }, 0);
@@ -99,7 +99,7 @@ impl Drop for IdleWatcher {
 mod test {
     use super::*;
     use std::rt::tube::Tube;
-    use std::rt::rtio::{Callback, PausibleIdleCallback};
+    use std::rt::rtio::{Callback, PausableIdleCallback};
     use super::super::local_loop;
 
     struct MyCallback(Tube<int>, int);

src/librustuv/uvio.rs

@@ -153,8 +153,8 @@ impl EventLoop for UvEventLoop {
         IdleWatcher::onetime(self.uvio.uv_loop(), f);
     }
 
-    fn pausible_idle_callback(&mut self, cb: ~Callback) -> ~PausibleIdleCallback {
-        IdleWatcher::new(self.uvio.uv_loop(), cb) as ~PausibleIdleCallback
+    fn pausable_idle_callback(&mut self, cb: ~Callback) -> ~PausableIdleCallback {
+        IdleWatcher::new(self.uvio.uv_loop(), cb) as ~PausableIdleCallback
     }
 
     fn remote_callback(&mut self, f: ~Callback) -> ~RemoteCallback {

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.
     ///