Pattern guards

[Yitzchak Gale]

I would like to suggest a correction to ticket #56,
"Pattern Guards".

It is easy to show that every expression written
using pattern guards can also be written in
Haskell 98 in a way that is essentially
equivalent in simplicity. (Proof below.)

In my opinion, the Haskell 98 version below is
more clear than the pattern guard version - it
makes the monad explicit. Even if you disagree,
I think it would be very difficult to argue that the
difference is important enough to justify the extreme
measure of adding new syntax to the language.

Therefore, the first two items under "Pros" are
false, and should be removed. The only remaining
"Pro" is that the extension is well-specified, which
has no value on its own.

The purpose of Haskell' is to remove warts from
Haskell, not add new ones. Pattern guards are
a serious wart - they further overload syntax that
is arguably already overused, as pointed out
in the referenced paper by Martin Erwig and
Simon Peyton Jones [EPJ].

I hope that there is still time to retract the evil decree
of "definitely in" Proposal Status for this ticket.

Regards,
Yitz

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

Now given any function binding using pattern guards:

funlhs
 | qual11, qual12, ..., qual1n = exp1
 | qual21, qual22, ..., qual2n = exp2
 ...

we translate the function binding into Haskell 98 as:

funlhs = runExit $ do
  maybeExit $ do {qual11'; qual12'; ...; qual1n'; return (exp1)}
  maybeExit $ do {qual21'; qual22'; ...; qual2n'; return (exp2)}
  ...

where

  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

For a conventional guard:

 | p = exp

we can simplify the translation to:

  when (p) $ Exit (exp)

Simplifications are also possible for other special cases.

This concludes the proof. Here are some examples, taken
from [EPJ]:

> clunky env var1 var2
>  | Just val1 <- lookup env var1
>  , Just val2 <- lookup env var2
>  = val1 + val2
>  ...other equations for clunky

translates to:

> clunky env var1 var2 = runExit $ do
>   maybeExit $ do
>     val1 <- lookup env var1
>     val2 <- lookup env var2
>     return (val1 + val2)
>  ...other equations for clunky

> filtSeq :: (a->Bool) -> Seq a -> Seq a
> filtSeq p xs
>  | Just (y,ys) <- lview xs, p y = lcons y (filtSeq p ys)
>  | Just (y,ys) <- lview xs      = filtSeq p ys
>  | otherwise                    = nil

translates to:

> filtSeq :: (a->Bool) -> Seq a -> Seq a
> filtSeq p xs = runExit $ do
>   maybeExit $ do
>     (y,ys) <- lview xs
>     guard $ p y
>     return $ lcons y $ filtSeq p ys
>   maybeExit $ do
>     (y,ys) <- lview xs
>     return $ filtSeq p ys
>   Exit nil

Note that in this case, the Maybe monad alone is
sufficient. That eliminates both the double lookup and
the double pattern match, as discussed in [EPJ]:

> filtSeq :: (a->Bool) -> Seq a -> Seq a
> filtSeq p xs = fromMaybe nil $ do
>   (y,ys) <- lview xs
>   return $ if (p y)
>     then lcons y (filtSeq p ys)
>     else filtSeq p ys