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.