Comment jouer avec Control.Monad.Writer dans haskell?

Je suis nouveau dans la programmation fonctionnelle et j'ai récemment appris à Learn You a Haskell , mais quand j'ai parcouru ce chapitre , je suis resté coincé avec le programme ci-dessous:

import Control.Monad.Writer  

logNumber :: Int -> Writer [String] Int  
logNumber x = Writer (x, ["Got number: " ++ show x])  

multWithLog :: Writer [String] Int  
multWithLog = do  
    a <- logNumber 3  
    b <- logNumber 5  
    return (a*b)

J'ai enregistré ces lignes dans un fichier .hs et je n'ai pas réussi à l'importer dans mon ghci, ce qui s'est plaint:

more1.hs:4:15:
    Not in scope: data constructor `Writer'
    Perhaps you meant `WriterT' (imported from Control.Monad.Writer)
Failed, modules loaded: none.

J'ai examiné le type par la commande ": info":

Prelude Control.Monad.Writer> :info Writer
type Writer w = WriterT w Data.Functor.Identity.Identity
               -- Defined in `Control.Monad.Trans.Writer.Lazy'

De mon point de vue, c'était censé être quelque chose comme "newtype Writer wa ..." donc je ne sais pas comment alimenter le constructeur de données et obtenir un Writer.

Je suppose que cela pourrait être un problème lié à la version et ma version ghci est 7.4.1

Le package Control.Monad.Writern'exporte pas le constructeur de données Writer. Je suppose que c'était différent lorsque LYAH a été écrit.

Utilisation de la classe de types MonadWriter dans ghci

Au lieu de cela, vous créez des rédacteurs à l'aide de la writerfonction. Par exemple, dans une session ghci, je peux faire

ghci> import Control.Monad.Writer
ghci> let logNumber x = writer (x, ["Got number: " ++ show x])

C'est maintenant logNumberune fonction qui crée des écrivains. Je peux demander son type:

ghci> :t logNumber
logNumber :: (Show a, MonadWriter [String] m) => a -> m a

Ce qui me dit que le type inféré n'est pas une fonction qui renvoie un écrivain particulier , mais plutôt tout ce qui implémente la MonadWriterclasse de type. Je peux maintenant l'utiliser:

ghci> let multWithLog = do { a <- logNumber 3; b <- logNumber 5; return (a*b) }
    :: Writer [String] Int

(Entrée en fait entré tout sur une seule ligne). Ici, j'ai spécifié le type d' multWithLogêtre Writer [String] Int. Maintenant je peux l'exécuter:

ghci> runWriter multWithLog
(15, ["Got number: 3","Got number: 5"])

Et vous voyez que nous enregistrons toutes les opérations intermédiaires.

Pourquoi le code est-il écrit comme ça?

Pourquoi se donner la peine de créer la MonadWriterclasse de type? La raison est à voir avec les transformateurs monades. Comme vous l'avez bien compris, le moyen le plus simple d'implémenter Writerest de créer un wrapper de nouveau type au-dessus d'une paire:

newtype Writer w a = Writer { runWriter :: (a,w) }

Vous pouvez déclarer une instance de monade pour cela, puis écrire la fonction

tell :: Monoid w => w -> Writer w ()

qui enregistre simplement son entrée. Supposons maintenant que vous vouliez une monade qui ait des capacités de journalisation, mais qui fasse également autre chose - disons qu'elle peut également lire à partir d'un environnement. Vous implémenteriez cela comme

type RW r w a = ReaderT r (Writer w a)

Maintenant, parce que l'écrivain est à l'intérieur du ReaderTtransformateur monade, si vous voulez enregistrer la sortie, vous ne pouvez pas utiliser tell w(car cela ne fonctionne qu'avec des écrivains non emballés) mais vous devez utiliser lift $ tell w, ce qui "soulève" la tellfonction à travers le ReaderTafin qu'elle puisse accéder au monade d'écrivain intérieur. Si vous vouliez des transformateurs à deux couches (disons que vous vouliez également ajouter la gestion des erreurs), vous devez les utiliser lift $ lift $ tell w. Cela devient rapidement difficile à manier.

Au lieu de cela, en définissant une classe de type, nous pouvons transformer n'importe quel wrapper de transformateur monade autour d'un écrivain en une instance de writer lui-même. Par exemple,

instance (Monoid w, MonadWriter w m) => MonadWriter w (ReaderT r m)

c'est-à-dire que si west un monoïde, et mest a MonadWriter w, alors ReaderT r mest également a MonadWriter w. Cela signifie que nous pouvons utiliser la tellfonction directement sur la monade transformée, sans avoir à se soucier de la soulever explicitement à travers le transformateur de monade.

Une fonction appelée "writer" est mise à disposition à la place d'un constructeur "Writer". Changement:

logNumber x = Writer (x, ["Got number: " ++ show x])

à:

logNumber x = writer (x, ["Got number: " ++ show x])

J'ai reçu un message similaire en essayant le LYAH "Pour quelques monades en plus" en utilisant l'éditeur en ligne Haskell dans repl.it

J'ai changé l'importation de:

import Control.Monad.Writer

à:

import qualified Control.Monad.Trans.Writer.Lazy as W

Donc, mon code fonctionne maintenant comme ceci (avec l'inspiration du blog Haskell de Kwang ):

import Data.Monoid
import qualified Control.Monad.Trans.Writer.Lazy as W


output :: String -> W.Writer [String] ()
output x = W.tell [x]


gcd' :: Int -> Int -> W.Writer [String] Int  
gcd' a b  
    | b == 0 = do  
        output ("Finished with " ++ show a)
        return a  
    | otherwise = do  
        output (show a ++ " mod " ++ show b ++ " = " ++ show (a `mod` b))
        gcd' b (a `mod` b)

main :: IO()
main = mapM_ putStrLn $ snd $ W.runWriter (gcd' 8 3) 

Le code est actuellement exécutable ici