Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: Maybe monad and computations (divyanshu ranjan)
2. Re: Maybe monad and computations (Bob Ippolito)
3. Re: Maybe monad and computations (Emmanuel Touzery)
----------------------------------------------------------------------
Message: 1
Date: Sat, 7 Sep 2013 02:41:15 +0530
From: divyanshu ranjan <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] Maybe monad and computations
Message-ID:
<cal9hw27rhf2ocdwspmyqmcbqjdrnhjywb0ntun1ygibzm9b...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
Hi,
In that case you can use <$> and <*>.
Your code will look like, .... <$> doA <*> doB where ... is the
rest of the computation
Thanks
Divyanshu Ranjan
On Sat, Sep 7, 2013 at 2:34 AM, Emmanuel Touzery <[email protected]> wrote:
> Hmm I've been looking some more. Turns out I'm pretty sure... What I've been
> looking for is liftMx.
>
> In this case, liftM2.
>
> liftM2 ... doA doB
>
> where "..." represents the rest of the computation as it did in the example
> snippet I sent in my first email.
>
> In the case of the Maybe monad, "..." will be called with the "Just" values
> and only if both doA and doB are not Nothing.
>
> and for "n" operations, there is "ap", I'll look at that one too.
>
> emmanuel
>
>
> On Fri, Sep 6, 2013 at 10:43 PM, Emmanuel Touzery <[email protected]>
> wrote:
>>
>> Thank you (and the others) for tips. I'll check the suggestions but yes
>> sequence requires that all items have the same type so that sequence2 would
>> work better but feels un-idiomatic.
>> I needed such code several times in several contexts, so i assumed the
>> answer would be obvious. Maybe i'm structuring my code the wrong way for
>> haskell, i'll rethink those functions. Thanks for now!
>>
>> Emmanuel
>>
>> On Sep 6, 2013 10:37 PM, "Nicholas Vanderweit" <[email protected]>
>> wrote:
>>>
>>> It seems like he wants something like sequence, but for tuples. Say:
>>>
>>> sequence2 :: Monad m => (m a, m b) -> m (a, b)
>>> sequence2 (ma, mb) = ma >>= \a -> mb >>= \b -> return (a, b)
>>>
>>> But without knowing the use case it's hard to know whether or not this
>>> could be done simply with "sequence" and mapM*
>>>
>>>
>>> Nick
>>>
>>>
>>> On Fri, Sep 6, 2013 at 2:28 PM, Michael Steele <[email protected]>
>>> wrote:
>>>>
>>>> The `sequence`, `mapM`, and `mapM_` functions may be what you are
>>>> looking for.
>>>>
>>>> let allTogether = sequence [doA, doB, doC, doZ]
>>>> case allTogether of
>>>> Nothing -> ...
>>>> Just as -> ...
>>>>
>>>>
>>>> Use `maybe` and `fromMaybe` to avoid case statements:
>>>>
>>>> fromMaybe "failure!" $ do
>>>> as <- sequence [doA, doB, doC, doZ]
>>>> return $ "Success: " ++ show (length as)
>>>>
>>>> The `catMaybes` function can be used to execute each computation in
>>>> the list even if some of them return nothing.
>>>>
>>>> On Fri, Sep 6, 2013 at 12:49 PM, Emmanuel Touzery <[email protected]>
>>>> wrote:
>>>> > Hello,
>>>> >
>>>> > I'm often using the Maybe monad to combine Maybe computations one
>>>> > after the
>>>> > other without conditionals.
>>>> >
>>>> > But I'm not sure how to do it, when I have several operations which
>>>> > return
>>>> > Maybe and I want all the indiviual values in the end, not a
>>>> > combination of
>>>> > the values.
>>>> >
>>>> > Currently I do:
>>>> >
>>>> > let allTogether = do
>>>> > ma <- doA
>>>> > mb <- doB
>>>> > return (ma, mb)
>>>> > case allTogether of
>>>> > Nothing -> ...
>>>> > Just (a, b) -> ...
>>>> >
>>>> > This way in this case I have one case instead of two, however I'm
>>>> > sure
>>>> > there must be a nicer way to achieve this result?
>>>> >
>>>> > Thank you!
>>>> >
>>>> > Emmanuel
>>>> >
>>>> > _______________________________________________
>>>> > Beginners mailing list
>>>> > [email protected]
>>>> > http://www.haskell.org/mailman/listinfo/beginners
>>>> >
>>>>
>>>>
>>>>
>>>> --
>>>> -- Michael Steele
>>>>
>>>> _______________________________________________
>>>> Beginners mailing list
>>>> [email protected]
>>>> http://www.haskell.org/mailman/listinfo/beginners
>>>
>>>
>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> [email protected]
>>> http://www.haskell.org/mailman/listinfo/beginners
>>>
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
------------------------------
Message: 2
Date: Fri, 6 Sep 2013 14:12:40 -0700
From: Bob Ippolito <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] Maybe monad and computations
Message-ID:
<CACwMPm8SvUnyJ5DNOQCO=OSWvwhyorVQxKMM_v4=6nipsvy...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Many also use the Control.Applicative syntax for this sort of thing (most
types that have a Monad instance also have an Applicative instance):
(,) <$> ma <*> mb
which is equivalent to:
do
a <- ma
b <- mb
return (a, b)
On Fri, Sep 6, 2013 at 2:04 PM, Emmanuel Touzery <[email protected]> wrote:
> Hmm I've been looking some more. Turns out I'm pretty sure... What I've
> been looking for is liftMx.
>
> In this case, liftM2.
>
> liftM2 ... doA doB
>
> where "..." represents the rest of the computation as it did in the
> example snippet I sent in my first email.
>
> In the case of the Maybe monad, "..." will be called with the "Just"
> values and only if both doA and doB are not Nothing.
>
> and for "n" operations, there is "ap", I'll look at that one too.
>
> emmanuel
>
>
> On Fri, Sep 6, 2013 at 10:43 PM, Emmanuel Touzery <[email protected]>wrote:
>
>> Thank you (and the others) for tips. I'll check the suggestions but yes
>> sequence requires that all items have the same type so that sequence2 would
>> work better but feels un-idiomatic.
>> I needed such code several times in several contexts, so i assumed the
>> answer would be obvious. Maybe i'm structuring my code the wrong way for
>> haskell, i'll rethink those functions. Thanks for now!
>>
>> Emmanuel
>> On Sep 6, 2013 10:37 PM, "Nicholas Vanderweit" <[email protected]>
>> wrote:
>>
>>> It seems like he wants something like sequence, but for tuples. Say:
>>>
>>> sequence2 :: Monad m => (m a, m b) -> m (a, b)
>>> sequence2 (ma, mb) = ma >>= \a -> mb >>= \b -> return (a, b)
>>>
>>> But without knowing the use case it's hard to know whether or not this
>>> could be done simply with "sequence" and mapM*
>>>
>>>
>>> Nick
>>>
>>>
>>> On Fri, Sep 6, 2013 at 2:28 PM, Michael Steele
>>> <[email protected]>wrote:
>>>
>>>> The `sequence`, `mapM`, and `mapM_` functions may be what you are
>>>> looking for.
>>>>
>>>> let allTogether = sequence [doA, doB, doC, doZ]
>>>> case allTogether of
>>>> Nothing -> ...
>>>> Just as -> ...
>>>>
>>>>
>>>> Use `maybe` and `fromMaybe` to avoid case statements:
>>>>
>>>> fromMaybe "failure!" $ do
>>>> as <- sequence [doA, doB, doC, doZ]
>>>> return $ "Success: " ++ show (length as)
>>>>
>>>> The `catMaybes` function can be used to execute each computation in
>>>> the list even if some of them return nothing.
>>>>
>>>> On Fri, Sep 6, 2013 at 12:49 PM, Emmanuel Touzery <[email protected]>
>>>> wrote:
>>>> > Hello,
>>>> >
>>>> > I'm often using the Maybe monad to combine Maybe computations one
>>>> after the
>>>> > other without conditionals.
>>>> >
>>>> > But I'm not sure how to do it, when I have several operations which
>>>> return
>>>> > Maybe and I want all the indiviual values in the end, not a
>>>> combination of
>>>> > the values.
>>>> >
>>>> > Currently I do:
>>>> >
>>>> > let allTogether = do
>>>> > ma <- doA
>>>> > mb <- doB
>>>> > return (ma, mb)
>>>> > case allTogether of
>>>> > Nothing -> ...
>>>> > Just (a, b) -> ...
>>>> >
>>>> > This way in this case I have one case instead of two, however I'm
>>>> sure
>>>> > there must be a nicer way to achieve this result?
>>>> >
>>>> > Thank you!
>>>> >
>>>> > Emmanuel
>>>> >
>>>> > _______________________________________________
>>>> > Beginners mailing list
>>>> > [email protected]
>>>> > http://www.haskell.org/mailman/listinfo/beginners
>>>> >
>>>>
>>>>
>>>>
>>>> --
>>>> -- Michael Steele
>>>>
>>>> _______________________________________________
>>>> Beginners mailing list
>>>> [email protected]
>>>> http://www.haskell.org/mailman/listinfo/beginners
>>>>
>>>
>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> [email protected]
>>> http://www.haskell.org/mailman/listinfo/beginners
>>>
>>>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20130906/b093193e/attachment-0001.html>
------------------------------
Message: 3
Date: Sat, 7 Sep 2013 07:37:15 +0200
From: Emmanuel Touzery <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] Maybe monad and computations
Message-ID:
<cac42rek2vpipr2dbmxf7b8fe3ysy-dqrd2rum7v_tnnxwdr...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
Hello,
And I tried to apply it to the haskell fay compiler, but failed:
http://stackoverflow.com/questions/18667530/dont-understand-this-liftm2-behaviour-in-fay
Not sure whether it's a fay bug or something about the fay monad or liftM2
which i don't understand.
emmanuel
On Sep 6, 2013 11:04 PM, "Emmanuel Touzery" <[email protected]> wrote:
> Hmm I've been looking some more. Turns out I'm pretty sure... What I've
> been looking for is liftMx.
>
> In this case, liftM2.
>
> liftM2 ... doA doB
>
> where "..." represents the rest of the computation as it did in the
> example snippet I sent in my first email.
>
> In the case of the Maybe monad, "..." will be called with the "Just"
> values and only if both doA and doB are not Nothing.
>
> and for "n" operations, there is "ap", I'll look at that one too.
>
> emmanuel
>
>
> On Fri, Sep 6, 2013 at 10:43 PM, Emmanuel Touzery <[email protected]>wrote:
>
>> Thank you (and the others) for tips. I'll check the suggestions but yes
>> sequence requires that all items have the same type so that sequence2 would
>> work better but feels un-idiomatic.
>> I needed such code several times in several contexts, so i assumed the
>> answer would be obvious. Maybe i'm structuring my code the wrong way for
>> haskell, i'll rethink those functions. Thanks for now!
>>
>> Emmanuel
>> On Sep 6, 2013 10:37 PM, "Nicholas Vanderweit" <[email protected]>
>> wrote:
>>
>>> It seems like he wants something like sequence, but for tuples. Say:
>>>
>>> sequence2 :: Monad m => (m a, m b) -> m (a, b)
>>> sequence2 (ma, mb) = ma >>= \a -> mb >>= \b -> return (a, b)
>>>
>>> But without knowing the use case it's hard to know whether or not this
>>> could be done simply with "sequence" and mapM*
>>>
>>>
>>> Nick
>>>
>>>
>>> On Fri, Sep 6, 2013 at 2:28 PM, Michael Steele
>>> <[email protected]>wrote:
>>>
>>>> The `sequence`, `mapM`, and `mapM_` functions may be what you are
>>>> looking for.
>>>>
>>>> let allTogether = sequence [doA, doB, doC, doZ]
>>>> case allTogether of
>>>> Nothing -> ...
>>>> Just as -> ...
>>>>
>>>>
>>>> Use `maybe` and `fromMaybe` to avoid case statements:
>>>>
>>>> fromMaybe "failure!" $ do
>>>> as <- sequence [doA, doB, doC, doZ]
>>>> return $ "Success: " ++ show (length as)
>>>>
>>>> The `catMaybes` function can be used to execute each computation in
>>>> the list even if some of them return nothing.
>>>>
>>>> On Fri, Sep 6, 2013 at 12:49 PM, Emmanuel Touzery <[email protected]>
>>>> wrote:
>>>> > Hello,
>>>> >
>>>> > I'm often using the Maybe monad to combine Maybe computations one
>>>> after the
>>>> > other without conditionals.
>>>> >
>>>> > But I'm not sure how to do it, when I have several operations which
>>>> return
>>>> > Maybe and I want all the indiviual values in the end, not a
>>>> combination of
>>>> > the values.
>>>> >
>>>> > Currently I do:
>>>> >
>>>> > let allTogether = do
>>>> > ma <- doA
>>>> > mb <- doB
>>>> > return (ma, mb)
>>>> > case allTogether of
>>>> > Nothing -> ...
>>>> > Just (a, b) -> ...
>>>> >
>>>> > This way in this case I have one case instead of two, however I'm
>>>> sure
>>>> > there must be a nicer way to achieve this result?
>>>> >
>>>> > Thank you!
>>>> >
>>>> > Emmanuel
>>>> >
>>>> > _______________________________________________
>>>> > Beginners mailing list
>>>> > [email protected]
>>>> > http://www.haskell.org/mailman/listinfo/beginners
>>>> >
>>>>
>>>>
>>>>
>>>> --
>>>> -- Michael Steele
>>>>
>>>> _______________________________________________
>>>> Beginners mailing list
>>>> [email protected]
>>>> http://www.haskell.org/mailman/listinfo/beginners
>>>>
>>>
>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> [email protected]
>>> http://www.haskell.org/mailman/listinfo/beginners
>>>
>>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20130907/19a61fd5/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 63, Issue 10
*****************************************
