[Haskell-beginners] ListT + Writer

[Baa]

В Thu, 25 May 2017 11:52:01 -0400
David McBride <toad3k at gmail.com> пишет:

Hello, David! Am I right that "WriterT ... ListT" is "list of writers"?
As I understand, internal representation is "m (a, w)" where m is a-la
List? So, this is list of "writers"? I am confused only of this "m" in
your "proc1" function, because I suppose this must be Identity and type
becomes "WriterT String [Int]" ? Or?

Can this function "proc1" be modified in the way to get input list and
to "iterate" over its elements with "do el <- ..." but to can call
Writer's tell in the same time? This is the problem for my mind - I can
not understand how to pass input list and to have writer inside :) You
call ListT's bind but over internal hardcoded list values...


> ListT is a bit weird in that it affects whatever monad is underneath
> it, so the order of your types in your Transformer stack matters.
> Both ways have different meanings and each have legitimate uses.  In
> any case you must use the lift function to get to the monad below the
> one you are at.
> 
> import Control.Monad.List
> import Control.Monad.Writer
> 
> test :: IO ()
> test = do
>   (runListT $ runWriterT  proc1) >>= print
>   (runWriterT $ runListT proc2) >>= print
>   return ()
> 
> 
> proc1 :: Monad m => WriterT String (ListT m) Int
> proc1 = do
>   tell ("started: " :: String)
>   x <- lift $ ListT (return [1,2])
>   y <- lift $ ListT (return [3,4,5])
>   lift $ guard (y /= 5)
>   tell ("x:" ++ show x)
>   tell ("y:" ++ show y)
>   return (x * y)
> 
> 
> proc2 :: Monad m => ListT (WriterT String m) Int
> proc2 = do
>   lift $ tell ("started: " :: String)
>   x <- ListT (return [1,2])
>   y <- ListT (return [3,4,5])
>   guard (y /= 5)
>   lift $ tell (" x:" ++ show x)
>   lift $ tell (" y:" ++ show y)
> 
>   return (x * y)
> 
> On Thu, May 25, 2017 at 11:10 AM, Baa <aquagnu at gmail.com> wrote:
> > Hello, everybody!
> >
> > I can process list in monad style with "do" syntax and to use
> > "guard" function in the body. Something like:
> >
> >   fn :: [a] -> [a]
> >   fn lst = do
> >     el <- lst
> >     guard $ condition el
> >     ...
> >     return $ change el
> >
> > How can I do the same but with possibility to call "tell" of "Write"
> > monad in the fn's body? As I understand it should be:
> >
> >    ListT (Writer w) Int
> >
> > for this example?
> >
> > - but how to write it?
> > - how to call (run) it?
> > - and how is it safe ("transformers" package has bug in ListT, so
> > "mtl" must be used?)?
> > - is there other canonical way to do it without to use fold*,
> > recursive calls/fix, State/RWS ?
> >
> >
> > /Cheers
> > _______________________________________________
> > Beginners mailing list
> > Beginners at haskell.org
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners  
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners