Send Beginners mailing list submissions to
beginners@haskell.org
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
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: Maybe, Either (Michael Snoyman)
2. Re: Maybe, Either (Michael P Mossey)
3. Re: Maybe, Either (Brent Yorgey)
4. Re: Maybe, Either (Brandon S. Allbery KF8NH)
5. Re: Maybe, Either (Yusaku Hashimoto)
6. Re: Maybe, Either (Conor McBride)
7. Re: Maybe, Either (Heinrich Apfelmus)
----------------------------------------------------------------------
Message: 1
Date: Mon, 14 Sep 2009 21:42:22 +0300
From: Michael Snoyman <mich...@snoyman.com>
Subject: Re: [Haskell-beginners] Maybe, Either
To: Brent Yorgey <byor...@seas.upenn.edu>
Cc: beginners@haskell.org
Message-ID:
<29bf512f0909141142m1d5129f0t6a744d691cc16...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
On Sun, Sep 13, 2009 at 3:40 PM, Brent Yorgey <byor...@seas.upenn.edu>wrote:
> On Sat, Sep 12, 2009 at 09:13:58PM +0300, Michael Snoyman wrote:
> > I often times have to write a lookup function that returns its value into
> > any monad instead of just Maybe. For example:
> >
> > mLookup :: (Eq k, Monad m) => k -> [(k, v)] -> m v
> > mLookup k pairs = case lookup k pairs of
> > Nothing -> fail "mLookup: nothing found"
> > Just v -> return v
> >
>
> This is actually the type that the lookup function USED to have, but
> it was changed since monads actually have nothing to do with failing
> (the fail method is just a hack used to handle pattern-match failures
> in do-notation). Probably a better implementation of this would be
>
> mLookup :: (Eq k, MonadPlus m) => k -> [(k,v)] -> m v
> mLookup k pairs = maybe mzero return (lookup k pairs)
>
>
I understand that fail being in Monad is controversial, but my version of
the function works in *all* monads. This is very useful for:
1) Quickly writing up code in the IO monad (ie, for a shell script)
2) Check out the data-objects library; having an mLookup function makes
dealing with mappings very convenient.
Michael
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://www.haskell.org/pipermail/beginners/attachments/20090914/437f6726/attachment-0001.html
------------------------------
Message: 2
Date: Mon, 14 Sep 2009 13:39:04 -0700
From: Michael P Mossey <m...@alumni.caltech.edu>
Subject: Re: [Haskell-beginners] Maybe, Either
To: Michael Snoyman <mich...@snoyman.com>, beginners
<beginners@haskell.org>
Message-ID: <4aaea9e8.9070...@alumni.caltech.edu>
Content-Type: text/plain; charset=UTF-8; format=flowed
Michael Snoyman wrote:
> Can you give me a better idea of what you mean by catching errors? That
> could mean a lot of things.
>
> Michael
Hi Michael,
I mean that I need my software not to exit the program on an error condition,
but have a higher level "catch" of that condition which handles it gracefully.
I'm writing a musical score editor for personal use in my spare hobby time.
Because it's just a bit of spare time, I can't make a promise my software won't
have bugs. When I'm working on a score, I don't want to lose my work when an
error occurs, such as internal errors that violate the invariants I've
established in my data structures. So any action that results in an error
should
trigger a message box that says "such-and-such error" and otherwise leave the
data unchanged. Then I can save my work and attempt to debug the problem.
Thanks,
Mike
------------------------------
Message: 3
Date: Mon, 14 Sep 2009 20:08:08 -0400
From: Brent Yorgey <byor...@seas.upenn.edu>
Subject: Re: [Haskell-beginners] Maybe, Either
To: beginners@haskell.org
Message-ID: <20090915000808.ga12...@seas.upenn.edu>
Content-Type: text/plain; charset=us-ascii
On Mon, Sep 14, 2009 at 09:42:22PM +0300, Michael Snoyman wrote:
> On Sun, Sep 13, 2009 at 3:40 PM, Brent Yorgey <byor...@seas.upenn.edu>wrote:
>
> > On Sat, Sep 12, 2009 at 09:13:58PM +0300, Michael Snoyman wrote:
> > > I often times have to write a lookup function that returns its value into
> > > any monad instead of just Maybe. For example:
> > >
> > > mLookup :: (Eq k, Monad m) => k -> [(k, v)] -> m v
> > > mLookup k pairs = case lookup k pairs of
> > > Nothing -> fail "mLookup: nothing found"
> > > Just v -> return v
> > >
> >
> > This is actually the type that the lookup function USED to have, but
> > it was changed since monads actually have nothing to do with failing
> > (the fail method is just a hack used to handle pattern-match failures
> > in do-notation). Probably a better implementation of this would be
> >
> > mLookup :: (Eq k, MonadPlus m) => k -> [(k,v)] -> m v
> > mLookup k pairs = maybe mzero return (lookup k pairs)
> >
> >
> I understand that fail being in Monad is controversial, but my version of
> the function works in *all* monads. This is very useful for:
It doesn't work in *all* monads -- it only works in monads which
support a sensible notion of failure. This is exactly what is
captured by the MonadPlus constraint on my version of mLookup. And,
in fact, any monad in context of which you would want to use mLookup
(IO, Maybe, [], ...) are already instances of MonadPlus.
Also, fail being in Monad isn't controversial, it's just wrong. =) The
only controversial thing is what to DO about it now that it's there...
-Brent
------------------------------
Message: 4
Date: Mon, 14 Sep 2009 23:21:17 -0400
From: "Brandon S. Allbery KF8NH" <allb...@ece.cmu.edu>
Subject: Re: [Haskell-beginners] Maybe, Either
To: Michael Snoyman <mich...@snoyman.com>
Cc: beginners@haskell.org
Message-ID: <a2c7cb11-8671-488c-85b8-e833d696f...@ece.cmu.edu>
Content-Type: text/plain; charset="us-ascii"
Skipped content of type multipart/alternative-------------- next part
--------------
A non-text attachment was scrubbed...
Name: PGP.sig
Type: application/pgp-signature
Size: 195 bytes
Desc: This is a digitally signed message part
Url :
http://www.haskell.org/pipermail/beginners/attachments/20090914/cfd50e58/PGP-0001.bin
------------------------------
Message: 5
Date: Tue, 15 Sep 2009 15:14:28 +0900
From: Yusaku Hashimoto <nonow...@gmail.com>
Subject: Re: [Haskell-beginners] Maybe, Either
To: Michael Snoyman <mich...@snoyman.com>
Cc: beginners@haskell.org
Message-ID:
<d17c24b90909142314p43ae205aiaae2919a42a86...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
I prefer Alternative to MonadPlus for explaining failure. It has
better name and operator for failure and try-another.
import Control.Applicative
aLookup :: (Alternative f, Eq k) => k -> [(k,v)] -> f v
aLookup key pairs = maybe empty pure $ lookup key pairs
-nwn
On Tue, Sep 15, 2009 at 12:21 PM, Brandon S. Allbery KF8NH
<allb...@ece.cmu.edu> wrote:
> On Sep 14, 2009, at 14:42 , Michael Snoyman wrote:
>
> I understand that fail being in Monad is controversial, but my version of
> the function works in *all* monads. This is very
>
> Not really; "fail" in non-MonadPlus-es is a rather poorly defined notion,
> and there are no guarantees that the result will be at all sane. Â "mzero" is
> well defined.
> --
> brandon s. allbery [solaris,freebsd,perl,pugs,haskell] allb...@kf8nh.com
> system administrator [openafs,heimdal,too many hats] allb...@ece.cmu.edu
> electrical and computer engineering, carnegie mellon university   KF8NH
>
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>
------------------------------
Message: 6
Date: Tue, 15 Sep 2009 09:21:02 +0100
From: Conor McBride <co...@strictlypositive.org>
Subject: Re: [Haskell-beginners] Maybe, Either
To: beginners@haskell.org
Message-ID:
<3f9a8109-2b66-4791-9201-f635ee837...@strictlypositive.org>
Content-Type: text/plain; charset=US-ASCII; format=flowed; delsp=yes
Hi
This topic comes up a lot, and this is what I usually say when
it does. It's a thing I learned from James McKinna, many years
ago...
Might I gently suggest that there is a much better, more
natural way to abstract over every type-former which has
some sort of return/pure-like thing and some sort of mzero/empty
like thing? You could use the type-former which is inductively
defined to be the least such thing, and as such has a canonical
mapping to all the others, namely Maybe.
It's not necessarily a good idea to fix on Monad or MonadPlus
as there are other choices. For example,
On 15 Sep 2009, at 07:14, Yusaku Hashimoto wrote:
> I prefer Alternative to MonadPlus for explaining failure. It has
> better name and operator for failure and try-another.
>
> import Control.Applicative
>
> aLookup :: (Alternative f, Eq k) => k -> [(k,v)] -> f v
> aLookup key pairs = maybe empty pure $ lookup key pairs
there are notorious non-monadic instances for the above f
(some formulations of parsing, in particular). So,
>> I understand that fail being in Monad is controversial, but my
>> version of
>> the function works in *all* monads.
this is a touch presumptuous. On the one hand, Brent is right
when he says
> It doesn't work in *all* monads -- it only works in monads which
> support a sensible notion of failure.
but he's perhaps excessive when he says
> This is exactly what is captured by the MonadPlus constraint
> on my version of mLookup.
because it's not exact: it requires mplus as well as a sensible
notion of failure. And yes, why should we insist on (>>=) when
we just need a return and an mzero? Incidentally, I don't know
where the MonadPlus instance
> (IO, Maybe, [], ...) are already instances of MonadPlus.
of IO is coming from, but I want it caught and locked up now (in
STM, for example) before it does any permanent damage.
Why not factor out the failure-prone operations from the business
of interpreting failure in some failure-supporting context? Work
concretely while you can (types stay shorter, error messages make
more sense) then apply adapters
malt :: Alternative f => Maybe x -> f x
malt = maybe empty pure
mop :: MonadPlus m => Maybe x -> m x
mop = maybe mzero return
when you need to? This also reduces the risk of connecting an
ambiguous supplier to an ambiguous consumer, (show . read) style.
The message clearly bears repeating. Inductive definition is
a concrete form of abstraction. Don't be fooled by its
appearance: Maybe is the most abstract choice here -- the
classier options demand more structure than is needed and
thus exclude use-cases.
I'll crawl back under my stone now.
All the best
Conor
------------------------------
Message: 7
Date: Tue, 15 Sep 2009 12:25:43 +0200
From: Heinrich Apfelmus <apfel...@quantentunnel.de>
Subject: [Haskell-beginners] Re: Maybe, Either
To: beginners@haskell.org
Message-ID: <h8nq39$u9...@ger.gmane.org>
Content-Type: text/plain; charset=ISO-8859-1
Conor McBride wrote:
>
> malt :: Alternative f => Maybe x -> f x
> malt = maybe empty pure
>
> mop :: MonadPlus m => Maybe x -> m x
> mop = maybe mzero return
>
> The message clearly bears repeating. Inductive definition is
> a concrete form of abstraction. Don't be fooled by its
> appearance: Maybe is the most abstract choice here -- the
> classier options demand more structure than is needed and
> thus exclude use-cases.
Seconded! Maybe is the most general choice.
The only issue left here would be that the combinators malt and mop
are missing from the standard library. Once again, their purpose is not
generality, but the convenience of overloading.
Regards,
apfelmus
--
http://apfelmus.nfshost.com
------------------------------
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 15, Issue 9
****************************************
