CODEWITHSUNDEEP
haskellf#functional-programmingpattern-matchingguard-clause
Dario
Dario

Reputation: 49218

Pattern matching identical values

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?

Upvotes: 23

Views: 8136

Answers (4)

egi
egi

Reputation: 41

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)]}))

Upvotes: -4

Alexey
Alexey

Reputation: 4061

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.)

Upvotes: 0

Thomas
Thomas

Reputation: 181745

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/[email protected]/msg59617.html

http://www.mail-archive.com/[email protected]/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

Upvotes: 44

sth
sth

Reputation: 229593

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.

Upvotes: 16

Related Questions