Libraries Digest, Vol 117, Issue 10
Edward Kmett
ekmett at gmail.com
Sat May 11 00:06:00 CEST 2013
I for one do not view 'monomorphic too' as a feature.
Sent from my iPad
On May 10, 2013, at 4:36 PM, kudah <kudahkukarek at gmail.com> wrote:
> This is nothing but obfuscation, whenJust is clearly more readable than
> for_. whenJust is monomorphic too.
>
> On Fri, 10 May 2013 11:44:42 -0700 Gabriel Gonzalez
> <gabriel439 at gmail.com> wrote:
>
>> How about I just write a blog post teaching people how to use `for_`
>> (and more generally, how to use `Maybe`'s `Foldable` instance)? I
>> know Oliver Charles wrote a similar post in his 24 days of Hackage,
>> and maybe I could build on that a bit more and perhaps make it as
>> Google-able as possible so it comes up as the top result when people
>> search for keywords like `whenJust` and other `Maybe` idioms.
>>
>>
>> On Fri, May 10, 2013 at 11:25 AM, <libraries-request at haskell.org>
>> wrote:
>>
>>> Send Libraries mailing list submissions to
>>> libraries at haskell.org
>>>
>>> To subscribe or unsubscribe via the World Wide Web, visit
>>> http://www.haskell.org/mailman/listinfo/libraries
>>> or, via email, send a message with subject or body 'help' to
>>> libraries-request at haskell.org
>>>
>>> You can reach the person managing the list at
>>> libraries-owner at haskell.org
>>>
>>> When replying, please edit your Subject line so it is more specific
>>> than "Re: Contents of Libraries digest..."
>>>
>>>
>>> Today's Topics:
>>>
>>> 1. Re: Control.Monad proposal: Add whenJust (Edward Kmett)
>>> 2. Re: Control.Monad proposal: Add whenJust (Evan Laforge)
>>> 3. Re: Control.Monad proposal: Add whenJust (Simon Hengel)
>>> 4. Re: Control.Monad proposal: Add whenJust (Andreas Abel)
>>> 5. Re: Control.Monad proposal: Add whenJust (Ivan Lazar
>>> Miljenovic) 6. Re: Control.Monad proposal: Add whenJust (Ganesh
>>> Sittampalam) 7. Re: Control.Monad proposal: Add whenJust (Petr
>>> Pudl?k)
>>>
>>>
>>> ----------------------------------------------------------------------
>>>
>>> Message: 1
>>> Date: Fri, 10 May 2013 07:16:53 -0400
>>> From: Edward Kmett <ekmett at gmail.com>
>>> Subject: Re: Control.Monad proposal: Add whenJust
>>> To: Niklas Hamb?chen <mail at nh2.me>
>>> Cc: Haskell Libraries <libraries at haskell.org>
>>> Message-ID:
>>> <
>>> CAJumaK8XJrtdrXQfVb3pdi193ghz9ZEX8Q-MnVd435tDt5YFbg at mail.gmail.com>
>>> Content-Type: text/plain; charset="utf-8"
>>>
>>> I'm -1 on this, due to it just further obfuscating the fact that
>>> Data.Foldable.for_ already exists.
>>>
>>>
>>> On Fri, May 10, 2013 at 2:13 AM, Niklas Hamb?chen <mail at nh2.me>
>>> wrote:
>>>
>>>> I would like to propose the addition of
>>>>
>>>> whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
>>>> whenJust (Just x) f = f x
>>>> whenJust _ _ = return ()
>>>>
>>>> to Control.Monad, in the section
>>>>
>>>> "Conditional execution of monadic expressions"
>>>>
>>>> next to
>>>>
>>>> guard :: MonadPlus m => Bool -> m ()
>>>> when :: Monad m => Bool -> m () -> m ()
>>>> unless :: Monad m => Bool -> m () -> m ()
>>>>
>>>>
>>>> Why?
>>>>
>>>> It would allow us to write more readable code and fit well into
>>>> the group of similar functions of this style.
>>>>
>>>> Compare
>>>>
>>>> mUser <- lookupUser
>>>>
>>>> whenJust mUser email
>>>>
>>>> or
>>>>
>>>> whenJust mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> with some currently available alternatives:
>>>>
>>>>
>>>> case mUser of
>>>> Just user -> do putStrLn "Mailing!"
>>>> email user
>>>> Nothing -> return ()
>>>>
>>>> (Default base case clutter.)
>>>>
>>>>
>>>> import Data.Foldable
>>>>
>>>> forM_ mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> (Not too intuitive/well-named here and "Ambiguous occurrence
>>>> forM_" clash with Control.Monad.)
>>>>
>>>> Some more dissatisfying alternatives:
>>>>
>>>>
>>>> maybe (return ()) (\user -> do putStrLn "Mailing!"
>>>> email user
>>>> ) mUser
>>>>
>>>>
>>>> flip (maybe (return ())) mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>>
>>>> import Control.Monad.Trans.Maybe
>>>> import Control.Monad.Trans (lift)
>>>>
>>>> _ <- runMaybeT $ return mUser >>= \user -> lift $ do
>>>> putStrLn "Mailing!"
>>>> email user
>>>> return ()
>>>>
>>>>
>>>> Alternative names:
>>>>
>>>> - withJust, analog to withFile and withForeignPtr
>>>>
>>>> Any comments?
>>>>
>>>> _______________________________________________
>>>> Libraries mailing list
>>>> Libraries at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/libraries
>>> -------------- next part --------------
>>> An HTML attachment was scrubbed...
>>> URL: <
>>> http://www.haskell.org/pipermail/libraries/attachments/20130510/ad34bbe5/attachment-0001.htm
>>>
>>> ------------------------------
>>>
>>> Message: 2
>>> Date: Fri, 10 May 2013 18:30:14 +0700
>>> From: Evan Laforge <qdunkan at gmail.com>
>>> Subject: Re: Control.Monad proposal: Add whenJust
>>> To: Niklas Hamb?chen <mail at nh2.me>
>>> Cc: "libraries at haskell.org" <libraries at haskell.org>
>>> Message-ID:
>>> <
>>> CACbaDy5oCQ-xV4-c-gDNzc5L1+XzHaUAqNomCb3ZfAouwyqH3Q at mail.gmail.com>
>>> Content-Type: text/plain; charset=UTF-8
>>>
>>> I like it, I have a local whenJust I use very frequently.
>>>
>>> I know about forM_, but I don't use it because it sounds too much
>>> like a loop.
>>>
>>> But I recall we already had this discussion and it failed to catch
>>> on then, so unless something has changed it might not be worth
>>> bringing it up again.
>>>
>>> On Fri, May 10, 2013 at 1:13 PM, Niklas Hamb?chen <mail at nh2.me>
>>> wrote:
>>>> I would like to propose the addition of
>>>>
>>>> whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
>>>> whenJust (Just x) f = f x
>>>> whenJust _ _ = return ()
>>>>
>>>> to Control.Monad, in the section
>>>>
>>>> "Conditional execution of monadic expressions"
>>>>
>>>> next to
>>>>
>>>> guard :: MonadPlus m => Bool -> m ()
>>>> when :: Monad m => Bool -> m () -> m ()
>>>> unless :: Monad m => Bool -> m () -> m ()
>>>>
>>>>
>>>> Why?
>>>>
>>>> It would allow us to write more readable code and fit well into
>>>> the group of similar functions of this style.
>>>>
>>>> Compare
>>>>
>>>> mUser <- lookupUser
>>>>
>>>> whenJust mUser email
>>>>
>>>> or
>>>>
>>>> whenJust mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> with some currently available alternatives:
>>>>
>>>>
>>>> case mUser of
>>>> Just user -> do putStrLn "Mailing!"
>>>> email user
>>>> Nothing -> return ()
>>>>
>>>> (Default base case clutter.)
>>>>
>>>>
>>>> import Data.Foldable
>>>>
>>>> forM_ mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> (Not too intuitive/well-named here and "Ambiguous occurrence
>>>> forM_" clash with Control.Monad.)
>>>>
>>>> Some more dissatisfying alternatives:
>>>>
>>>>
>>>> maybe (return ()) (\user -> do putStrLn "Mailing!"
>>>> email user
>>>> ) mUser
>>>>
>>>>
>>>> flip (maybe (return ())) mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>>
>>>> import Control.Monad.Trans.Maybe
>>>> import Control.Monad.Trans (lift)
>>>>
>>>> _ <- runMaybeT $ return mUser >>= \user -> lift $ do
>>>> putStrLn "Mailing!"
>>>> email user
>>>> return ()
>>>>
>>>>
>>>> Alternative names:
>>>>
>>>> - withJust, analog to withFile and withForeignPtr
>>>>
>>>> Any comments?
>>>>
>>>> _______________________________________________
>>>> Libraries mailing list
>>>> Libraries at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/libraries
>>>
>>>
>>>
>>> ------------------------------
>>>
>>> Message: 3
>>> Date: Fri, 10 May 2013 14:04:09 +0200
>>> From: Simon Hengel <sol at typeful.net>
>>> Subject: Re: Control.Monad proposal: Add whenJust
>>> To: Niklas Hamb?chen <mail at nh2.me>
>>> Cc: libraries at haskell.org
>>> Message-ID: <20130510120409.GA2858 at x200>
>>> Content-Type: text/plain; charset=iso-8859-1
>>>
>>> -1
>>>
>>> Personally I think forM_ is the way to go.
>>>
>>> On Fri, May 10, 2013 at 02:13:45PM +0800, Niklas Hamb?chen wrote:
>>>> I would like to propose the addition of
>>>>
>>>> whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
>>>> whenJust (Just x) f = f x
>>>> whenJust _ _ = return ()
>>>>
>>>> to Control.Monad, in the section
>>>>
>>>> "Conditional execution of monadic expressions"
>>>>
>>>> next to
>>>>
>>>> guard :: MonadPlus m => Bool -> m ()
>>>> when :: Monad m => Bool -> m () -> m ()
>>>> unless :: Monad m => Bool -> m () -> m ()
>>>>
>>>>
>>>> Why?
>>>>
>>>> It would allow us to write more readable code and fit well into
>>>> the group of similar functions of this style.
>>>>
>>>> Compare
>>>>
>>>> mUser <- lookupUser
>>>>
>>>> whenJust mUser email
>>>>
>>>> or
>>>>
>>>> whenJust mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> with some currently available alternatives:
>>>>
>>>>
>>>> case mUser of
>>>> Just user -> do putStrLn "Mailing!"
>>>> email user
>>>> Nothing -> return ()
>>>>
>>>> (Default base case clutter.)
>>>>
>>>>
>>>> import Data.Foldable
>>>>
>>>> forM_ mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> (Not too intuitive/well-named here and "Ambiguous occurrence
>>>> forM_" clash with Control.Monad.)
>>>>
>>>> Some more dissatisfying alternatives:
>>>>
>>>>
>>>> maybe (return ()) (\user -> do putStrLn "Mailing!"
>>>> email user
>>>> ) mUser
>>>>
>>>>
>>>> flip (maybe (return ())) mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>>
>>>> import Control.Monad.Trans.Maybe
>>>> import Control.Monad.Trans (lift)
>>>>
>>>> _ <- runMaybeT $ return mUser >>= \user -> lift $ do
>>>> putStrLn "Mailing!"
>>>> email user
>>>> return ()
>>>>
>>>>
>>>> Alternative names:
>>>>
>>>> - withJust, analog to withFile and withForeignPtr
>>>>
>>>> Any comments?
>>>>
>>>> _______________________________________________
>>>> Libraries mailing list
>>>> Libraries at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/libraries
>>>
>>>
>>>
>>> ------------------------------
>>>
>>> Message: 4
>>> Date: Fri, 10 May 2013 16:02:30 +0200
>>> From: Andreas Abel <andreas.abel at ifi.lmu.de>
>>> Subject: Re: Control.Monad proposal: Add whenJust
>>> To: Niklas Hamb?chen <mail at nh2.me>
>>> Cc: libraries at haskell.org
>>> Message-ID: <518CFDF6.2000002 at ifi.lmu.de>
>>> Content-Type: text/plain; charset=ISO-8859-1; format=flowed
>>>
>>> +1
>>>
>>> I use whenJust quite frequently and it is much more readable than
>>> for_ (wrong connotation) or
>>>
>>> flip (maybe $ return ())
>>>
>>> Cheers,
>>> Andreas
>>>
>>> On 10.05.13 8:13 AM, Niklas Hamb?chen wrote:
>>>> I would like to propose the addition of
>>>>
>>>> whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
>>>> whenJust (Just x) f = f x
>>>> whenJust _ _ = return ()
>>>>
>>>> to Control.Monad, in the section
>>>>
>>>> "Conditional execution of monadic expressions"
>>>>
>>>> next to
>>>>
>>>> guard :: MonadPlus m => Bool -> m ()
>>>> when :: Monad m => Bool -> m () -> m ()
>>>> unless :: Monad m => Bool -> m () -> m ()
>>>>
>>>>
>>>> Why?
>>>>
>>>> It would allow us to write more readable code and fit well into
>>>> the group of similar functions of this style.
>>>>
>>>> Compare
>>>>
>>>> mUser <- lookupUser
>>>>
>>>> whenJust mUser email
>>>>
>>>> or
>>>>
>>>> whenJust mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> with some currently available alternatives:
>>>>
>>>>
>>>> case mUser of
>>>> Just user -> do putStrLn "Mailing!"
>>>> email user
>>>> Nothing -> return ()
>>>>
>>>> (Default base case clutter.)
>>>>
>>>>
>>>> import Data.Foldable
>>>>
>>>> forM_ mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>> (Not too intuitive/well-named here and "Ambiguous occurrence
>>>> forM_" clash with Control.Monad.)
>>>>
>>>> Some more dissatisfying alternatives:
>>>>
>>>>
>>>> maybe (return ()) (\user -> do putStrLn "Mailing!"
>>>> email user
>>>> ) mUser
>>>>
>>>>
>>>> flip (maybe (return ())) mUser $ \user -> do
>>>> putStrLn "Mailing!"
>>>> email user
>>>>
>>>>
>>>> import Control.Monad.Trans.Maybe
>>>> import Control.Monad.Trans (lift)
>>>>
>>>> _ <- runMaybeT $ return mUser >>= \user -> lift $ do
>>>> putStrLn "Mailing!"
>>>> email user
>>>> return ()
>>>>
>>>>
>>>> Alternative names:
>>>>
>>>> - withJust, analog to withFile and withForeignPtr
>>>>
>>>> Any comments?
>>>>
>>>> _______________________________________________
>>>> Libraries mailing list
>>>> Libraries at haskell.org
>>>> http://www.haskell.org/mailman/listinfo/libraries
>>>
>>> --
>>> Andreas Abel <>< Du bist der geliebte Mensch.
>>>
>>> Theoretical Computer Science, University of Munich
>>> Oettingenstr. 67, D-80538 Munich, GERMANY
>>>
>>> andreas.abel at ifi.lmu.de
>>> http://www2.tcs.ifi.lmu.de/~abel/
>>>
>>>
>>>
>>> ------------------------------
>>>
>>> Message: 5
>>> Date: Sat, 11 May 2013 00:25:04 +1000
>>> From: Ivan Lazar Miljenovic <ivan.miljenovic at gmail.com>
>>> Subject: Re: Control.Monad proposal: Add whenJust
>>> To: Simon Hengel <sol at typeful.net>
>>> Cc: libraries at haskell.org
>>> Message-ID:
>>> <
>>> CA+u6gbxg6KaXe5etCHcKtEk8sR3-7wAhdCt2mu9S6Y47jTsJqA at mail.gmail.com>
>>> Content-Type: text/plain; charset=UTF-8
>>>
>>> -1
>>>
>>> Wasn't there a similar proposal to this last year?
>>>
>>> On 10 May 2013 22:04, Simon Hengel <sol at typeful.net> wrote:
>>>> -1
>>>>
>>>> Personally I think forM_ is the way to go.
>>>>
>>>> On Fri, May 10, 2013 at 02:13:45PM +0800, Niklas Hamb?chen wrote:
>>>>> I would like to propose the addition of
>>>>>
>>>>> whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
>>>>> whenJust (Just x) f = f x
>>>>> whenJust _ _ = return ()
>>>>>
>>>>> to Control.Monad, in the section
>>>>>
>>>>> "Conditional execution of monadic expressions"
>>>>>
>>>>> next to
>>>>>
>>>>> guard :: MonadPlus m => Bool -> m ()
>>>>> when :: Monad m => Bool -> m () -> m ()
>>>>> unless :: Monad m => Bool -> m () -> m ()
>>>>>
>>>>>
>>>>> Why?
>>>>>
>>>>> It would allow us to write more readable code and fit well into
>>>>> the group of similar functions of this style.
>>>>>
>>>>> Compare
>>>>>
>>>>> mUser <- lookupUser
>>>>>
>>>>> whenJust mUser email
>>>>>
>>>>> or
>>>>>
>>>>> whenJust mUser $ \user -> do
>>>>> putStrLn "Mailing!"
>>>>> email user
>>>>>
>>>>> with some currently available alternatives:
>>>>>
>>>>>
>>>>> case mUser of
>>>>> Just user -> do putStrLn "Mailing!"
>>>>> email user
>>>>> Nothing -> return ()
>>>>>
>>>>> (Default base case clutter.)
>>>>>
>>>>>
>>>>> import Data.Foldable
>>>>>
>>>>> forM_ mUser $ \user -> do
>>>>> putStrLn "Mailing!"
>>>>> email user
>>>>>
>>>>> (Not too intuitive/well-named here and "Ambiguous occurrence
>>>>> forM_" clash with Control.Monad.)
>>>>>
>>>>> Some more dissatisfying alternatives:
>>>>>
>>>>>
>>>>> maybe (return ()) (\user -> do putStrLn
More information about the Libraries
mailing list