# [Haskell-cafe] What is a "simple pattern binding"?

Sat Jun 25 16:52:13 CEST 2011

```Section 4.4.3.2 of the 2010 Haskell report says:

A simple pattern binding has form p = e. The pattern p is
matched “lazily” as an irrefutable pattern, as if there were
an implicit ~ in front of it.

This makes it sound as though p is a pattern, which I assume means
what section 3.17 defines as the non-terminal "pat".

pat -> lpat qconop pat | lpat

This is further suggested by the explicit mention of ~, which would be
redundant if p had to be a var, since variables always match
(according to section 3.17.2 rule 1).  So my reading of section
4.4.3.2 is that the following is considered a simple pattern binding
(because it has no guards):

(f, g) = (\x -> x, f)

However, section 4.5.5 seems to contradict this.  It reads:

Recall that a variable is bound by either a function binding
or a pattern binding, and that a simple pattern binding is a
pattern binding in which the pattern consists of only a single
variable (Section 4.4.3).

Moreover, it goes on to give an example and explanation:

[(n,s)] = reads t
... Hence, when non-simple pattern bindings are used

This text makes it sound as though a "simple pattern binding" can have
only a single variable to the left of the = sign, meaning:

f = \x -> x

Further confusing things, GHC accepts the following:

g1 x y z = if x>y then show x ++ show z else g2 y x

g2 :: (Show a, Ord a) => a -> a -> String
g2 | False     = \p q -> g1 q p ()
| otherwise = \p q -> g1 q p 'a'
where x = True

and infers type:

g1 :: (Show a, Show a1, Ord a1) => a1 -> a1 -> a -> [Char]

According to 4.4.3.2, g2 definitely does not have a simple pattern
binding, as its binding is not of the form p = e where p is a pattern.
Yet by section 4.5.5, if g2 were not considered a simple pattern
binding, the constrained type variables in the binding group
containing g1 and g2 (in particular the inferred type (Show a => a) of
z in g1) would not be allowed to be generalized.

So is section 4.4.3.2 of the Haskell 2010 report just wrong?  Or is
GHC allowing code prohibited by the standard?  Or am I somehow