wiki:NoNPlusKPatterns

Version 2 (modified by igloo, 5 years ago) (diff)

--

Proposal: NoNPlusKPatterns

Ticket #130
Dependencies none
Related ViewPatterns

Compiler support

GHC full (-XNoNPlusKPatterns from 6.12)
nhc98 full (--nonplusk)
Hugs none?
UHC full (doesn't support n+k patterns at all)
JHC none?
LHC none?

Summary

Remove n+k patterns.

Description

n+k patterns provide a concise, natural, and familiar notation for recursion over naturals. When used with non-negative types, such as Word, they allow functions to be cleanly defined using non-overlapping patterns.

However, n+k patterns are a non-orthogonal feature. No other pattern has special notation like this, although there is a ViewPatterns extension which does something not entirely dissimilar in a general way.

The + symbol is being abused here; it doesn't really mean +, and if + happens to be bound to something other than Prelude.+ the notation's behaviour doesn't change. Counterintuitively, the desugaring does include references to a number of other Prelude definitions: Integral, - and >=.

Working on all Integral types is inconsistent with the n >= 0 condition, which means that n is really a natural number.

There has long been a general consensus in the community that n+k patterns should be removed. Indeed, the report already admits "Many people feel that n+k patterns should not be used. These patterns may be removed or changed in future versions of Haskell." (Haskell 98 Revised Report, Section 3.17.2).

References

Haskell 98 Revised Report, Section 3.17.2

Report Delta

In Section 3.17.1 replace:

pat    ->    var + integer    (successor pattern)
       |     pat0

with:

pat    ->    pat0

In Section 3.17.2 remove:

  1. Matching an n+k pattern (where n is a variable and k is a positive integer literal) against a value v succeeds if x >= k, resulting in the binding of n to x - k, and fails otherwise. Again, the functions >= and - are overloaded, depending on the type of the pattern. The match diverges if the comparison diverges.

The interpretation of the literal k is the same as in numeric literal patterns, except that only integer literals are allowed.

and renumber.

In Section 3.17.2 remove:

  • An n+k pattern can only be matched against a value in the class Integral.

Many people feel that n+k patterns should not be used. These patterns may be removed or changed in future versions of Haskell.

In Section 3.17.3 remove:

(s)
	case v of { x+k -> e; _ -> e' }
	= if v >= k then (\x -> e) (v-k) else e'
	where k is a numeric literal

In Section 4.4.3.2 remove:

A note about syntax.

It is usually straightforward to tell whether a binding is a pattern binding or a function binding, but the existence of n+k patterns sometimes confuses the issue. Here are four examples:

  x + 1 = ... -- Function binding, defines (+)
-- Equivalent to   (+) x 1 = ...

  (x + 1) = ... -- Pattern binding, defines x

  (x + 1) * y = ... -- Function binding, defines (*)
-- Equivalent to   (*) (x+1) y = ...

  (x + 1) y = ... -- Function binding, defines (+)
-- Equivalent to   (+) x 1 y = ...

The first two can be distinguished because a pattern binding has a pat0 on the left hand side, not a pat --- the former cannot be an unparenthesised n+k pattern.