Simplify RawReader interface
diff --git a/src/keymap.rs b/src/keymap.rs
index 1d9b662..3c631da 100644
--- a/src/keymap.rs
+++ b/src/keymap.rs
@@ -125,18 +125,17 @@
         self.mode == EditMode::Emacs
     }
 
-    pub fn next_cmd<R: RawReader>(&mut self, rdr: &mut R, config: &Config) -> Result<Cmd> {
+    pub fn next_cmd<R: RawReader>(&mut self, rdr: &mut R) -> Result<Cmd> {
         match self.mode {
-            EditMode::Emacs => self.emacs(rdr, config),
-            EditMode::Vi if self.insert => self.vi_insert(rdr, config),
-            EditMode::Vi => self.vi_command(rdr, config),
+            EditMode::Emacs => self.emacs(rdr),
+            EditMode::Vi if self.insert => self.vi_insert(rdr),
+            EditMode::Vi => self.vi_command(rdr),
         }
     }
 
     // TODO dynamic prompt (arg: ?)
     fn emacs_digit_argument<R: RawReader>(&mut self,
                                           rdr: &mut R,
-                                          config: &Config,
                                           digit: char)
                                           -> Result<KeyPress> {
         match digit {
@@ -149,7 +148,7 @@
             _ => unreachable!(),
         }
         loop {
-            let key = try!(rdr.next_key(config.keyseq_timeout()));
+            let key = try!(rdr.next_key());
             match key {
                 KeyPress::Char(digit @ '0'...'9') |
                 KeyPress::Meta(digit @ '0'...'9') => {
@@ -166,12 +165,12 @@
         }
     }
 
-    fn emacs<R: RawReader>(&mut self, rdr: &mut R, config: &Config) -> Result<Cmd> {
-        let mut key = try!(rdr.next_key(config.keyseq_timeout()));
+    fn emacs<R: RawReader>(&mut self, rdr: &mut R) -> Result<Cmd> {
+        let mut key = try!(rdr.next_key());
         if let KeyPress::Meta(digit @ '-') = key {
-            key = try!(self.emacs_digit_argument(rdr, config, digit));
+            key = try!(self.emacs_digit_argument(rdr, digit));
         } else if let KeyPress::Meta(digit @ '0'...'9') = key {
-            key = try!(self.emacs_digit_argument(rdr, config, digit));
+            key = try!(self.emacs_digit_argument(rdr, digit));
         }
         let (n, positive) = self.emacs_num_args(); // consume them in all cases
         let cmd = match key {
@@ -220,7 +219,7 @@
             KeyPress::Ctrl('N') => Cmd::NextHistory,
             KeyPress::Ctrl('P') => Cmd::PreviousHistory,
             KeyPress::Ctrl('X') => {
-                let snd_key = try!(rdr.next_key(config.keyseq_timeout()));
+                let snd_key = try!(rdr.next_key());
                 match snd_key {
                     KeyPress::Ctrl('G') => Cmd::Abort,
                     KeyPress::Ctrl('U') => Cmd::Undo,
@@ -272,12 +271,11 @@
 
     fn vi_arg_digit<R: RawReader>(&mut self,
                                   rdr: &mut R,
-                                  config: &Config,
                                   digit: char)
                                   -> Result<KeyPress> {
         self.num_args = digit.to_digit(10).unwrap() as i16;
         loop {
-            let key = try!(rdr.next_key(config.keyseq_timeout()));
+            let key = try!(rdr.next_key());
             match key {
                 KeyPress::Char(digit @ '0'...'9') => {
                     self.num_args = self.num_args
@@ -289,10 +287,10 @@
         }
     }
 
-    fn vi_command<R: RawReader>(&mut self, rdr: &mut R, config: &Config) -> Result<Cmd> {
-        let mut key = try!(rdr.next_key(config.keyseq_timeout()));
+    fn vi_command<R: RawReader>(&mut self, rdr: &mut R) -> Result<Cmd> {
+        let mut key = try!(rdr.next_key());
         if let KeyPress::Char(digit @ '1'...'9') = key {
-            key = try!(self.vi_arg_digit(rdr, config, digit));
+            key = try!(self.vi_arg_digit(rdr, digit));
         }
         let n = self.vi_num_args(); // consume them in all cases
         let cmd = match key {
@@ -316,7 +314,7 @@
             KeyPress::Char('B') => Cmd::BackwardWord(n, Word::Big),
             KeyPress::Char('c') => {
                 self.insert = true;
-                match try!(self.vi_cmd_motion(rdr, config, key, n)) {
+                match try!(self.vi_cmd_motion(rdr, key, n)) {
                     Some(mvt) => Cmd::Kill(mvt),
                     None => Cmd::Unknown,
                 }
@@ -326,7 +324,7 @@
                 Cmd::Kill(Movement::EndOfLine)
             }
             KeyPress::Char('d') => {
-                match try!(self.vi_cmd_motion(rdr, config, key, n)) {
+                match try!(self.vi_cmd_motion(rdr, key, n)) {
                     Some(mvt) => Cmd::Kill(mvt),
                     None => Cmd::Unknown,
                 }
@@ -347,7 +345,7 @@
             }
             KeyPress::Char(c) if c == 'f' || c == 'F' || c == 't' || c == 'T' => {
                 // vi-char-search
-                let cs = try!(self.vi_char_search(rdr, config, c));
+                let cs = try!(self.vi_char_search(rdr, c));
                 match cs {
                     Some(cs) => Cmd::ViCharSearch(n, cs),
                     None => Cmd::Unknown,
@@ -370,7 +368,7 @@
             KeyPress::Char('P') => Cmd::Yank(n, Anchor::Before), // vi-put
             KeyPress::Char('r') => {
                 // vi-replace-char: Vi replace character under the cursor with the next character typed.
-                let ch = try!(rdr.next_key(config.keyseq_timeout()));
+                let ch = try!(rdr.next_key());
                 match ch {
                     KeyPress::Char(c) => Cmd::Replace(n, c),
                     KeyPress::Esc => Cmd::Noop,
@@ -395,7 +393,7 @@
             KeyPress::Char('x') => Cmd::Kill(Movement::ForwardChar(n)), // vi-delete: TODO move backward if eol
             KeyPress::Char('X') => Cmd::Kill(Movement::BackwardChar(n)), // vi-rubout
             KeyPress::Char('y') => {
-                match try!(self.vi_cmd_motion(rdr, config, key, n)) {
+                match try!(self.vi_cmd_motion(rdr, key, n)) {
                     Some(mvt) => Cmd::ViYankTo(mvt),
                     None => Cmd::Unknown,
                 }
@@ -429,8 +427,8 @@
         Ok(cmd)
     }
 
-    fn vi_insert<R: RawReader>(&mut self, rdr: &mut R, config: &Config) -> Result<Cmd> {
-        let key = try!(rdr.next_key(config.keyseq_timeout()));
+    fn vi_insert<R: RawReader>(&mut self, rdr: &mut R) -> Result<Cmd> {
+        let key = try!(rdr.next_key());
         let cmd = match key {
             KeyPress::Char(c) => Cmd::SelfInsert(1, c),
             KeyPress::Ctrl('H') |
@@ -449,18 +447,17 @@
 
     fn vi_cmd_motion<R: RawReader>(&mut self,
                                    rdr: &mut R,
-                                   config: &Config,
                                    key: KeyPress,
                                    n: RepeatCount)
                                    -> Result<Option<Movement>> {
-        let mut mvt = try!(rdr.next_key(config.keyseq_timeout()));
+        let mut mvt = try!(rdr.next_key());
         if mvt == key {
             return Ok(Some(Movement::WholeLine));
         }
         let mut n = n;
         if let KeyPress::Char(digit @ '1'...'9') = mvt {
             // vi-arg-digit
-            mvt = try!(self.vi_arg_digit(rdr, config, digit));
+            mvt = try!(self.vi_arg_digit(rdr, digit));
             n = self.vi_num_args().saturating_mul(n);
         }
         Ok(match mvt {
@@ -471,7 +468,7 @@
             KeyPress::Char('e') => Some(Movement::ForwardWord(n, At::AfterEnd, Word::Vi)),
             KeyPress::Char('E') => Some(Movement::ForwardWord(n, At::AfterEnd, Word::Big)),
             KeyPress::Char(c) if c == 'f' || c == 'F' || c == 't' || c == 'T' => {
-                let cs = try!(self.vi_char_search(rdr, config, c));
+                let cs = try!(self.vi_char_search(rdr, c));
                 match cs {
                     Some(cs) => Some(Movement::ViCharSearch(n, cs)),
                     None => None,
@@ -516,10 +513,9 @@
 
     fn vi_char_search<R: RawReader>(&mut self,
                                     rdr: &mut R,
-                                    config: &Config,
                                     cmd: char)
                                     -> Result<Option<CharSearch>> {
-        let ch = try!(rdr.next_key(config.keyseq_timeout()));
+        let ch = try!(rdr.next_key());
         Ok(match ch {
             KeyPress::Char(ch) => {
                 let cs = match cmd {
diff --git a/src/lib.rs b/src/lib.rs
index 5640729..71be64d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -114,9 +114,9 @@
         }
     }
 
-    fn next_cmd<R: RawReader>(&mut self, rdr: &mut R, config: &Config) -> Result<Cmd> {
+    fn next_cmd<R: RawReader>(&mut self, rdr: &mut R) -> Result<Cmd> {
         loop {
-            let rc = self.edit_state.next_cmd(rdr, config);
+            let rc = self.edit_state.next_cmd(rdr);
             if rc.is_err() && self.term.sigwinch() {
                 self.update_columns();
                 try!(self.refresh_line());
@@ -613,7 +613,7 @@
                 s.snapshot();
             }
 
-            cmd = try!(s.next_cmd(rdr, config));
+            cmd = try!(s.next_cmd(rdr));
             match cmd {
                 Cmd::Complete => {
                     i = (i + 1) % (candidates.len() + 1); // Circular
@@ -652,7 +652,7 @@
             }
         }
         // we can't complete any further, wait for second tab
-        let mut cmd = try!(s.next_cmd(rdr, config));
+        let mut cmd = try!(s.next_cmd(rdr));
         // if any character other than tab, pass it to the main loop
         if cmd != Cmd::Complete {
             return Ok(Some(cmd));
@@ -671,7 +671,7 @@
                   cmd != Cmd::SelfInsert(1, 'n') &&
                   cmd != Cmd::SelfInsert(1, 'N') &&
                   cmd != Cmd::Kill(Movement::BackwardChar(1)) {
-                cmd = try!(s.next_cmd(rdr, config));
+                cmd = try!(s.next_cmd(rdr));
             }
             show_completions = match cmd {
                 Cmd::SelfInsert(1, 'y') |
@@ -680,7 +680,7 @@
             };
         }
         if show_completions {
-            page_completions(rdr, s, config, &candidates)
+            page_completions(rdr, s, &candidates)
         } else {
             try!(s.refresh_line());
             Ok(None)
@@ -692,7 +692,6 @@
 
 fn page_completions<R: RawReader>(rdr: &mut R,
                                   s: &mut State,
-                                  config: &Config,
                                   candidates: &[String])
                                   -> Result<Option<Cmd>> {
     use std::cmp;
@@ -720,7 +719,7 @@
                   cmd != Cmd::SelfInsert(1, ' ') &&
                   cmd != Cmd::Kill(Movement::BackwardChar(1)) &&
                   cmd != Cmd::AcceptLine {
-                cmd = try!(s.next_cmd(rdr, config));
+                cmd = try!(s.next_cmd(rdr));
             }
             match cmd {
                 Cmd::SelfInsert(1, 'y') |
@@ -761,8 +760,7 @@
 /// Incremental search
 fn reverse_incremental_search<R: RawReader>(rdr: &mut R,
                                             s: &mut State,
-                                            history: &History,
-                                            config: &Config)
+                                            history: &History)
                                             -> Result<Option<Cmd>> {
     if history.is_empty() {
         return Ok(None);
@@ -785,7 +783,7 @@
         };
         try!(s.refresh_prompt_and_line(&prompt));
 
-        cmd = try!(s.next_cmd(rdr, config));
+        cmd = try!(s.next_cmd(rdr));
         if let Cmd::SelfInsert(_, c) = cmd {
             search_buf.push(c);
         } else {
@@ -855,10 +853,10 @@
                            editor.history.len());
     try!(s.refresh_line());
 
-    let mut rdr = try!(s.term.create_reader());
+    let mut rdr = try!(s.term.create_reader(&editor.config));
 
     loop {
-        let rc = s.next_cmd(&mut rdr, &editor.config);
+        let rc = s.next_cmd(&mut rdr);
         let mut cmd = try!(rc);
 
         // autocomplete
@@ -881,7 +879,7 @@
         if cmd == Cmd::ReverseSearchHistory {
             // Search history backward
             let next =
-                try!(reverse_incremental_search(&mut rdr, &mut s, &editor.history, &editor.config));
+                try!(reverse_incremental_search(&mut rdr, &mut s, &editor.history));
             if next.is_some() {
                 cmd = next.unwrap();
             } else {
diff --git a/src/tty/mod.rs b/src/tty/mod.rs
index 06a11c3..fe3ac99 100644
--- a/src/tty/mod.rs
+++ b/src/tty/mod.rs
@@ -1,6 +1,7 @@
 //! This module implements and describes common TTY methods & traits
 use std::io::Write;
 use Result;
+use config::Config;
 use consts::KeyPress;
 
 /// Terminal state
@@ -12,7 +13,7 @@
 /// Translate bytes read from stdin to keys.
 pub trait RawReader: Sized {
     /// Blocking read of key pressed.
-    fn next_key(&mut self, timeout_ms: i32) -> Result<KeyPress>;
+    fn next_key(&mut self) -> Result<KeyPress>;
     /// For CTRL-V support
     #[cfg(unix)]
     fn next_char(&mut self) -> Result<char>;
@@ -38,7 +39,7 @@
     /// Enable RAW mode for the terminal.
     fn enable_raw_mode(&self) -> Result<Self::Mode>;
     /// Create a RAW reader
-    fn create_reader(&self) -> Result<Self::Reader>;
+    fn create_reader(&self, config: &Config) -> Result<Self::Reader>;
     /// Create a writer
     fn create_writer(&self) -> Self::Writer;
     /// Clear the screen. Used to handle ctrl+l
diff --git a/src/tty/test.rs b/src/tty/test.rs
index 592773d..8813fa5 100644
--- a/src/tty/test.rs
+++ b/src/tty/test.rs
@@ -7,6 +7,7 @@
 #[cfg(windows)]
 use winapi;
 
+use config::Config;
 use consts::KeyPress;
 use error::ReadlineError;
 use Result;
@@ -21,7 +22,7 @@
 }
 
 impl<'a> RawReader for Iter<'a, KeyPress> {
-    fn next_key(&mut self, _: i32) -> Result<KeyPress> {
+    fn next_key(&mut self) -> Result<KeyPress> {
         match self.next() {
             Some(key) => Ok(*key),
             None => Err(ReadlineError::Eof),
@@ -34,7 +35,7 @@
 }
 
 impl RawReader for IntoIter<KeyPress> {
-    fn next_key(&mut self, _: i32) -> Result<KeyPress> {
+    fn next_key(&mut self) -> Result<KeyPress> {
         match self.next() {
             Some(key) => Ok(key),
             None => Err(ReadlineError::Eof),
@@ -131,7 +132,7 @@
     }
 
     /// Create a RAW reader
-    fn create_reader(&self) -> Result<IntoIter<KeyPress>> {
+    fn create_reader(&self, _: &Config) -> Result<IntoIter<KeyPress>> {
         Ok(self.keys.clone().into_iter())
     }
 
diff --git a/src/tty/unix.rs b/src/tty/unix.rs
index 258cf84..5691f44 100644
--- a/src/tty/unix.rs
+++ b/src/tty/unix.rs
@@ -9,6 +9,7 @@
 use nix::sys::signal;
 use nix::sys::termios;
 
+use config::Config;
 use consts::{self, KeyPress};
 use Result;
 use error;
@@ -92,12 +93,13 @@
 /// Console input reader
 pub struct PosixRawReader {
     chars: Chars<StdinRaw>,
+    timeout_ms: i32,
 }
 
 impl PosixRawReader {
-    fn new() -> Result<PosixRawReader> {
+    fn new(config: &Config) -> Result<PosixRawReader> {
         let stdin = StdinRaw {};
-        Ok(PosixRawReader { chars: stdin.chars() })
+        Ok(PosixRawReader { chars: stdin.chars(), timeout_ms: config.keyseq_timeout() })
     }
 
     fn escape_sequence(&mut self) -> Result<KeyPress> {
@@ -183,14 +185,14 @@
 }
 
 impl RawReader for PosixRawReader {
-    fn next_key(&mut self, timeout_ms: i32) -> Result<KeyPress> {
+    fn next_key(&mut self) -> Result<KeyPress> {
         let c = try!(self.next_char());
 
         let mut key = consts::char_to_key_press(c);
         if key == KeyPress::Esc {
             let mut fds =
                 [poll::PollFd::new(STDIN_FILENO, poll::POLLIN, poll::EventFlags::empty())];
-            match poll::poll(&mut fds, timeout_ms) {
+            match poll::poll(&mut fds, self.timeout_ms) {
                 Ok(n) if n == 0 => {
                     // single escape
                 }
@@ -308,8 +310,8 @@
     }
 
     /// Create a RAW reader
-    fn create_reader(&self) -> Result<PosixRawReader> {
-        PosixRawReader::new()
+    fn create_reader(&self, config: &Config) -> Result<PosixRawReader> {
+        PosixRawReader::new(config)
     }
 
     fn create_writer(&self) -> Stdout {
diff --git a/src/tty/windows.rs b/src/tty/windows.rs
index bb0bcf1..6ad8844 100644
--- a/src/tty/windows.rs
+++ b/src/tty/windows.rs
@@ -6,6 +6,7 @@
 use kernel32;
 use winapi;
 
+use config::Config;
 use consts::{self, KeyPress};
 use error;
 use Result;
@@ -85,7 +86,7 @@
 }
 
 impl RawReader for ConsoleRawReader {
-    fn next_key(&mut self, _: i32) -> Result<KeyPress> {
+    fn next_key(&mut self) -> Result<KeyPress> {
         use std::char::decode_utf16;
         // use winapi::{LEFT_ALT_PRESSED, LEFT_CTRL_PRESSED, RIGHT_ALT_PRESSED, RIGHT_CTRL_PRESSED};
         use winapi::{LEFT_ALT_PRESSED, RIGHT_ALT_PRESSED};
@@ -292,8 +293,7 @@
         })
     }
 
-
-    fn create_reader(&self) -> Result<ConsoleRawReader> {
+    fn create_reader(&self, _: &Config) -> Result<ConsoleRawReader> {
         ConsoleRawReader::new()
     }