Drop read thread

Previously we would read events from the console in a separate thread
which would be killed after the needed event was read. There are a few
issues with this approach:

 * it is expensive, requiring the creation and destruction of a thread
   with every read event
 * it is racy, since the thread may be killed after an even has been
   read from the console but before it has been pushed to the event
   TChan
 * we may read too much: the read loop thread may read more input than
   Haskeline was supposed to read (see GHC #21047).

Author: bgamari

System/Console/Haskeline/Backend/Win32.hsc

@@ -66,8 +66,6 @@ eventReader :: HANDLE -> IO [Event]
 eventReader h = do
     let waitTime = 500 -- milliseconds
     ret <- c_WaitForSingleObject h waitTime
-    yield -- otherwise, the above foreign call causes the loop to never
-          -- respond to the killThread
     if ret /= (#const WAIT_OBJECT_0)
         then eventReader h
         else do

System/Console/Haskeline/Term.hs

@@ -138,18 +138,17 @@ keyEventLoop readEvents eventChan = do
     isEmpty <- atomically $ isEmptyTChan eventChan
     if not isEmpty
         then atomically $ readTChan eventChan
-        else do
-            tid <- forkIO $ handleErrorEvent readerLoop
-            atomically (readTChan eventChan) `finally` killThread tid
+        else handleErrorEvent readerLoop
   where
+    readerLoop :: IO Event
     readerLoop = do
         es <- readEvents
-        if null es
-            then readerLoop
-            else atomically $ mapM_ (writeTChan eventChan) es
-    handleErrorEvent = handle $ \e -> case fromException e of
-                                Just ThreadKilled -> return ()
-                                _ -> atomically $ writeTChan eventChan (ErrorEvent e)
+        case es of
+          [] -> readerLoop
+          e : rest -> do atomically $ mapM_ writeTChan rest
+                         return e
+
+    handleErrorEvent = handle $ \e -> return (ErrorEvent e)
 
 saveKeys :: TChan Event -> [Key] -> IO ()
 saveKeys ch = atomically . writeTChan ch . KeyInput