The Haskell 2010 report contains ambiguous and sometimes contradictory
definitions of the terms "simple pattern binding" and "declaration
group". The confusion is compounded by the phrasing of the
monomorphism restriction, which is carried over from the Haskell98
report in which a different definition of declaration group required a
more complicated description of the monomorphism restriction.
A recent thread on the haskell cafe mailing list summarizes the
problem:
http://www.haskell.org/pipermail/haskell-cafe/2011-June/093488.html
To resolve this confusion, I propose applying the following changes to
the Haskell 2010 report for the next revision of the language:
In section "4.4.3.2 Pattern bindings", replace:
- A pattern binding binds variables to values. 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. See the translation in Section 3.12.
With the following:
A pattern binding binds variables to values. A /simple/
pattern binding is one in which the pattern consists of a
single variable, yielding a declaration of the form /var/
/rhs/. Recall from section 3.17 that such a pattern is always
irrefutable.
In section 4.5.1, replace this text:
- A binding b1 depends on a binding b2 in the same list of
- declarations if either
-
- 1. b1 contains a free identifier that has no type signature
- and is bound by b2, or
with the following:
A binding b1 depends on a binding b2 in the same list of
declarations if either
1. b1 contains a free identifier v, v is bound by b2, and the
list of declarations does not contain a type signature for
v; or
Add the following text to the end of section 4.5.1:
For example, the following two bindings form a single
declaration group, as each contains a free identifier bound by
the other and, despite the presence of expression
type-signatures, the declaration list contains no type
signatures:
(x, y) = (z :: Int, 1 :: Int) -- binds y, has z free
(z, t) = (2 :: Int, y :: Int) -- binds z, has y free
Conversely, the following two bindings constitute two
different declaration groups. Even though f and g contain
each other as free identifiers, the declaration list contains
a type signature for f, so g does not depend on f.
f :: (Eq a) => (a, a) -> (Bool, a)
f = \(x, y) -> (x == y, snd (g (x, y)))
g pair = (fst (f pair), snd pair)
Note that if b is a function binding or simple pattern binding
and b is accompanied by a type signature, then b always
constitutes a /singleton/ declaration group, regardless of
what free identifiers it contains. (If b is a non-simple
pattern binding, it may bind multiple variables
simultaneously.)
Finally, change Rule 1 of the monomorphism restriction in section
4.5.5, by replacing the following text:
- We say that a given declaration group is unrestricted if and
- only if:
-
- (a): every variable in the group is bound by a function
- binding or a simple pattern binding (Section 4.4.3.2),
- and
-
- (b): an explicit type signature is given for every variable in
- the group that is bound by simple pattern binding.
with the following:
We say that a given declaration group is unrestricted if and
only if:
(a): every variable in the group is bound by a function
binding, or
(b): the group consists of exactly one binding, the binding is
a simple pattern binding of some variable v, and the
binding's declaration list contains an explicit type
signature for v.
If there is agreement on these changes or something along these lines,
I can create a ticket and/or wiki page. I propose the name
SimplePatternBinding for the change.
David