Évaluation paresseuse des actions IO

Cela semble être dans cet esprit:

let (|>) = flip ($)
let (.>) = flip (.)

getContents >>= lines .> takeWhile (/= "quit") .> length .> print

Utilisation de repeatM , takeWhile et length_ fonctions de bibliothèque en streaming :

import Streaming
import qualified Streaming.Prelude as S

count :: IO ()
count = do r <- S.length_ . S.takeWhile (/= "quit") . S.repeatM $ getLine
           print r

Le problème ici est que Monad n'est pas la bonne abstraction pour cela, et essayer de faire quelque chose comme ça entraîne une situation où la transparence référentielle est brisée.

Premièrement, nous pouvons faire un Lazy IO se lit comme suit:

1
Hello World

Cette fois, exécutera cat . Il lira les lignes et les affichera. Tout fonctionne bien.

Mais pensez à changer la fonction principale en ceci:

main :: IO ()
main = do
    x <- lazyIOSequence (map (putStrLn . show) [1..])
    seq (head x) putStrLn "Hello World"

Cela ne produit que Hello World , car nous n'avions pas besoin pour évaluer l'un des l . Mais maintenant, envisagez de remplacer la dernière ligne comme suit:

main :: IO ()
main = do
    l <- lazyIOSequence (map (putStrLn . show) [1..])
    putStrLn "Hello World"

Même programme, mais le résultat est maintenant:

module Main where

import System.IO.Unsafe (unsafePerformIO)
import Control.Monad(forM_)

lazyIOSequence :: [IO a] -> IO [a]
lazyIOSequence = pure . go where
    go :: [IO a] -> [a]
    go (l:ls) = (unsafePerformIO l):(go ls)


main :: IO ()
main = do
    l <- lazyIOSequence (repeat getLine)
    forM_ l putStrLn 

C'est mauvais, nous avons changé les résultats d'un programme simplement en évaluant une valeur. Cela n'est pas censé se produire dans Haskell, lorsque vous évaluez quelque chose, il devrait simplement l'évaluer, pas changer le monde extérieur.

Donc, si vous limitez vos actions d'E / S à quelque chose comme la lecture d'un fichier, rien d'autre ne lit à partir de, alors vous pourrez peut-être évaluer paresseusement les choses de manière raisonnable, car lorsque vous le lisez par rapport à toutes les autres actions d'E / S prises par votre programme, cela n'a pas d'importance. Mais vous ne voulez pas autoriser cela pour les E / S en général, car sauter des actions ou les exécuter dans un ordre différent peut avoir de l'importance (et au-dessus, certainement). Même dans le cas de la lecture paresseuse d'un fichier, si quelque chose d'autre dans votre programme écrit dans le fichier, le fait que vous évaluiez cette liste avant ou après l'action d'écriture affectera la sortie de votre programme, ce qui, encore une fois, rompt la transparence référentielle (car l'ordre d'évaluation ne devrait pas avoir d'importance).

Donc, pour un sous-ensemble restreint d'actions IO, vous pouvez définir judicieusement Functor, Applicative et Monad sur un type de flux pour fonctionner de manière paresseuse, mais le faire dans IO Monad en général est un champ de mines et souvent tout simplement incorrect. Au lieu de cela, vous voulez un type de streaming spécialisé, et en fait Conduit définit Functor, Applicative et Monad sur beaucoup de ses types afin que vous puissiez toujours utiliser toutes vos fonctions préférées.