Pattern matching identical values

Question

I just wondered whether it's possible to match against the same values for multiple times with the pattern matching facilities of functional programming languages (Haskell/F#/Caml).

Just think of the following example:

plus a a = 2 * a
plus a b = a + b

The first variant would be called when the function is invoked with two similar values (which would be stored in a).

A more useful application would be this (simplifying an AST).

simplify (Add a a) = Mult 2 a

But Haskell rejects these codes and warns me of conflicting definitions for a - I have to do explicit case/if-checks instead to find out whether the function got identical values. Is there any trick to indicate that a variable I want to match against will occur multiple times?

Answer 1

This is called a nonlinear pattern. There have been several threads on the haskell-cafe mailing list about this, not long ago. Here are two:

http://www.mail-archive.com/[e-mail]/msg59617.html

http://www.mail-archive.com/[e-mail]/msg62491.html

Bottom line: it's not impossible to implement, but was decided against for sake of simplicity.

By the way, you do not need if or case to work around this; the (slightly) cleaner way is to use a guard:

a `plus` b
  | a == b = 2*a
  | otherwise = a+b

Answer 2

I have just looked up the mailing list threads given in Thomas's answer, and the very first reply in one of them makes good sense, and explains why such a "pattern" would not make much sense in general: what if a is a function? (It is impossible in general to check it two functions are equal.)

Answer 3

I have implemented a new functional programming language that can handle non-linear patterns in Haskell.

https://github.com/egison/egison

In my language, your plus function in written as follow.

(define $plus
  (match-lambda [integer integer]
    {[[$a ,a] (* a 2)]
     [[$a $b] (+ a b)]}))

Answer 4

Haskell doesn't do unification.

Answer 5

You can't have two parameters with the same name to indicate that they should be equal, but you can use guards to distinguish cases like this:

plus a b
  | a == b    = 2 * a
  | otherwise = a + b

This is more flexible since it also works for more complicated conditions than simple equality.