Dan Doel writes:

There was talk of adding a readMaybe a while ago, but apparently it never happened.

As it is, you can use reads, "read s" becomes:

case reads s of [(a, rest)] | all isSpace rest -> <code using a> _ -> <error case>

which ensures that you have an unambiguous parse with only trailing whitespace. You can, of course, modify that if you don't care about ambiguity or trailing characters.

I was wondering about a more algebraic way of writing that; here's a version (that doesn't care about ambiguity) readMaybe :: Read a => String -> Maybe a readMaybe = join . fmap no_trailing_garbage . listToMaybe . reads where no_trailing_garbage = fmap fst . check (all isSpace . snd) check :: (MonadPlus m) => (a -> Bool) -> a -> m a check p a | p a = return a | otherwise = mzero I tried Hoogling for a function like check, but couldn't find it. Surely there's one in a library somewhere? It looks useful to me. (I'm rather taken by way the "check (all isSpace . snd)" part reads) Monad.guard comes close but fails to get the cigar; in fact guard b == check (const b) () So check is more general. Also, I don't see a singletonListToMaybe that one could use in place of listToMaybe to require unambiguity. Could do isSingleton [a] = True isSingleton _ = False and then use "listToMaybe . join . check isSingleton" -- aha! Another use for check! Jón [Footnote: I thought of writing "guard == flip (check . const) ()" but then realised it was pointless] -- Jón Fairbairn Jon.Fairbairn@cl.cam.ac.uk

On Thursday 02 July 2009 6:36:09 am Jon Fairbairn wrote:

check :: (MonadPlus m) => (a -> Bool) -> a -> m a check p a | p a = return a | otherwise = mzero

I tried Hoogling for a function like check, but couldn't find it. Surely there's one in a library somewhere? It looks useful to me. (I'm rather taken by way the "check (all isSpace . snd)" part reads)

Monad.guard comes close but fails to get the cigar; in fact

guard b == check (const b) ()

So check is more general.

I've often noticed the need for a similar function in conjunction with unfoldr: -- This is overly general for unfoldr, but it lines up with check stopAt :: (MonadPlus m) => (a -> Bool) -> (a -> b) -> a -> m b stopAt p f x | p x = mzero | otherwise = return (f x) -- stopAt p f x = guard (not $ p x) >> return (f x) -- stopAt p f = liftM2 (>>) (guard . not . p) (return . f) -- etc. Then you can write: unfoldr (stopAt p $ f) where p is a stopping predicate based on the seed, and f unfolds the seed one step. This lets you use the many functions in the standard library that have types like: s -> (a, s) where unfoldr wants them to instead be: s -> Maybe (a, s) However, I don't really like the name stopAt, and have never come up with anything better. And of course: check = flip stopAt id . not -- Dan

Dan Doel writes:

On Thursday 02 July 2009 6:36:09 am Jon Fairbairn wrote:

...

check :: (MonadPlus m) => (a -> Bool) -> a -> m a check p a | p a = return a | otherwise = mzero

I've often noticed the need for a similar function in conjunction with unfoldr:

-- This is overly general for unfoldr, but it lines up with check stopAt :: (MonadPlus m) => (a -> Bool) -> (a -> b) -> a -> m b stopAt p f x | p x = mzero | otherwise = return (f x)

Yes, I've had occasion to use something like that too, eg things similar to: reverse . unfoldr (stopAt (==0) (swap . flip divMod 10)) where swap (a,b) = (b,a)

And of course: check = flip stopAt id . not

or, equally, "stopAt p f = fmap f . check (not . p)" Granted, reverse . unfoldr (fmap (swap . flip divMod 10) . check (/=0)) isn't /quite/ as nice as the first version, but I imagine one could get used to it. -- Jón Fairbairn Jon.Fairbairn@cl.cam.ac.uk