HowChar güvenli bir şekilde nasıl iptal edilir?

Question

İsteğe bağlı olarak getChar eylemini iptal etmek istiyorum. Ben aşağıdaki işlevi gerekir: Bir karakter kullanılabilir duruma gelmeden abort denir sürece,

getChar' :: (Char -> IO()) -> IO (IO()) 

abort <- getChar' callback durumunda, bir karakter standart girdi okunur. Bir karakter okunduğunda, callback ile çağrılır.

import Control.Monad 
import Control.Concurrent 

getChar' :: (Char -> IO()) -> IO (IO()) 
getChar' callback = do 
    v <- newEmptyMVar 
    tid <- forkIO $ do 
     c <- getChar 
     b <- tryPutMVar v() 
     when b $ callback c 
    return $ do 
     b <- tryPutMVar v() 
     when b $ killThread tid 

sorun killThread kömürü okuduktan sonra ancak Mvar içine () koymadan önce parçacığı iptal edebilir olmasıdır:

Aşağıdaki prototip uygulama var.

Bu sorunun nasıl çözüleceğine dair bir fikrim yok, temel pakette bu mümkün mü? Değilse, diğer paketlerde uygulanan benzer bir işlev gördünüz mü?

Answer 1

Bunu başarmanın en kolay yolu, kendi arabelleğinizi gerçekleştirmektir. İşte basit bir prototip. Programınızda tam olarak bir kez launchIOThread aradığını varsayar. EOF veya diğer IO istisnalarını işlemez, ancak bu kolay olmalıdır.

import Control.Concurrent 
import Control.Concurrent.STM 
import Data.Maybe 
import Control.Monad 

type Buffer = TVar (Maybe Char) 

launchIOThread :: IO Buffer 
launchIOThread = do 
    buf <- atomically $ newTVar Nothing 
    _ <- forkIO $ ioThread buf 
    return buf 

ioThread :: Buffer -> IO() 
ioThread buf = loop where 
    loop = 
    join $ atomically $ do 
     contents <- readTVar buf 
     if isJust contents -- no-one has taken the character yet 
     then retry -- relax 
     else return $ do 
      c <- getChar 
      atomically $ writeTVar buf (Just c) 
      loop 

getChar' :: Buffer -> (Char -> IO()) -> IO (IO()) 
getChar' buf callback = do 
    abortFlag <- atomically $ newTVar False 

    _ <- forkIO $ doGetChar abortFlag 

    return $ atomically $ writeTVar abortFlag True 

    where 
    doGetChar abortFlag = join $ atomically $ do 
     mbC <- readTVar buf 
     abort <- readTVar abortFlag 
     case mbC of 
     Just c -> 
      do writeTVar buf Nothing; return $ callback c 
     Nothing | abort -> return $ return() 
     _ -> retry 

Answer 2

Yapmak istediğiniz, istisnalara bakılmaksızın MVAR her zaman güvenli bir durumda bırakılacak şekilde istisna işleme yapıları kullanmaktır. Özellikle, muhtemelen withMVar.