Pattern matching functions in Clojure?

Question

I have used erlang in the past and it has some really useful things like pattern matching functions or "function guards". Example from erlang docs is:

fact(N) when N>0 -> 
    N * fact(N-1); 
fact(0) ->      
    1.

But this could be expanded to a much more complex example where the form of parameter and values inside it are matched.

Is there anything similar in clojure?

This is an old question but this project expands core.match to functions and is almost exactly what I was asking years ago https://github.com/killme2008/defun — mikkom, Nov 13 '15 at 09:38

score 33 · Accepted Answer · answered Dec 21 '11 at 22:31

33

There is ongoing work towards doing this with unification in the core.match ( https://github.com/clojure/core.match ) library.

Depending on exactly what you want to do, another common way is to use defmulti/defmethod to dispatch on arbitrary functions. See http://clojuredocs.org/clojure_core/clojure.core/defmulti (at the bottom of that page is the factorial example)

answered Dec 21 '11 at 22:31

gilesc

1,969
1
14
16

3

core.match is almost exactly what I'm looking for on the code level, is this part of the core of 1.3 (I don't exactly understand how the clojure packaging works)? With some macros I think it would be possible to extend the syntax to functions (IMHO in erlang the clearest code could be written with pattern matching functions with guards) – mikkom Dec 22 '11 at 08:04
It requires 1.3 but is not part of 1.3 by default. If you are using Leiningen (https://github.com/technomancy/leiningen) -- and you should be -- then you add a line '[org.clojure/core.match "0.2.0-alpha8"]' to your project.clj's dependencies, then run lein deps. And yes as you can see at the bottom of their github page, the devs plan to apply core.match to functions (predicate dispatch) soon. – gilesc Dec 22 '11 at 20:33
If anyone else runs into trouble pattern matching function arguments, use `vec`: http://nickknowlson.com/blog/2013/02/17/using-core-match-with-function-arguments/ – Nick Knowlson Feb 17 '13 at 21:28

score 19 · Answer 2 · answered Sep 19 '14 at 14:29

I want to introduce defun, it's a macro to define functions with pattern matching just like erlang,it's based on core.match. The above fact function can be wrote into:

(use 'defun)
(defun fact
  ([0] 1)
  ([(n :guard #(> % 0))] 
    (* n (fact (dec n)))))

Another example, an accumulator from zero to positive number n:

(defun accum
  ([0 ret] ret)
  ([n ret] (recur (dec n) (+ n ret)))
  ([n] (recur n 0)))

More information please see https://github.com/killme2008/defun

@killme2008, I really like your work with defun. What are the advantages of defun over core.match? — David Shaked, Aug 20 '16 at 18:57

score 9 · Answer 3 · answered Dec 21 '11 at 22:30

9

core.match is a full-featured and extensible pattern matching library for Clojure. With a little macro magic and you can probably get a pretty close approximation to what you're looking for.

answered Dec 21 '11 at 22:30

Dave Ray

39,616
7
83
82

score 3 · Answer 4 · answered Dec 22 '11 at 07:03

3

Also, if you want to take apart only simple structures like vectors and maps (any thing that is sequence or map, e.g. record, in fact), you could also use destructuring bind. This is the weaker form of pattern matching, but still is very useful. Despite it is described in let section there, it can be used in many contexts, including function definitions.

answered Dec 22 '11 at 07:03

Vladimir Matveev

120,085
34
287
296

2

Destructuring is quite a bit too limited for real pattern matching. – mikkom Dec 22 '11 at 08:02

Pattern matching functions in Clojure?

4 Answers4

Linked