Attente de deux entrées dans Haskell, simultanément

Question

Le titre peut être un peu vague. C'est ce que je veux dire:

Dites que j'ai deux façons d'obtenir des informations sur mon programme. Le premier est via le clavier, en utilisant la fonction getLine qui bloque jusqu'à ce qu'une ligne soit lue. L'autre est, disons, via un TChan, où l'utilisation readTChan chan entraînera également un bloc jusqu'à ce qu'une valeur soit présente dans le canal, après quoi il sera lu. Ce que je veux accomplir est d'être en mesure d'attendre les deux valeurs, en utilisant un seul thread et ne permettant pas à mon processeur de sauter à 100%. Au moment où l'une des deux valeurs est disponible, elle est récupérée et le programme reprend. (Dites, en utilisant Either pour indiquer laquelle des deux valeurs a été reçue.)

Est-ce possible?

Merci beaucoup!

Answer 1

Je ne pense pas que "l'utilisation d'un seul thread" ait un sens ici. Vous devez déjà utiliser plusieurs threads Haskell pour écrire sur le TChan. Vous devez utiliser deux threads Haskell pour cela, et utiliser un MVar ou similaire pour communiquer le premier résultat à arriver. Par exemple:

module Main where 

import System.IO 
import Control.Concurrent 
import Control.Concurrent.MVar 
import Control.Concurrent.STM 
import Control.Concurrent.STM.TChan 

main = do 
    chan <- newTChanIO 
    forkIO (threadTChanWrite chan) 
    threadMultiplexedRead chan 

threadTChanWrite chan = do 
    threadDelay 5000000 
    atomically $ writeTChan chan 3 

threadMultiplexedRead chan = do 
    mvar <- newEmptyMVar 
    forkIO (threadKeyboardRead mvar) 
    forkIO (threadTChanRead mvar chan) 
    v <- readMVar mvar 
    print v 

threadKeyboardRead mvar = do 
    str <- getLine 
    putMVar mvar (Right str) 

threadTChanRead mvar chan = do 
    v <- atomically (readTChan chan) 
    putMVar mvar (Left v) 

Une mise en œuvre correcte nettoiera probablement les fils laissés par la suite, par exemple.

Answer 2

J'ai deux façons d'obtenir les commentaires de mon programme

Vous devriez être en mesure d'utiliser 2 fils, une par source d'entrée, qui attendent leurs entrées respectives, écrit le résultat à un canal partagé ou Mvar gouverné par un troisième thread.

Answer 3

Il y a la fonction d'assistance race :: IO a -> IO b -> IO (Either a b) dans le paquet "async" sur le hackage.

Exécute deux actions d'E/S en même temps, donc l'une pourrait être votre getLine et l'autre bloquant sur un MVar ou autre. Renvoie un Either indiquant lequel est retourné en premier (l'autre est annulé).

https://hackage.haskell.org/package/async-2.0.2/docs/Control-Concurrent-Async.html#v:race