Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
beginners-requ...@haskell.org
You can reach the person managing the list at
beginners-ow...@haskell.org
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: ListT + Writer (aquagnu)
2. Re: ListT + Writer (Francesco Ariis)
3. Re: ListT + Writer (David McBride)
4. Re: ListT + Writer (Baa)
5. Re: ListT + Writer (Baa)
----------------------------------------------------------------------
Message: 1
Date: Thu, 25 May 2017 21:37:03 +0300
From: aquagnu <aqua...@gmail.com>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] ListT + Writer
Message-ID: <20170525213703.54e82...@gmail.com>
Content-Type: text/plain; charset=UTF-8
David, many thanks for such a detailed answer and explanation!!
So, if I know that I'll iterate over list (vs abstract "m"'s bind), can
I replace "m" with Identity, to get list instead of abstract "ListT m"?
And last question: what is more canonical (Haskelish) way to iterate
over list with state? Fold*/State/Writer? Actually my ultimate goal was
to process list items with some state and possible IO (REST calls,
something else)... Is the usage of ListT + Writer (or ListT + State) a
good solution or better is to make all logic in one function and to
pass it to fold* (so state will be accumulating value)? I will iterate
over items of items of this list too: some of them are also lists,
so ListT looks more naturally IMHO, but I'm not sure...
David, in all cases - many thanks!!
В Thu, 25 May 2017 12:55:00 -0400
David McBride <toa...@gmail.com> пишет:
> To start all these types with T at the end are transformers. They are
> a type that is wrapped around some inner m. StateT s m, ErrorT e m a,
> and so on.
>
> In order to use do notation, you must be in a type which is an
> instance of Monad.
>
> newtype ListT (m :: * -> *) a = ListT {runListT :: m [a]}
> instance [safe] Monad m => Monad (ListT m)
>
> newtype WriterT w (m :: * -> *) a = WriterT {runWriterT :: m (a, w)}
> instance [safe] (Monoid w, Monad m) => MonadWriter w (WriterT w m)
>
> These types and their instances say the following:
> ListT m a is a Monad if m is a Monad.
> WriterT w m a is a Monad if m is a Monad and w is a Monoid.
>
> So in order to use do notation in a WriterT String (ListT m) a, I must
> add the Monad m contstraint to proc, and also ensure that the writer's
> w is a monoid (it is because it is a string).
>
> Now to pass in a ListT as an argument, I must construct one. Remember
> that in order to use the return function, m must be in a monad, so I
> must add the Monad constraint.
>
> foo :: Monad m => ListT m Int
> foo = ListT (return [1,2,3])
>
> test = (runListT $ runWriterT (proc3 foo)) >>= print
>
> proc3 :: Monad m => ListT m Int -> WriterT String (ListT m) Int
> proc3 foo = do
> tell ("started: " :: String)
> x <- lift foo
> y <- lift $ ListT (return [3,4,5])
> lift $ guard (y /= 5)
> tell ("x:" ++ show x)
> tell ("y:" ++ show y)
> return (x * y)
>
> As you saw in the other comment in this thread, most people use a type
> alias to make it more palatable.
>
> type MyApp m a = WriterT String (ListT m) Int
> -- or type MyApp a = WriterT String (ListT IO) Int
>
> proc3 :: Monad m =>ListT m a -> MyApp m Int
> -- or proc3 :: ListT m a -> MyApp Int
>
> On Thu, May 25, 2017 at 12:11 PM, Baa <aqua...@gmail.com> wrote:
> > В Thu, 25 May 2017 11:52:01 -0400
> > David McBride <toa...@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 <aqua...@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@haskell.org
> >> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >> _______________________________________________
> >> Beginners mailing list
> >> Beginners@haskell.org
> >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >
> > _______________________________________________
> > Beginners mailing list
> > Beginners@haskell.org
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
--
Best regards,
Paul a.k.a. 6apcyk
------------------------------
Message: 2
Date: Thu, 25 May 2017 20:44:57 +0200
From: Francesco Ariis <fa...@ariis.it>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] ListT + Writer
Message-ID: <20170525184457.ga12...@casa.casa>
Content-Type: text/plain; charset=utf-8
On Thu, May 25, 2017 at 07:02:58PM +0300, Baa wrote:
>
> В Thu, 25 May 2017 17:43:49 +0200
> > Should be as easy as:
> >
> > import Control.Monad.List
> > import Control.Monad.Writer
> >
> > type Prova = ListT (Writer String) Int
>
> Yes! And this is the source of my questions.. 1) How to call it? 2)
> What does mean to provide argument of type ".. Writer .."? As result,
> it's good: you can run it with "runWriter", but what is "writer" in
> input argument? Fake writer (which is ignoring)?
I am not sure for question #1. If we look at the constructor of ListT
(`runListT :: m [a]`) and MonadWriter (`(a, w)`) and we compose the two
we get:
([a], w)
-- or ([Integer], String) in our example
-- e.g. ListT (writer ([1,2], "ciao")) <-- to construct
No idea what is the correct name of this critter.
As we can see by running it, the argument in `fn` (both the list part and
the string part) is not ignored:
λ> fn $ ListT (writer ([1,2], "ciao"))
ListT (WriterT (Identity ([3],"ciaohey baby")))
Does this answer your questions?
------------------------------
Message: 3
Date: Thu, 25 May 2017 15:10:10 -0400
From: David McBride <toa...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] ListT + Writer
Message-ID:
<can+tr402exq5pn_7gd0vyyjf-taaqtel0s_tgvrwb_alhsp...@mail.gmail.com>
Content-Type: text/plain; charset="UTF-8"
If you fill in Identity for m, ListT m Int ends up becoming Identity
[Int], which is just a list.
Doing effects over a list is a classic FoldM. You can use the foldl
library on hackage to do most things, I think. To do it over a list
of lists, that actually sounds like something you would use ListT for,
but I don't use it much in my code, so I can't say for sure how well
it will work for you. For what it is worth I've also heard that the
version of ListT in base is not quite correct, although I don't know
why.
If you are feeling adventurous, check out the pipes tutorial
http://hackage.haskell.org/package/pipes-4.3.4/docs/Pipes-Tutorial.html,
there is a ListT done right section toward the end where it shows how
to construct and use IO code from his version of a ListT. That would
require you to understand and buy into the pipes ecosystem.
On Thu, May 25, 2017 at 2:37 PM, aquagnu <aqua...@gmail.com> wrote:
> David, many thanks for such a detailed answer and explanation!!
>
> So, if I know that I'll iterate over list (vs abstract "m"'s bind), can
> I replace "m" with Identity, to get list instead of abstract "ListT m"?
>
> And last question: what is more canonical (Haskelish) way to iterate
> over list with state? Fold*/State/Writer? Actually my ultimate goal was
> to process list items with some state and possible IO (REST calls,
> something else)... Is the usage of ListT + Writer (or ListT + State) a
> good solution or better is to make all logic in one function and to
> pass it to fold* (so state will be accumulating value)? I will iterate
> over items of items of this list too: some of them are also lists,
> so ListT looks more naturally IMHO, but I'm not sure...
>
> David, in all cases - many thanks!!
>
>
>
> В Thu, 25 May 2017 12:55:00 -0400
> David McBride <toa...@gmail.com> пишет:
>
>> To start all these types with T at the end are transformers. They are
>> a type that is wrapped around some inner m. StateT s m, ErrorT e m a,
>> and so on.
>>
>> In order to use do notation, you must be in a type which is an
>> instance of Monad.
>>
>> newtype ListT (m :: * -> *) a = ListT {runListT :: m [a]}
>> instance [safe] Monad m => Monad (ListT m)
>>
>> newtype WriterT w (m :: * -> *) a = WriterT {runWriterT :: m (a, w)}
>> instance [safe] (Monoid w, Monad m) => MonadWriter w (WriterT w m)
>>
>> These types and their instances say the following:
>> ListT m a is a Monad if m is a Monad.
>> WriterT w m a is a Monad if m is a Monad and w is a Monoid.
>>
>> So in order to use do notation in a WriterT String (ListT m) a, I must
>> add the Monad m contstraint to proc, and also ensure that the writer's
>> w is a monoid (it is because it is a string).
>>
>> Now to pass in a ListT as an argument, I must construct one. Remember
>> that in order to use the return function, m must be in a monad, so I
>> must add the Monad constraint.
>>
>> foo :: Monad m => ListT m Int
>> foo = ListT (return [1,2,3])
>>
>> test = (runListT $ runWriterT (proc3 foo)) >>= print
>>
>> proc3 :: Monad m => ListT m Int -> WriterT String (ListT m) Int
>> proc3 foo = do
>> tell ("started: " :: String)
>> x <- lift foo
>> y <- lift $ ListT (return [3,4,5])
>> lift $ guard (y /= 5)
>> tell ("x:" ++ show x)
>> tell ("y:" ++ show y)
>> return (x * y)
>>
>> As you saw in the other comment in this thread, most people use a type
>> alias to make it more palatable.
>>
>> type MyApp m a = WriterT String (ListT m) Int
>> -- or type MyApp a = WriterT String (ListT IO) Int
>>
>> proc3 :: Monad m =>ListT m a -> MyApp m Int
>> -- or proc3 :: ListT m a -> MyApp Int
>>
>> On Thu, May 25, 2017 at 12:11 PM, Baa <aqua...@gmail.com> wrote:
>> > В Thu, 25 May 2017 11:52:01 -0400
>> > David McBride <toa...@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 <aqua...@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@haskell.org
>> >> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>> >> _______________________________________________
>> >> Beginners mailing list
>> >> Beginners@haskell.org
>> >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>> >
>> > _______________________________________________
>> > Beginners mailing list
>> > Beginners@haskell.org
>> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>> _______________________________________________
>> Beginners mailing list
>> Beginners@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>
>
> --
> Best regards,
> Paul a.k.a. 6apcyk
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
Message: 4
Date: Fri, 26 May 2017 11:16:37 +0300
From: Baa <aqua...@gmail.com>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] ListT + Writer
Message-ID: <20170526111559.50bd33dd@Pavel>
Content-Type: text/plain; charset=UTF-8
@Francesco, yes, it completely answers my questions. Thank you very much
for clarification!! I got it.
В Thu, 25 May 2017 20:44:57 +0200
Francesco Ariis <fa...@ariis.it> пишет:
> On Thu, May 25, 2017 at 07:02:58PM +0300, Baa wrote:
> >
> > В Thu, 25 May 2017 17:43:49 +0200
> > > Should be as easy as:
> > >
> > > import Control.Monad.List
> > > import Control.Monad.Writer
> > >
> > > type Prova = ListT (Writer String) Int
> >
> > Yes! And this is the source of my questions.. 1) How to call it? 2)
> > What does mean to provide argument of type ".. Writer .."? As
> > result, it's good: you can run it with "runWriter", but what is
> > "writer" in input argument? Fake writer (which is ignoring)?
>
> I am not sure for question #1. If we look at the constructor of ListT
> (`runListT :: m [a]`) and MonadWriter (`(a, w)`) and we compose the
> two we get:
>
> ([a], w)
> -- or ([Integer], String) in our example
> -- e.g. ListT (writer ([1,2], "ciao")) <-- to construct
>
> No idea what is the correct name of this critter.
>
> As we can see by running it, the argument in `fn` (both the list part
> and the string part) is not ignored:
>
> λ> fn $ ListT (writer ([1,2], "ciao"))
> ListT (WriterT (Identity ([3],"ciaohey baby")))
>
> Does this answer your questions?
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
Message: 5
Date: Fri, 26 May 2017 11:49:43 +0300
From: Baa <aqua...@gmail.com>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] ListT + Writer
Message-ID: <20170526114943.177421e6@Pavel>
Content-Type: text/plain; charset=UTF-8
David,
On
https://hackage.haskell.org/package/transformers-0.5.4.0/docs/Control-Monad-Trans-List.html
is written that
"Deprecated: This transformer is invalid on most monads".
Also I found this: https://wiki.haskell.org/ListT_done_right.
But no such warning in the "mtl" package, and I don't know is it done
rightly in the "mtl" package...
David, what does mean "space leak" here:
"Use this foldl library when you want to compute multiple folds over a
collection in one pass over the data without space leaks"
--http://hackage.haskell.org/package/foldl
?
As I understand no real space leak when we are talking about Haskell
code, only not optimal usage of memory (for example, thunks number
grows up drastically)?
Guys, it's so good that there are people like you who have enough time
and desire to support us - Haskell beginners.
В Thu, 25 May 2017 15:10:10 -0400
David McBride <toa...@gmail.com> пишет:
> If you fill in Identity for m, ListT m Int ends up becoming Identity
> [Int], which is just a list.
>
> Doing effects over a list is a classic FoldM. You can use the foldl
> library on hackage to do most things, I think. To do it over a list
> of lists, that actually sounds like something you would use ListT for,
> but I don't use it much in my code, so I can't say for sure how well
> it will work for you. For what it is worth I've also heard that the
> version of ListT in base is not quite correct, although I don't know
> why.
>
> If you are feeling adventurous, check out the pipes tutorial
> http://hackage.haskell.org/package/pipes-4.3.4/docs/Pipes-Tutorial.html,
> there is a ListT done right section toward the end where it shows how
> to construct and use IO code from his version of a ListT. That would
> require you to understand and buy into the pipes ecosystem.
>
> On Thu, May 25, 2017 at 2:37 PM, aquagnu <aqua...@gmail.com> wrote:
> > David, many thanks for such a detailed answer and explanation!!
> >
> > So, if I know that I'll iterate over list (vs abstract "m"'s bind),
> > can I replace "m" with Identity, to get list instead of abstract
> > "ListT m"?
> >
> > And last question: what is more canonical (Haskelish) way to iterate
> > over list with state? Fold*/State/Writer? Actually my ultimate goal
> > was to process list items with some state and possible IO (REST
> > calls, something else)... Is the usage of ListT + Writer (or ListT
> > + State) a good solution or better is to make all logic in one
> > function and to pass it to fold* (so state will be accumulating
> > value)? I will iterate over items of items of this list too: some
> > of them are also lists, so ListT looks more naturally IMHO, but I'm
> > not sure...
> >
> > David, in all cases - many thanks!!
> >
> >
> >
> > В Thu, 25 May 2017 12:55:00 -0400
> > David McBride <toa...@gmail.com> пишет:
> >
> >> To start all these types with T at the end are transformers. They
> >> are a type that is wrapped around some inner m. StateT s m,
> >> ErrorT e m a, and so on.
> >>
> >> In order to use do notation, you must be in a type which is an
> >> instance of Monad.
> >>
> >> newtype ListT (m :: * -> *) a = ListT {runListT :: m [a]}
> >> instance [safe] Monad m => Monad (ListT m)
> >>
> >> newtype WriterT w (m :: * -> *) a = WriterT {runWriterT :: m (a,
> >> w)} instance [safe] (Monoid w, Monad m) => MonadWriter w (WriterT
> >> w m)
> >>
> >> These types and their instances say the following:
> >> ListT m a is a Monad if m is a Monad.
> >> WriterT w m a is a Monad if m is a Monad and w is a Monoid.
> >>
> >> So in order to use do notation in a WriterT String (ListT m) a, I
> >> must add the Monad m contstraint to proc, and also ensure that the
> >> writer's w is a monoid (it is because it is a string).
> >>
> >> Now to pass in a ListT as an argument, I must construct one.
> >> Remember that in order to use the return function, m must be in a
> >> monad, so I must add the Monad constraint.
> >>
> >> foo :: Monad m => ListT m Int
> >> foo = ListT (return [1,2,3])
> >>
> >> test = (runListT $ runWriterT (proc3 foo)) >>= print
> >>
> >> proc3 :: Monad m => ListT m Int -> WriterT String (ListT m) Int
> >> proc3 foo = do
> >> tell ("started: " :: String)
> >> x <- lift foo
> >> y <- lift $ ListT (return [3,4,5])
> >> lift $ guard (y /= 5)
> >> tell ("x:" ++ show x)
> >> tell ("y:" ++ show y)
> >> return (x * y)
> >>
> >> As you saw in the other comment in this thread, most people use a
> >> type alias to make it more palatable.
> >>
> >> type MyApp m a = WriterT String (ListT m) Int
> >> -- or type MyApp a = WriterT String (ListT IO) Int
> >>
> >> proc3 :: Monad m =>ListT m a -> MyApp m Int
> >> -- or proc3 :: ListT m a -> MyApp Int
> >>
> >> On Thu, May 25, 2017 at 12:11 PM, Baa <aqua...@gmail.com> wrote:
> >> > В Thu, 25 May 2017 11:52:01 -0400
> >> > David McBride <toa...@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 <aqua...@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@haskell.org
> >> >> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >> >> _______________________________________________
> >> >> Beginners mailing list
> >> >> Beginners@haskell.org
> >> >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >> >
> >> > _______________________________________________
> >> > Beginners mailing list
> >> > Beginners@haskell.org
> >> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >> _______________________________________________
> >> Beginners mailing list
> >> Beginners@haskell.org
> >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >
> >
> >
> > --
> > Best regards,
> > Paul a.k.a. 6apcyk
> > _______________________________________________
> > Beginners mailing list
> > Beginners@haskell.org
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 107, Issue 13
******************************************
