Comment terminer un calcul qui s'exécute dans la monade `IO`?

Question

Il est une bibliothèque qui fournit un type de données F et une fonction de type

ffoldlIO :: (b -> a -> IO b) -> b -> F a -> IO b 

La fonction est similaire à

foldlIO :: (b -> a -> IO b) -> b -> [a] -> IO b 
foldlIO f a = \xs -> foldr (\x r (!a') -> f a' x >>= r) return xs a 

Je me demande si foldlIO (et donc ffoldlIO) peut fonctionner dans un court -circuit de mode.

Considérons cet exemple:

example1 :: IO Int 
example1 = foldlIO (\a x -> if a < 4 then return (a + x) else return a) 0 [1..5] 

Ici foldlIO parcourt toute la liste, mais si l'on jette une exception pour arrêter le calcul et l'attraper? Quelque chose comme ceci:

data Terminate = Terminate 
    deriving (Show) 

instance Exception Terminate 

example2 :: IO Int 
example2 = do 
    ra <- newIORef 0 
    let step a x 
     | a' < 4 = return a' 
     | otherwise = writeIORef ra a' >> throwIO Terminate 
     where a' = a + x 
    foldlIO step 0 [1..] `catch` \(_ :: Terminate) -> readIORef ra 

Est-ce fiable? Y at-il un meilleur moyen de terminer un calcul qui s'exécute dans la monade IO (et aucune autre monade) ou suis-je pas censé faire cela du tout?

Answer 1

Par exemple, vous pouvez utiliser ContT transformateur monade comme ceci:

example3 :: IO Int 
example3 = flip runContT return . callCC $ \exit -> do 
    let step a x 
      | a' < 4 = return a' 
      | otherwise = exit a' 
      where a' = a + x 
    foldM step 0 [1..] 

Vous pouvez également définir votre propre version de foldM avec posibility de résiliation.

termFoldM :: (Monad m, Foldable t) => 
    ((b -> ContT b m c) -> b -> a -> ContT b m b) -> b -> t a -> m b 
termFoldM f a t = flip runContT return . callCC $ \exit -> foldM (f exit) a xs 

example4 :: IO Int 
example4 = termFoldM step 0 [1..] 
    where 
    step exit a x 
     | a' < 4 = return a' 
     | otherwise = exit a' 
     where a' = a + x 

Mais de cette façon (avec ContT) a un problème. Vous ne pouvez pas facilement faire des actions IO. Par exemple, ce code ne sera pas compilé, car la fonction step doit renvoyer la valeur du type ContT Int IO Int et non IO Int.

let step a x 
     | a' < 4 = putStrLn ("'a = " ++ show a') >> return a' 
     | otherwise = exit a' 
     where a' = a + x 

Heureusement, vous pouvez résoudre ce par la fonction lift, comme ceci:

let step a x 
     | a' < 4 = lift (putStrLn ("'a = " ++ show a')) >> return a' 
     | otherwise = exit a' 
     where a' = a + x 

Answer 2

Ma première réponse n'a pas été correcte. Donc, je vais essayer de m'améliorer. Je pense que l'utilisation d'exceptions pour se terminer dans une monade d'E/S n'est pas un hack mais elle n'a pas l'air propre. Je propose de définir l'instance MonadCont IO comme ceci:

data Terminate = forall a . Terminate a deriving (Typeable) 
instance Show Terminate where show = const "Terminate" 
instance Exception Terminate 

instance MonadCont IO where 
    callCC f = f exit `catch` (\(Terminate x) -> return . unsafeCoerce $ x) 
     where exit = throwIO . Terminate 

Ensuite, vous pouvez réécrire votre exemple plus propre.

example :: IO Int 
example = callCC $ \exit -> do 
    let step a x 
      | a' < 4 = return a' 
      | otherwise = exit a' 
      where a' = a + x 
    foldlIO step 0 [1..] 

---

Variante avec IOREf.

data Terminate = Terminate deriving (Show, Typeable) 
instance Exception Terminate 

instance MonadCont IO where 
    callCC f = do 
     ref <- newIORef undefined 
     let exit a = writeIORef ref a >> throwIO Terminate 
     f exit `catch` (\Terminate -> readIORef ref)