diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs index 6389e3fdab0..5700a299945 100644 --- a/src/libextra/arc.rs +++ b/src/libextra/arc.rs @@ -276,7 +276,7 @@ impl MutexArc { * 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 diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs index ad5df00a2fe..11afff16825 100644 --- a/src/libextra/getopts.rs +++ b/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 { diff --git a/src/libextra/tempfile.rs b/src/libextra/tempfile.rs index d305b3f3b24..c9ea556f23a 100644 --- a/src/libextra/tempfile.rs +++ b/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 } diff --git a/src/libextra/uuid.rs b/src/libextra/uuid.rs index 0fbac7771dc..3af76a1e3d8 100644 --- a/src/libextra/uuid.rs +++ b/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 { diff --git a/src/librustuv/idle.rs b/src/librustuv/idle.rs index 80481498881..32c7699a308 100644 --- a/src/librustuv/idle.rs +++ b/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); diff --git a/src/librustuv/uvio.rs b/src/librustuv/uvio.rs index e0011398aa1..c556b96671a 100644 --- a/src/librustuv/uvio.rs +++ b/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 { diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs index 280c79f1fd4..cf886fbebe1 100644 --- a/src/libstd/cell.rs +++ b/src/libstd/cell.rs @@ -81,7 +81,7 @@ impl RefCell { /// 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 RefCell { /// 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 diff --git a/src/libstd/char.rs b/src/libstd/char.rs index 3019e47c9f9..93667bb6225 100644 --- a/src/libstd/char.rs +++ b/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); diff --git a/src/libstd/clone.rs b/src/libstd/clone.rs index 95d75138082..6bff438bbc6 100644 --- a/src/libstd/clone.rs +++ b/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) { diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs index df5154123f2..1a4e9226ee8 100644 --- a/src/libstd/condition.rs +++ b/src/libstd/condition.rs @@ -81,7 +81,7 @@ pub struct Handler { /// 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 { /// Name of the condition handler name: &'static str, diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs index a98a110ac3b..b4f30311753 100644 --- a/src/libstd/fmt/mod.rs +++ b/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 /// diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 04f4d50036f..365866872ec 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -202,8 +202,8 @@ impl Decorator for BufferedWriter { 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 { diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index 5bfdf685bea..a1465ca7b33 100644 --- a/src/libstd/io/fs.rs +++ b/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 { /// /// 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) diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index c5ae6457515..1024f28f379 100644 --- a/src/libstd/io/mod.rs +++ b/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> { - /// Spin up the listener and start queueing incoming connections + /// Spin up the listener and start queuing incoming connections /// /// # Failure /// diff --git a/src/libstd/io/native/process.rs b/src/libstd/io/native/process.rs index 1b614852737..a1f50b15f23 100644 --- a/src/libstd/io/native/process.rs +++ b/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, diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs index 43659d24c35..3b6c6013dd2 100644 --- a/src/libstd/io/signal.rs +++ b/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. diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs index 3a7f8ab8629..5fbb09eadcb 100644 --- a/src/libstd/iter.rs +++ b/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> RandomAccessIterator for Fuse { impl Fuse { /// 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 diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index 335bbc8b1da..c75e7dde251 100644 --- a/src/libstd/local_data.rs +++ b/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. diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 79efe5934d5..c8c2ea8af81 100644 --- a/src/libstd/num/mod.rs +++ b/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(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(value: T) -> T { value.sqrt() } /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. #[inline(always)] pub fn rsqrt(value: T) -> T { value.rsqrt() } diff --git a/src/libstd/ops.rs b/src/libstd/ops.rs index cdc63608122..5bce884448a 100644 --- a/src/libstd/ops.rs +++ b/src/libstd/ops.rs @@ -352,7 +352,7 @@ pub trait BitOr { * # 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; diff --git a/src/libstd/rand/distributions/mod.rs b/src/libstd/rand/distributions/mod.rs index a381ac35d30..dd882f051d3 100644 --- a/src/libstd/rand/distributions/mod.rs +++ b/src/libstd/rand/distributions/mod.rs @@ -45,7 +45,7 @@ pub trait Sample { /// `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,7 +84,7 @@ pub struct Weighted { /// 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. /// @@ -92,7 +92,7 @@ pub struct Weighted { /// /// ```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' }, diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 32c2402f39b..e3929501e19 100644 --- a/src/libstd/rand/mod.rs +++ b/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. /// diff --git a/src/libstd/rt/basic.rs b/src/libstd/rt/basic.rs index fa47ceb1c04..3589582357c 100644 --- a/src/libstd/rt/basic.rs +++ b/src/libstd/rt/basic.rs @@ -15,7 +15,7 @@ use prelude::*; use cast; -use rt::rtio::{EventLoop, IoFactory, RemoteCallback, PausibleIdleCallback, +use rt::rtio::{EventLoop, IoFactory, RemoteCallback, PausableIdleCallback, Callback}; use unstable::sync::Exclusive; use io::native; @@ -28,7 +28,7 @@ pub fn event_loop() -> ~EventLoop { struct BasicLoop { work: ~[proc()], // pending work - idle: Option<*mut BasicPausible>, // only one is allowed + idle: Option<*mut BasicPausable>, // only one is allowed remotes: ~[(uint, ~Callback)], next_remote: uint, messages: Exclusive<~[Message]>, @@ -142,14 +142,14 @@ impl EventLoop for BasicLoop { } // XXX: Seems like a really weird requirement to have an event loop provide. - fn pausible_idle_callback(&mut self, cb: ~Callback) -> ~PausibleIdleCallback { - let callback = ~BasicPausible::new(self, cb); + fn pausable_idle_callback(&mut self, cb: ~Callback) -> ~PausableIdleCallback { + let callback = ~BasicPausable::new(self, cb); rtassert!(self.idle.is_none()); unsafe { - let cb_ptr: &*mut BasicPausible = cast::transmute(&callback); + let cb_ptr: &*mut BasicPausable = cast::transmute(&callback); self.idle = Some(*cb_ptr); } - return callback as ~PausibleIdleCallback; + return callback as ~PausableIdleCallback; } fn remote_callback(&mut self, f: ~Callback) -> ~RemoteCallback { @@ -196,15 +196,15 @@ impl Drop for BasicRemote { } } -struct BasicPausible { +struct BasicPausable { eloop: *mut BasicLoop, work: ~Callback, active: bool, } -impl BasicPausible { - fn new(eloop: &mut BasicLoop, cb: ~Callback) -> BasicPausible { - BasicPausible { +impl BasicPausable { + fn new(eloop: &mut BasicLoop, cb: ~Callback) -> BasicPausable { + BasicPausable { active: false, work: cb, eloop: eloop, @@ -212,7 +212,7 @@ impl BasicPausible { } } -impl PausibleIdleCallback for BasicPausible { +impl PausableIdleCallback for BasicPausable { fn pause(&mut self) { self.active = false; } @@ -221,7 +221,7 @@ impl PausibleIdleCallback for BasicPausible { } } -impl Drop for BasicPausible { +impl Drop for BasicPausable { fn drop(&mut self) { unsafe { (*self.eloop).idle = None; diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs index 05cc051a23e..557d9c998ca 100644 --- a/src/libstd/rt/rtio.rs +++ b/src/libstd/rt/rtio.rs @@ -35,7 +35,7 @@ pub trait Callback { pub trait EventLoop { fn run(&mut self); fn callback(&mut self, proc()); - fn pausible_idle_callback(&mut self, ~Callback) -> ~PausibleIdleCallback; + fn pausable_idle_callback(&mut self, ~Callback) -> ~PausableIdleCallback; fn remote_callback(&mut self, ~Callback) -> ~RemoteCallback; /// The asynchronous I/O services. Not all event loops may provide one. @@ -265,7 +265,7 @@ pub trait RtioTTY { fn isatty(&self) -> bool; } -pub trait PausibleIdleCallback { +pub trait PausableIdleCallback { fn pause(&mut self); fn resume(&mut self); } diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs index eefed412466..fa17efc833b 100644 --- a/src/libstd/rt/sched.rs +++ b/src/libstd/rt/sched.rs @@ -22,7 +22,7 @@ use rt::kill::BlockedTask; use rt::deque; use rt::local_ptr; use rt::local::Local; -use rt::rtio::{RemoteCallback, PausibleIdleCallback, Callback}; +use rt::rtio::{RemoteCallback, PausableIdleCallback, Callback}; use borrow::{to_uint}; use rand::{XorShiftRng, Rng, Rand}; use iter::range; @@ -75,8 +75,8 @@ pub struct Scheduler { friend_handle: Option, /// A fast XorShift rng for scheduler use rng: XorShiftRng, - /// A toggleable idle callback - idle_callback: Option<~PausibleIdleCallback>, + /// A togglable idle callback + idle_callback: Option<~PausableIdleCallback>, /// A countdown that starts at a random value and is decremented /// every time a yield check is performed. When it hits 0 a task /// will yield. @@ -86,7 +86,7 @@ pub struct Scheduler { steal_for_yield: bool, // n.b. currently destructors of an object are run in top-to-bottom in order - // of field declaration. Due to its nature, the pausible idle callback + // of field declaration. Due to its nature, the pausable idle callback // must have some sort of handle to the event loop, so it needs to get // destroyed before the event loop itself. For this reason, we destroy // the event loop last to ensure that any unsafe references to it are @@ -170,7 +170,7 @@ impl Scheduler { // Build an Idle callback. let cb = ~SchedRunner as ~Callback; - self.idle_callback = Some(self.event_loop.pausible_idle_callback(cb)); + self.idle_callback = Some(self.event_loop.pausable_idle_callback(cb)); // Initialize the TLS key. local_ptr::init(); diff --git a/src/libstd/str.rs b/src/libstd/str.rs index af381ef3cf0..caf0b535e05 100644 --- a/src/libstd/str.rs +++ b/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 diff --git a/src/libstd/unstable/mutex.rs b/src/libstd/unstable/mutex.rs index ff46824d823..3e7a861b385 100644 --- a/src/libstd/unstable/mutex.rs +++ b/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(); diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index c31e3b56444..fbfd9accd0d 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -402,7 +402,7 @@ pub fn unzip>(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 { 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 { /** * 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);