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

3 files changed, 19 insertions, 19 deletions

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<SchedHandle>,
     /// 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();