Pattern guards

[Yitzchak Gale]

Thanks for all the responses. I get the digest,
and I was off-line for a day, so I only saw most
of them now.  Also, for the same reason, my
apologies that I am connecting this message to the
wrong spot in the thread.

First of all, I still maintain that any expression
written using pattern guards can be written just
as simply - and, in my opinion, more clearly - in
Haskell 98 using monads.

An important clarification: the main monad at work
here is the Exit monad. The "bind" notation in a
pattern guard is just an obfuscated Exit monad.
However, in many simple examples, the Maybe monad
can be used as a special case of the Exit monad.

It is true that in my proof I also use a nested
Maybe monad, but that is only for the
comma-separated sequence of multiple qualifiers in
a complex pattern guard.

Conor McBride wrote:
> Whether or not your conclusion is correct, your
> candidate proof is incomplete...  This
> translation does not appear to address programs
> with multiple left-hand sides, exploiting
> fall-through from match (hence guard) failure

Quite right, sorry. That is easy to fix.  A
corrected proof is at the bottom of this message.

David Roundy wrote:
> If all your pattern guards happen to involve the
> Maybe monad, then perhaps you can rewrite the
> pattern guard code almost as concisely using
> monadic notation

No, it works for any type.

> the moment you choose to do that you have to
> completely give up on using Haskell's existing
> pattern matching to define your function, unless
> you happen to be defining a particularly simple
> function.

No, all pattern matching is retained as before.

> How do you nearly as concisely write a function
> such as this in Haskell 98?

Hmm, believe it or not, your original example is
too simple. You can actually do the whole thing in
the Maybe monad, because none of the versions of
foo has more than one pattern guard.  I am
transposing the third and fourth foo and combinig
like LHSs to make it more interesting. Here is
your function with those modifications:

>> 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

Finally, here is the corrected proof, allowing for
multiple LHSs. Actually, the proof is still not
complete - I do not treat pattern bindings, nor
other possible forms for funlhs, as enumerated in
the Report.

Proof: We first assume that the following declarations
are available, presumably from a library:

> data Exit e a = Continue a | Exit {runExit :: e}
> instance Monad (Exit e) where
>   return = Continue
>   Continue x >>= f = f x
>   Exit e >>= _ = Exit e

(Note that this is essentially the same as the Monad
instance for Either defined in Control.Monad.Error,
except without the restriction that e be an instance
of Error.)

> maybeExit :: Maybe e -> Exit e ()
> maybeExit = maybe (return ()) Exit

> isExit :: Exit e a -> Bool
> isExit (Exit _) = True
> isExit _        = False

Now given any function binding using pattern guards:

var apat1 apat2 ... apatn
 | qual11, qual12, ..., qua11n = exp1
 | qual21, qual22, ..., qual2n = exp2
 ...
we translate the function binding into Haskell 98 as:

var apat1 apat2 ... apatn | isExit y = runExit y where {y = do
 maybeExit $ do {qual11'; qual12'; ...; qual1n'; return (exp1)}
 maybeExit $ do {qual21'; qual22'; ...; qual2n'; return (exp2)}
 ...}

where

 y is a new variable
 qualij' -> pat <- return (e) if qualij is pat <- e
 qualij' -> guard (qualij) if qualij is a boolean expression
 qualij' -> qualij if qualij is a let expression

-Yitz