Pattern guards

[David Roundy]

On Sun, Oct 01, 2006 at 02:08:35AM +0200, Yitzchak Gale wrote:
> David Roundy wrote:
> >>foo (Left "bar") = "a"
> >>foo (Right x) | (b,"foo") <- break (==' ') x = "b " ++ b
> >>              | ["Hello",n,"how","are","you",d@(_:_)] <- words x,
> >>                last d == '?'
> >>        = n ++ " is not here right now, but " ++ n ++ " is " ++
> >>          init d ++ " fine."
> >>foo (Left x) | ("foo",c) <- break (==' ') x = "c " ++ c
> >>             | length x == 13 = "Unlucky!"
> >>foo (Right x) = x
> >>foo (Left x) = x
> 
> And here it is in Haskell 98:
> 
> >foo (Left "bar") = "a"
> >foo (Right x) | isExit y = runExit y
> > where y = do
> >  maybeExit $ do (b,"foo") <- return $ break (==' ') x
> >                 return $ "b" ++ b
> >  maybeExit $ do ["Hello",n,"how","are","you",d@(_:_)] <- return $ words x
> >                 guard $ last d == '?'
> >                 return $ n ++ " is not here right now, but " ++
> >                          n ++ " is " ++ init d ++ " fine."
> >foo (Left x) | isExit y = runExit y
> > where y = do
> >  maybeExit $ do ("foo",c) <- break (==' ') x
> >                 return $ "c" ++ c
> >  when (length x == 13) $ Exit "Unlucky!"
> >foo (Right x) = x
> >foo (Left x) = x

I disagree as far as the beauty of this approach.  You require that
every pattern guard involves a where binding, plus the use of a three
function calls (isExit, runExit and maybeExit, plus sometimes one or
more calls to guard).  In my opinion that makes it less concise than
the usual pattern matching approach.

One extra where binding may not much matter in simple functions like
this, but in complicated functions that are already hard to read and
understand (because they do complicated things, not because they're
poorly written), throwing in extra where bindings is just a waste.

Also, in your code you're forced to mingle the "pattern matching" with
the actual code itself, which to me makes the result less legible.
And would be even worse if the function were one that returns a
monadic result, so the reader would be forced to distinguish between
the do in the Exit monad and the do in the output monad.

Pattern guards feel very natural, are very easy to read, and won't
bother you if you don't use them.  As you point, they're just
syntactic sugar, and therefore are "safe", in that they can't lead to
any weird or confusing semantics.
-- 
David Roundy