Clojure JIRA

[MATCH-68] Vector match "underflow" => IndexOutOfBoundsException

Sat, 18 May 2013 15:11:12 -0500

This fails with 0.2.0-alpha12:

(match [[:x]]
  [[m n & _]] 1)

I expect nil, but an unguarded subvec call throws an IndexOutOfBoundsException.

A WIP patch is attached that fixes this (perhaps incorrectly) but which produced regressions (outside of core.match), e.g.

(match [[[:x "t"]]]
 [[[:x & a] & tail]] :a
 [[[:y & p] [:x & a] & tail]] :b)
=> nil

The patch also "fixes" this (by changing pattern-compare behaviour for rest VectorPattern s, but that leads to a regression in the vector-pattern-rest-2 testcase in core.match.

(Original discussion with further background here.)

[MATCH-57] Non deterministic match behavior for seqs when AOT

Sat, 18 May 2013 14:29:42 -0500

The following source example:

https://github.com/narkisr/match-issue/blob/master/src/match_issue/core.clj

The defrule macro calls a function called lhs that use the match library,

this function calls it self recursively and print out the rest of body left to be matched,

When running lein compile two different results appear (in non deterministic fashion):

(when $message :> Message (== level 6) :from (entry-point event-stream))
($message :> Message (== level 6) :from (entry-point event-stream))
(Message (== level 6) :from (entry-point event-stream))
((== level 6) :from (entry-point event-stream))

This is the bug, as (== level 6) should be matched by:

[([([(o :when operator?) f s] :seq) :as c & r] :seq)]

In other cases the output is (the correct one):

[MATCH-53] Match doesn't work when AOT compiled into a JAR, but manually macroexpanding and JAR'ing works fine.

Sat, 18 May 2013 14:25:39 -0500

Code here:

https://gist.github.com/35fa11df7d7516abff50

Running lein uberjar on source containing the offending function, geo->svg, results in a non-working application.
However, if match is manually macroexpanded in the repl and the results pasted in, then the JAR works just fine.

[MATCH-51] Fail to match empty vector

Sat, 18 May 2013 14:24:24 -0500

(match (vector)
  ([(re :guard string?)] :seq) 4
  [] 6)

This should evaluate to 6 not nil.

[MATCH-54] Cannot AOT with certain match expression.

Sat, 18 May 2013 14:22:38 -0500

If you try to AOT this code, you get an exception.

(defn -main [& args]
  (println args)
  (let [x nil] 
    (match x
      ["=" _ _] true
      [[:invoke _] _] true)))

Stack Trace:

Compiling foo.core
Exception in thread "main" java.lang.IndexOutOfBoundsException, compiling:(foo/core.clj:8)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6416)
	at clojure.lang.Compiler.analyze(Compiler.java:6216)
	at clojure.lang.Compiler.analyze(Compiler.java:6177)
	at clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5572)
	at clojure.lang.Compiler$LetExpr$Parser.parse(Compiler.java:5873)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6409)
	at clojure.lang.Compiler.analyze(Compiler.java:6216)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6397)
	at clojure.lang.Compiler.analyze(Compiler.java:6216)
	at clojure.lang.Compiler.analyze(Compiler.java:6177)
	at clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:5572)
	at clojure.lang.Compiler$FnMethod.parse(Compiler.java:5008)
	at clojure.lang.Compiler$FnExpr.parse(Compiler.java:3629)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6407)
	at clojure.lang.Compiler.analyze(Compiler.java:6216)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6397)
	at clojure.lang.Compiler.analyze(Compiler.java:6216)
	at clojure.lang.Compiler.access$100(Compiler.java:37)
	at clojure.lang.Compiler$DefExpr$Parser.parse(Compiler.java:492)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6409)
	at clojure.lang.Compiler.analyze(Compiler.java:6216)
	at clojure.lang.Compiler.analyze(Compiler.java:6177)
	at clojure.lang.Compiler.compile1(Compiler.java:6980)
	at clojure.lang.Compiler.compile(Compiler.java:7046)
	at clojure.lang.RT.compile(RT.java:385)
	at clojure.lang.RT.load(RT.java:425)
	at clojure.lang.RT.load(RT.java:398)
	at clojure.core$load$fn__4610.invoke(core.clj:5386)
	at clojure.core$load.doInvoke(core.clj:5385)
	at clojure.lang.RestFn.invoke(RestFn.java:408)
	at clojure.core$load_one.invoke(core.clj:5200)
	at clojure.core$compile$fn__4615.invoke(core.clj:5397)
	at clojure.core$compile.invoke(core.clj:5396)
	at user$eval27.invoke(NO_SOURCE_FILE:1)
	at clojure.lang.Compiler.eval(Compiler.java:6465)
	at clojure.lang.Compiler.eval(Compiler.java:6455)
	at clojure.lang.Compiler.eval(Compiler.java:6431)
	at clojure.core$eval.invoke(core.clj:2795)
	at clojure.main$eval_opt.invoke(main.clj:296)
	at clojure.main$initialize.invoke(main.clj:315)
	at clojure.main$null_opt.invoke(main.clj:348)
	at clojure.main$main.doInvoke(main.clj:426)
	at clojure.lang.RestFn.invoke(RestFn.java:421)
	at clojure.lang.Var.invoke(Var.java:405)
	at clojure.lang.AFn.applyToHelper(AFn.java:163)
	at clojure.lang.Var.applyTo(Var.java:518)
	at clojure.main.main(main.java:37)
Caused by: java.lang.IndexOutOfBoundsException
	at clojure.lang.PersistentVector.arrayFor(PersistentVector.java:106)
	at clojure.lang.PersistentVector.nth(PersistentVector.java:110)
	at clojure.lang.RT.nth(RT.java:741)
	at clojure.core.match.PatternRow.invoke(match.clj:327)
	at clojure.core.match.PatternMatrix.pattern_at(match.clj:713)
	at clojure.core.match$useful_p_QMARK_.invoke(match.clj:778)
	at clojure.core.match.PatternMatrix$iter__832__838$fn__839$iter__834__840$fn__841$fn__842.invoke(match.clj:735)
	at clojure.core.match.PatternMatrix$iter__832__838$fn__839$iter__834__840$fn__841.invoke(match.clj:733)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:466)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core.match.PatternMatrix$iter__832__838$fn__839.invoke(match.clj:734)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:67)
	at clojure.lang.RT.seq(RT.java:466)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core$partition$fn__3913.invoke(core.clj:2777)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:466)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core$map$fn__3811.invoke(core.clj:2424)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.Cons.next(Cons.java:39)
	at clojure.lang.PersistentVector.create(PersistentVector.java:50)
	at clojure.lang.LazilyPersistentVector.create(LazilyPersistentVector.java:31)
	at clojure.core$vec.invoke(core.clj:345)
	at clojure.core.match.PatternMatrix.useful_matrix(match.clj:733)
	at clojure.core.match.PatternMatrix.necessary_column(match.clj:725)
	at clojure.core.match.PatternMatrix$choose_column__815.invoke(match.clj:690)
	at clojure.core.match.PatternMatrix.compile(match.clj:708)
	at clojure.core.match$first_column_chosen_case$switch_clauses__780$fn__781.invoke(match.clj:613)
	at clojure.core$map$fn__3815.invoke(core.clj:2437)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:466)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core$reduce.invoke(core.clj:5994)
	at clojure.core$into.invoke(core.clj:6004)
	at clojure.core.match$first_column_chosen_case$switch_clauses__780.invoke(match.clj:616)
	at clojure.core.match$first_column_chosen_case.invoke(match.clj:646)
	at clojure.core.match.PatternMatrix.compile(match.clj:710)
	at clojure.core.match$first_column_chosen_case$switch_clauses__780$fn__781.invoke(match.clj:613)
	at clojure.core$map$fn__3815.invoke(core.clj:2437)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:466)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core$reduce.invoke(core.clj:5994)
	at clojure.core$into.invoke(core.clj:6004)
	at clojure.core.match$first_column_chosen_case$switch_clauses__780.invoke(match.clj:616)
	at clojure.core.match$first_column_chosen_case.invoke(match.clj:646)
	at clojure.core.match.PatternMatrix.compile(match.clj:710)
	at clojure.core.match$clj_form.invoke(match.clj:1616)
	at clojure.core.match$match.doInvoke(match.clj:1645)
	at clojure.lang.RestFn.invoke(RestFn.java:573)
	at clojure.lang.Var.invoke(Var.java:426)
	at clojure.lang.AFn.applyToHelper(AFn.java:193)
	at clojure.lang.Var.applyTo(Var.java:518)
	at clojure.lang.Compiler.macroexpand1(Compiler.java:6320)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:6395)
	... 46 more

[MATCH-59] Misleading comment in clojure.core.match.bits

Sat, 18 May 2013 14:21:34 -0500

I was looking at the code for clojure.core.match.bits, and there seems to be a reference to an example of parsing a dgram. The code looks to be broken or incomplete, or is it my understanding of it that is lacking?

If it isn't done, are there any plans to finish it up?

[MATCH-66] Cannot match entire/single value

Sat, 18 May 2013 14:18:33 -0500

=> (match 3 x x)
CompilerException java.lang.RuntimeException: Unable to resolve symbol: ocr-34984 in this context, compiling:(NO_SOURCE_PATH:1:1) 
=> (macroexpand '(match 3 x x))
(let* [x ocr-35001] x)

(Discussed briefly here.)

[MATCH-69] AOT-compiling match expression produces stack overflow

Wed, 24 Apr 2013 16:04:23 -0500

The offending match expression is pretty gnarly, will try to simplify and post it here later. For now, a (partial) stack trace, eliding the repeating bits:

Caused by: java.lang.StackOverflowError
	at clojure.core$map$fn__4207.invoke(core.clj:2479)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.ChunkedCons.chunkedNext(ChunkedCons.java:59)
	at clojure.lang.ChunkedCons.next(ChunkedCons.java:43)
	at clojure.lang.PersistentVector.create(PersistentVector.java:51)
	at clojure.lang.LazilyPersistentVector.create(LazilyPersistentVector.java:31)
	at clojure.core$vec.invoke(core.clj:354)
	at clojure.core.match.PatternMatrix.column(match.clj:713)
	at clojure.core.match$useful_p_QMARK_.invoke(match.clj:811)
	at clojure.core.match.PatternMatrix$iter__1458__1464$fn__1465$iter__1460__1466$fn__1467$fn__1468.invoke(match.clj:765)
	at clojure.core.match.PatternMatrix$iter__1458__1464$fn__1465$iter__1460__1466$fn__1467.invoke(match.clj:763)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:484)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core.match.PatternMatrix$iter__1458__1464$fn__1465.invoke(match.clj:764)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:67)
	at clojure.lang.RT.seq(RT.java:484)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core$partition$fn__4309.invoke(core.clj:2834)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:484)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core$map$fn__4207.invoke(core.clj:2479)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.Cons.next(Cons.java:39)
	at clojure.lang.PersistentVector.create(PersistentVector.java:51)
	at clojure.lang.LazilyPersistentVector.create(LazilyPersistentVector.java:31)
	at clojure.core$vec.invoke(core.clj:354)
	at clojure.core.match.PatternMatrix.useful_matrix(match.clj:763)
	at clojure.core.match.PatternMatrix.necessary_column(match.clj:755)
	at clojure.core.match.PatternMatrix$choose_column__1441.invoke(match.clj:720)
	at clojure.core.match.PatternMatrix.compile(match.clj:738)
	at clojure.core.match$first_column_chosen_case$switch_clauses__1406$fn__1407.invoke(match.clj:643)
	at clojure.core$map$fn__4211.invoke(core.clj:2492)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:484)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core.protocols$seq_reduce.invoke(protocols.clj:30)
	at clojure.core.protocols$fn__6026.invoke(protocols.clj:54)
	at clojure.core.protocols$fn__5979$G__5974__5992.invoke(protocols.clj:13)
	at clojure.core$reduce.invoke(core.clj:6177)
	at clojure.core$into.invoke(core.clj:6229)
	at clojure.core.match$first_column_chosen_case$switch_clauses__1406.invoke(match.clj:646)
	at clojure.core.match$first_column_chosen_case.invoke(match.clj:676)
	at clojure.core.match.PatternMatrix.compile(match.clj:740)
	at clojure.core.match$first_column_chosen_case$switch_clauses__1406$fn__1407.invoke(match.clj:643)
	at clojure.core$map$fn__4211.invoke(core.clj:2492)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:484)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core.protocols$seq_reduce.invoke(protocols.clj:30)
	at clojure.core.protocols$fn__6026.invoke(protocols.clj:54)
	at clojure.core.protocols$fn__5979$G__5974__5992.invoke(protocols.clj:13)
	at clojure.core$reduce.invoke(core.clj:6177)
	at clojure.core$into.invoke(core.clj:6229)

[MATCH-63] IllegalArgumentException when AOT compiling namespace using clojure.core.match since alpha10

Tue, 26 Feb 2013 13:55:26 -0600

Getting this when AOT compiling a trivial project (attached) using alpha10: (works fine with alpha9)

Caused by: java.lang.IllegalArgumentException: No method in multimethod 'to-source' for dispatch value: class clojure.core.match.WildcardPattern
	at clojure.lang.MultiFn.getFn(MultiFn.java:121)
	at clojure.lang.MultiFn.invoke(MultiFn.java:167)
	at clojure.core.match$dag_clause_to_clj.invoke(match.clj:424)
	at clojure.lang.AFn.applyToHelper(AFn.java:167)
	at clojure.lang.AFn.applyTo(AFn.java:151)
	at clojure.core$apply.invoke(core.clj:602)
	at clojure.lang.AFn.applyToHelper(AFn.java:167)
	at clojure.lang.RestFn.applyTo(RestFn.java:132)
	at clojure.core$apply.invoke(core.clj:604)
	at clojure.core$partial$fn__3796.doInvoke(core.clj:2343)
	at clojure.lang.RestFn.invoke(RestFn.java:408)
	at clojure.core$map$fn__3811.invoke(core.clj:2430)
	at clojure.lang.LazySeq.sval(LazySeq.java:42)
	at clojure.lang.LazySeq.seq(LazySeq.java:60)
	at clojure.lang.RT.seq(RT.java:466)
	at clojure.core$seq.invoke(core.clj:133)
	at clojure.core$apply.invoke(core.clj:600)
	at clojure.core$mapcat.doInvoke(core.clj:2459)
	at clojure.lang.RestFn.invoke(RestFn.java:423)
	at clojure.core.match.SwitchNode.n_to_clj(match.clj:446)
	at clojure.core.match.BindNode.n_to_clj(match.clj:411)
	at clojure.core.match$executable_form.invoke(match.clj:1713)
	at clojure.core.match$clj_form.invoke(match.clj:1721)
	at clojure.core.match$match.doInvoke(match.clj:1750)

[MATCH-67] match broken on ClojureScript >= 88b36c1

Fri, 15 Feb 2013 19:51:49 -0600

The ClojureScript example in core.match's readme is failing at the moment, using core.match 0.2.0-alpha11:

(ns foo.bar
  (:use-macros [clojure.core.match.js :only [match]]))

(match [(mod 5 3) (mod 5 5)]
      [0 0] "FizzBuzz"
      [0 _] "Fizz"
      [_ 0] "Buzz"
      :else n)

ClojureScript:foo.bar> WARNING: Use of undeclared Var foo.bar/e__4345__auto__ at line 4 
clojure.lang.ExceptionInfo: Unsupported binding form: (if (clojure.core/identical? e__4345__auto__ 0) (do (clojure.core/let [ocr-5230 (mod 5 5) ocr-5229 (mod 5 3)] (try (clojure.core/cond (clojure.core/= ocr-5230 0) (clojure.core/let [G__5226 ocr-5229] "Buzz") :else (throw 0)) (catch e__4345__auto__ (if (clojure.core/identical? e__4345__auto__ 0) (do (clojure.core/let [G__5228 ocr-5230 G__5227 ocr-5229] n)) (throw e__4345__auto__)))))) (throw e__4345__auto__)) at line 4  {:tag :cljs/analysis-error, :file nil, :line 4}

The same error is produced with any usage of match in ClojureScript AFAICT, not just the README example. However, all is well with core.match AFAICT under Clojure, and if you use older revs of ClojureScript, e.g. r1552. I did a bisect, and found that this is the first ClojureScript commit with which the example does not work:

https://github.com/clojure/clojurescript/commit/88b36c1

Reverting it with master results in proper evaluation of the match, modulo the warning.

I don't see any obvious reason why the above would cause any problems, and some moderate digging based on what I know about ClojureScript didn't yield any ah-ha! moments.

[MATCH-65] cata matching

Fri, 23 Nov 2012 16:54:30 -0600

Dan Friedman's pattern matcher has a nice feature called cata-matching - allowing recursive matching from the match itself. Useful when writing compilers.

[MATCH-64] Improve match compile times

Wed, 15 Aug 2012 13:04:32 -0500

Improve match compile times

[MATCH-52] Pattern Map's aren't working

Tue, 14 Aug 2012 21:11:34 -0500

Neither of these work as expected:

(match [ {:type :consumed :value 4}]
[({:uid uid :modifiers ms} :only [:uid :modifiers])] :a0)

(match [ {:type :consumed :value 4}]
[{:uid uid :modifiers ms} ] :a0)

Tried these versions:
"0.2.0-alpha10-SNAPSHOT"
"0.2.0-alpha9"

[MATCH-62] ClojureScript map-matching should use cljs.core/ILookup, not cljs.core.ILookup

Sun, 1 Jul 2012 11:05:07 -0500

The latter form is an implementation detail and doesn't work in the latest cljs compiler release.

[MATCH-60] Matching maps with :only broken in CLJS

Sun, 1 Jul 2012 11:03:45 -0500

The `.keySet` method call doesn't exist on JavaScript objects.
Master throws compile errors on me, so I've attached a patch against alpha9 that removes the Java method call in favor of the pure Clojure `(set (keys m))`

[MATCH-61] Exception thrown when matching using :seq when there is a seq call in the tail of the occurrences

Fri, 22 Jun 2012 17:33:34 -0500

I also tested with three occurrences. When there is a seq call in the second occurrence onward a RuntimeException is thrown.

[MATCH-58] we should test the presence of key with find, not get

Sat, 7 Apr 2012 19:34:26 -0500

If a user really doesn't care about the existence of a key they won't match on it. The current behavior is very confusing.

[MATCH-56] IndexOutOfBoundsException when matching empty vector

Tue, 27 Mar 2012 10:28:38 -0500

Using the latest core.match:

user=> (let [x []] (match [x] [[h & t]] [h t] :else :nomatch))
IndexOutOfBoundsException clojure.lang.RT.subvec (RT.java:1451)

Not sure if this is the best fix, but I resolved this specific case by slightly changing subvec-inline (see attached diff).

[MATCH-55] Matching a sequence with just a rest pattern fails to compile

Wed, 21 Mar 2012 15:37:19 -0500

In 0.2.0-alpha9,

(match [ [1 2] ] [([& _] :seq)] true)

fails to compile with No method in multimethod 'to-source' for dispatch value: class clojure.core.match.RestPattern

[MATCH-48] Guards cannot be fn expressions

Sat, 25 Feb 2012 18:49:42 -0600

Anonymous function literals as guards (such as (a :when #(odd? %))) seem to confuse the match compiler. The attached test shows how.

[MATCH-50] locals pattern matching issue

Sat, 25 Feb 2012 18:49:00 -0600

(let [a 1]
    (match [1 2]
      [1 3] :a0
      [a 2] :a1
      :else :a2)) ;; :a2

[MATCH-49] Duplicate wildcard detection in pattern row doesn't account for locals

Thu, 12 Jan 2012 08:36:14 -0600

Duplicate wildcard detection in pattern row doesn't account for locals

[MATCH-35] Bug in seq pattern matching

Wed, 11 Jan 2012 10:26:35 -0600

(let [l '(1 2 3)]
    (match [l]
      [([a & [b & [c d]]] :seq)] :a0
      :else :a1))

Matches when it shouldn't.

[MATCH-43] Vector pattern - unreachable clause

Tue, 27 Dec 2011 20:23:57 -0600

This is the simplest example I could come up with:

(defn f [xs]
(match xs
[:a] "a"
[:b b] b
[:c] "c"
:else "problem!"))

[:a] and [:b b] can be matched with no problems, but [:c] can't be matched for some reason:

user=> (f [:a])
"a"
user=> (f [:b 1])
1
user=> (f [:c])
"problem!"

[MATCH-47] vector patterns dispatch on count after dispatching on type

Fri, 23 Dec 2011 22:22:41 -0600

The current behavior just creates complications.

[MATCH-45] group types together

Fri, 23 Dec 2011 22:09:30 -0600

Currently if patterns of the same type are not adjacent, matching fails unexpectedly. This should always work. This does beg the question about things which might possible match multiple clauses. When we get to predicate dispatch we may check for subsumption. However in some cases we might have something which is legitimately both things. We haven't decided yet how we'll handle that.

[MATCH-46] :or leaks into the matches

Thu, 22 Dec 2011 00:52:54 -0600

Macroexpanding an match expression with an :or pattern will show this.

[MATCH-44] regroup-keywords should not use gensym

Mon, 12 Dec 2011 21:30:07 -0600

I contributed the regroup-keywords function to allow 'flattened' match syntax for :when and :as. It used gensym to make a marker to simplify the algorithm. After seeing how other people had done similar things with sentinel values, I realized that (Object.) is a better unique value. Theoretically, an evil user could use the same symbol that the gensym had created. Also, it's better to test with identical? rather than = since the sentinel is unique. I will attach a patch with a slight refactoring.

[MATCH-36] throw on unsuccessful match

Wed, 30 Nov 2011 20:46:39 -0600

I was on the fence about this. But after looking at the literature as well as the behavior of condp, I've decided that throwing on unsuccessful match is the way to go. This is particularly important since we put no constraints on the types allowed - we cannot determine exhaustiveness.

[MATCH-31] vector patterns should work on seq

Wed, 30 Nov 2011 20:46:21 -0600

This means abandoning subvec and using nth + offsets.

[MATCH-41] This 5-clause match expression fails to compile

Wed, 30 Nov 2011 20:12:12 -0600

This expression fails to compile with a NullPointerException. Oddly enough I seem unable to make it any more minimal:

(match [["foo"]]
    [["foo"]] :a0
    [["foo" a]] :a1
    [["baz"]] :a2
    [["baz" a b]] :a3)

When I included the SNAPSHOT release in my project that seemed to fix it, but oddly enough I cloned the git repo this morning and it was still broken on HEAD, so I have no idea what's going on.

[MATCH-42] quoted symbols should be treated as literals

Wed, 30 Nov 2011 18:52:38 -0600

Reported on the Clojure mailing list:

From: Alex Miller <alex@puredanger.com>
Subject: Symbol matching in core.match
Date: November 30, 2011 2:49:43 PM EST
To: Clojure <clojure@googlegroups.com>
Reply-To: clojure@googlegroups.com

I've been working with core.match some this week and finding it pretty
nice. However, I have a common case (for me) that is not well handled
right now via core.match: matching symbols. Say that I wrote a match
like this:

;; translate (+ x (+ y z)) to (+ x y z)
(let [e '(+ 1 (+ 2 3))]
(match [e]
[([+ x ([+ y z] :seq)] :seq)] (+ x y z)))

You will see this error:
Pattern row 1: Pattern row reuses wildcards in [([+ x ([+ y
z] :seq)] :seq)]. The following wildcards are ambiguous: +. There's
no guarantee that the matched values will be same. Rename the
occurrences uniquely.

Any symbol inside a pattern row is treated as a bind variable. + is a
symbol. You can achieve this with guards:

(defn +? [s] (= '+ s))

(let [e '(+ 1 (+ 2 3))]
(match ['(+ 1 (+ 2 3))]
[([(_o1 :when +?) x ([(_o2 :when +?) y z] :seq)] :seq)] (list
'+ x y z)))

but, yuck. I can imagine using the reserved ()'s with additional keys
(:symbol or :sym) to do symbol matching like (:symbol +) but also,
yuck. The simplest idea I came up with was:

(let [e '(+ 1 (+ 2 3))]
(match [e]
[(['+ x (['+ y z] :seq)] :seq)] ('+ x y z)))

These come through as (quote x) although the error reporting goes a
little off the rails:
Pattern row 1: Pattern row reuses wildcards in [([(quote +) x ([(quote
+) y z] :seq)] :seq)]. The following wildcards are ambiguous: quote.
There's no guarantee that the matched values will be same. Rename the
occurrences uniquely.

However, that seems fixable and you could then use (quote x) as a
signal to do symbol matching. If I can figure out what the hell I'm
doing in core.match then I'd be happy to work on a patch.

[MATCH-39] Allow matching of map expressions to restrict the set of keys present in the value to a subset of a specified set of keys

Mon, 21 Nov 2011 12:34:22 -0600

It is useful, to be able to constrain a match on a map value to limit the set of keys present in the value, without enforcing that the keys are all present in the value.

The current :only option, enforces a strict matching of keys.

{{(let [x {:a 1} (match [x] [({:a _ :b _} :only [:a :b])])}} => doesn't match

This came up trying to write a precondition on the argument of a function, which allowed optional keys, but wanted to restrict the overall set of keys.

[MATCH-40] Allow or'ing of guard functions

Mon, 21 Nov 2011 11:11:42 -0600

In order to simplify composition of guard predicates which are alternatives, allow for passing a sequence of predicates whose values when called will be or'd together.

The :when keyword currently allows passing of a vector of predicates that are and'd together.

Either case (`and` or `or`) can be achieved externally to match via composition, and an alternative might be to force explicit composition outside of core.match.

At the least, the documentation should mention that multiple predicates will be and'd together.

[MATCH-38] interpose1 no longer needed

Sat, 29 Oct 2011 12:50:34 -0500

With the fix for ~~MATCH-34~~, the function interpose1 is no longer used and can be removed. It was there only to support the old infix OR pattern.

[MATCH-37] remove match-1, match should support match-1 behavior

Fri, 28 Oct 2011 00:31:08 -0500

matching literal vectors is not something we support so there can be no ambiguity.

[MATCH-2] Matching Diagnostics

Thu, 27 Oct 2011 23:50:44 -0500

Communicate to the user precisely what failed to match. Conversation here: http://groups.google.com/group/clojure/browse_thread/thread/675456fba1712214. We adopt the behavior of condp since that is closer to what match does and will do (predicate dispatch)

[MATCH-4] Optimized pattern matching on deftype/record, POJOs

Thu, 27 Oct 2011 23:42:15 -0500

(match [x]
  [({:a 0 :b 1} :type Foo)] :a0
  ...)

:a and :b would be converted to field access, i.e. (.a x)

As with primitive array matching, we should do an instance check followed by hinted field access.

We should consider adopting the deftype/record syntax.

[MATCH-10] map pattern keys should be allowed to be heterogenous types

Thu, 27 Oct 2011 23:39:10 -0500

Right now they fail since heterogenous keys can't be sorted.

[MATCH-33] typo in README.md

Thu, 27 Oct 2011 23:19:58 -0500

Re: "As shown, :else clauses are special, in that they are not implicitely wrapped in []."

"implicitely" is misspelled, but "implicitly" would be the wrong word anyway as the intended meaning seems to be "explicitly". It would be clearer just to leave out the adverb.

[MATCH-34] remove infix or pattern syntax, use (:or x y z) instead

Thu, 27 Oct 2011 23:17:49 -0500

remove infix or pattern syntax, use (:or x y z) instead

[MATCH-7] Eliminate distinction between leaf-bind-expr and bind-expr

Fri, 21 Oct 2011 18:55:52 -0500

We should have a better considered binding model that works for all cases instead of treating leaf nodes and regular binding as different cases.

[MATCH-32] Allow flattened pattern syntax at top-level to avoid nesting :when and :as

Fri, 21 Oct 2011 18:53:52 -0500

On the Clojure mailing list I wrote:

For guards, I wonder if the extra parens are really necessary. Couldn't the :when bind tightly to the previous pattern variable? Like Clojure FOR comprehensions. I think it would be easier to read that way. Same comment applies to :as. To cover the rare case of matching a literal :when or :as, you could quote it or use it as the first item in an OR pattern.

On Oct 10, 2011, at 3:11 PM, David Nolen wrote:

It would be nice to lose the extra parens - patch welcome

[MATCH-30] throw if binding name reused in the same pattern row

Wed, 19 Oct 2011 09:57:31 -0500

throw if binding name reused in the same pattern row

[MATCH-29] match should not throw, return nil if no match found like cond

Mon, 10 Oct 2011 22:55:09 -0500

match should not throw, return nil if no match found like cond

[MATCH-9] use case for dispatching on literals

Mon, 10 Oct 2011 22:45:51 -0500

Would speed up literal matching considerably.

[MATCH-28] clojure.core.match ns instead of clojure.core.match.core

Mon, 10 Oct 2011 22:34:41 -0500

clojure.core.match ns instead of clojure.core.match.core

[MATCH-26] Bug in the way that constructor set for a column is computed

Sun, 9 Oct 2011 14:22:53 -0500

(let [x '(1 2) y 1]
  (match [x y]
    [([1] :seq) _] :a0
    [_ 1] :a1
    [([1 2] :seq) _] :a2
    [_ 2] :a3
    :else :a4))

This returns :a2 when it should return :a1

[MATCH-27] match eats exceptions

Thu, 6 Oct 2011 22:51:10 -0500

user=> (match-1 :a :a (throw (Exception.)) :else :c)
:c

I would expect the exception to flow through the match. Instead, it gets eaten and one is left wondering why the proper clause "isn't matching".

[MATCH-25] Map pattern :only case still not right

Thu, 6 Oct 2011 20:28:58 -0500

(let [m {:a 1 :b 2}]
  (match [m]
    [({:a 1} :only [:a])] :a0
    :else :a1))

We get :a0 instead of :a1

[MATCH-23] map pattern order bug

Wed, 5 Oct 2011 21:39:05 -0500

(let [x {:a 1 :b 2 :c 10 :d 30}]
(match [x]
[({:a _ :b _ :c _ :d _} :only [:a :b :c :d])] :a-1
[({:a _ :b 2} :only [:a :b])] :a0
[{:a 1 :c _}] :a1
[{:c 3 :d _ :e 4}] :a2
:else []))

returns :a1 instead of :a-1

[MATCH-24] Setting warn-on-reflection affects all code using core.match

Mon, 3 Oct 2011 11:32:03 -0500

Setting warn-on-reflection affects all use of core.match.

Please remove all cases where warn-on-reflection is set.

This can be set by the pom for the project, rather than in source, so it doesn't affect code using core.match.

[MATCH-19] Analyze action bodies for the presence of recur, if recur is present do not use backtracking

Sun, 2 Oct 2011 12:56:19 -0500

A post about matchure on the ML reminded about my original line of thinking. We should not use the backtracking solution if we detect the presence of recur in any of the action bodies. If it is present we should use the old compilation mechanism.

[MATCH-20] Doesn't match 'head & tail' in vector matching.

Sun, 2 Oct 2011 12:25:44 -0500

Following code:

(match [[:plus 1 2 3]]
[[:pow arg pow]] 0
[[:plus & args]] 1
:else 2)

Returns 2, but must return 1.

If we delete first clause it works:

(match [[:plus 1 2 3]]
[[:plus & args]] 1
:else 2)

Returns 1.

[MATCH-21] Head-Tail Pattern Matching Fails for Lists

Sun, 2 Oct 2011 11:35:01 -0500

Head-tail pattern matching only seems to work with vectors.

Commit: https://github.com/clojure/core.match/commit/9f4919d855be09a1b32f9e5563ac1c3f5bace642

The following code falls through. (macroexpand appended)

(let [x '(1 2 3)]
  (match [x]
         [[a & as]] :a))

(try
  (clojure.core/cond
    (clojure.core/instance? clojure.lang.IPersistentVector x) (try
                                                                (clojure.core/let 
                                                                  [x_left__3201
                                                                   (clojure.core/subvec
                                                                     x
                                                                     0
                                                                     1)]
                                                                  (clojure.core/cond
                                                                    (clojure.core/and
                                                                      (clojure.core/instance?
                                                                        clojure.lang.IPersistentVector
                                                                        x_left__3201)
                                                                      (clojure.core/=
                                                                        (clojure.core/count
                                                                          x_left__3201)
                                                                        1))
                                                                    (clojure.core/let 
                                                                      [a
                                                                       (clojure.core/nth
                                                                         x_left__3201
                                                                         0)
                                                                       as
                                                                       (clojure.core/subvec
                                                                         x
                                                                         1)]
                                                                      :a)
                                                                    :else
                                                                    (throw
                                                                      clojure.core.match.core/backtrack)))
                                                                (catch
                                                                  java.lang.Exception
                                                                  e__2436__auto__
                                                                  (throw
                                                                    clojure.core.match.core/backtrack)))
    :else (throw clojure.core.match.core/backtrack))
  (catch
    java.lang.Exception
    e__2437__auto__
    (throw clojure.core.match.core/backtrack)))

[MATCH-22] boolean expression fails

Sun, 2 Oct 2011 11:32:34 -0500

(match [false] [false] true) throws an error.

I thought I handled this case earlier, but seems like I missed something.

[MATCH-13] Invalid method Code length when generating red black tree matcher

Wed, 28 Sep 2011 22:47:22 -0500

The issue is the same as stated on
https://github.com/swannodette/match/issues/54
but moved here as a part of moving match to Clojure contrib.

Here is a copy of the text from the issue above:

After having forked the latest version on branch and compiling I attempted to execute the infamous red-black tree rebalancing code.

(let [node nil]
(match/match
[node]
[([:black [:red [:red a x b] y c] z d] |
[:black [:red a x [:red b y c]] z d] |
[:black a x [:red [:red b y c] z d]] |
[:black a x [:red b y [:red c z d]]])]
[:red [:black a x b] y [:black c z d]]))
The good news is that issue issue 47 is indeed resolved. The bad news is that a new issue has cropped up, namely that the ClassFormatError with the message

error: java.lang.ClassFormatError: Invalid method Code length 78596 in class file redblack/core$eval3306 (core.clj:10)
is raised.

[MATCH-1] Investigate non-overlapping pattern optimization via pre-allocated exception for backtracking

Wed, 28 Sep 2011 22:46:59 -0500

The red black tree balance pattern mentioned by tgk generates enough code that the JVM will not inline it. Maranget's algorithm basically implements backtracking by passing along wildcard matches with actual matches. For non-overlapping patterns like the red black tree balance pattern this means exponential code size.

For such patterns where none of the actions involve recur we could implement backtracking with a pre-allocated exception.

http://blogs.oracle.com/jrose/entry/longjumps_considered_inexpensive

[MATCH-18] IndexOutOfBound exception using '&' in vector matching.

Wed, 28 Sep 2011 20:23:05 -0500

Following sample causes IndexOutOfBound exception.

(match [[:pow :x 2]]
[[:pow arg pow]] 0
[[:mult & args]] 1
:else 2)

Result: IndexOutOfBound

But if we delete '&' everything works fine:

(match [[:pow :x 2]]
[[:pow arg pow]] 0
[[:mult args]] 1
:else 2)

Result: 0

[MATCH-5] Rest patterns should infer their type

Mon, 26 Sep 2011 06:58:22 -0500

Rest patterns don't currently infer their type. A simple enhancement that would save some extra typing as well as potentially mysterious errors.

[MATCH-6] Nested rest pattern in vector patterns cause infinite loop

Mon, 26 Sep 2011 05:59:48 -0500

Nested rest patterns combined w/ vector patterns cause an infinite loop.

[MATCH-14] Vector Pattern bug when patterns not all of the same length

Mon, 26 Sep 2011 05:57:18 -0500

(let [v [[1 2]]]
(match [v]
[[3 1]] :a0
[[([1 a] :as b)]] [:a1 a b]))

Throws out of bounds exception error

[MATCH-17] first-column-chosen-case Infinite Loop at Compilation

Mon, 26 Sep 2011 05:48:47 -0500

See: https://gist.github.com/1241625

[MATCH-11] The order of pattern rows should be preserved

Sun, 25 Sep 2011 20:50:16 -0500

Sometimes pattern rows are not preserved in the user defind order. Fix this and create the tests to show that this property is preserved.

[MATCH-15] Binding issue

Sun, 25 Sep 2011 19:53:58 -0500

The binding in the match macro used in gitolite-webui.notification 41:

(defn email-request [req]
(match [req]
[{:name _ :repo (r :when (comp not nil?)) :email email}] (notify-user-constrained email "Your repository access request has been approved" (<< "Verify that you can access it by cloning ~(:repo req) repository.") @config)
[{:name _ :key _ :email email}] (notify-user-constrained email "Your key request in gitolite was approved" (<< "Please verify that your public key matches ~(:key req)") @config)
))

Trying to create jar results with:

(match-fix)⚡ % lein uberjar ~/CodeProjects/gitolite-webui
Cleaning up.
WARNING: gitolite-webui.notification, line 42: Non-exhaustive pattern matrix, consider adding :else clause
Exception in thread "main" java.lang.Exception: Unable to resolve symbol: email in this context (notification.clj:43)
at clojure.lang.Compiler.analyze(Compiler.java:5205)
at clojure.lang.Compiler.analyze(Compiler.java:5151)
at clojure.lang.Compiler$InvokeExpr.parse(Compiler.java:3057)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5371)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyze(Compiler.java:5151)
at clojure.lang.Compiler$IfExpr$Parser.parse(Compiler.java:2315)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5369)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5357)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5357)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyze(Compiler.java:5151)
at clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:4670)
at clojure.lang.Compiler$FnMethod.parse(Compiler.java:4328)
at clojure.lang.Compiler$FnExpr.parse(Compiler.java:3173)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5367)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5357)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyze(Compiler.java:5151)
at clojure.lang.Compiler$HostExpr$Parser.parse(Compiler.java:798)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5369)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5357)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.access$100(Compiler.java:35)
at clojure.lang.Compiler$DefExpr$Parser.parse(Compiler.java:438)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5369)
at clojure.lang.Compiler.analyze(Compiler.java:5190)
at clojure.lang.Compiler.analyze(Compiler.java:5151)
at clojure.lang.Compiler.compile1(Compiler.java:5928)
at clojure.lang.Compiler.compile(Compiler.java:5992)
at clojure.lang.RT.compile(RT.java:368)
at clojure.lang.RT.load(RT.java:407)
at clojure.lang.RT.load(RT.java:381)
at clojure.core$load$fn__4519.invoke(core.clj:4915)
at clojure.core$load.doInvoke(core.clj:4914)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.core$load_one.invoke(core.clj:4729)
at clojure.core$load_lib.doInvoke(core.clj:4766)
at clojure.lang.RestFn.applyTo(RestFn.java:142)
at clojure.core$apply.invoke(core.clj:542)
at clojure.core$load_libs.doInvoke(core.clj:4800)
at clojure.lang.RestFn.applyTo(RestFn.java:137)
at clojure.core$apply.invoke(core.clj:544)
at clojure.core$use.doInvoke(core.clj:4892)
at clojure.lang.RestFn.invoke(RestFn.java:512)
at gitolite_webui.persistency$loading_4414auto_.invoke(persistency.clj:1)
at clojure.lang.AFn.applyToHelper(AFn.java:159)
at clojure.lang.AFn.applyTo(AFn.java:151)
at clojure.lang.Compiler$InvokeExpr.eval(Compiler.java:2906)
at clojure.lang.Compiler.compile1(Compiler.java:5933)
at clojure.lang.Compiler.compile1(Compiler.java:5923)
at clojure.lang.Compiler.compile(Compiler.java:5992)
at clojure.lang.RT.compile(RT.java:368)
at clojure.lang.RT.load(RT.java:407)
at clojure.lang.RT.load(RT.java:381)
at clojure.core$load$fn__4519.invoke(core.clj:4915)
at clojure.core$load.doInvoke(core.clj:4914)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.core$load_one.invoke(core.clj:4729)
at clojure.core$load_lib.doInvoke(core.clj:4766)
at clojure.lang.RestFn.applyTo(RestFn.java:142)
at clojure.core$apply.invoke(core.clj:542)
at clojure.core$load_libs.doInvoke(core.clj:4800)
at clojure.lang.RestFn.applyTo(RestFn.java:137)
at clojure.core$apply.invoke(core.clj:542)
at clojure.core$require.doInvoke(core.clj:4881)
at clojure.lang.RestFn.invoke(RestFn.java:512)
at gitolite_webui.core$loading_4414auto_.invoke(core.clj:1)
at clojure.lang.AFn.applyToHelper(AFn.java:159)
at clojure.lang.AFn.applyTo(AFn.java:151)
at clojure.lang.Compiler$InvokeExpr.eval(Compiler.java:2906)
at clojure.lang.Compiler.compile1(Compiler.java:5933)
at clojure.lang.Compiler.compile1(Compiler.java:5923)
at clojure.lang.Compiler.compile(Compiler.java:5992)
at clojure.lang.RT.compile(RT.java:368)
at clojure.lang.RT.load(RT.java:407)
at clojure.lang.RT.load(RT.java:381)
at clojure.core$load$fn__4519.invoke(core.clj:4915)
at clojure.core$load.doInvoke(core.clj:4914)
at clojure.lang.RestFn.invoke(RestFn.java:408)
at clojure.core$load_one.invoke(core.clj:4729)
at clojure.core$compile$fn__4524.invoke(core.clj:4926)
at clojure.core$compile.invoke(core.clj:4925)
at user$eval27.invoke(NO_SOURCE_FILE:1)
at clojure.lang.Compiler.eval(Compiler.java:5424)
at clojure.lang.Compiler.eval(Compiler.java:5415)
at clojure.lang.Compiler.eval(Compiler.java:5391)
at clojure.core$eval.invoke(core.clj:2382)
at clojure.main$eval_opt.invoke(main.clj:235)
at clojure.main$initialize.invoke(main.clj:254)
at clojure.main$null_opt.invoke(main.clj:279)
at clojure.main$main.doInvoke(main.clj:354)
at clojure.lang.RestFn.invoke(RestFn.java:421)
at clojure.lang.Var.invoke(Var.java:369)
at clojure.lang.AFn.applyToHelper(AFn.java:163)
at clojure.lang.Var.applyTo(Var.java:482)
at clojure.main.main(main.java:37)
Caused by: java.lang.Exception: Unable to resolve symbol: email in this context
at clojure.lang.Compiler.resolveIn(Compiler.java:5677)
at clojure.lang.Compiler.resolve(Compiler.java:5621)
at clojure.lang.Compiler.analyzeSymbol(Compiler.java:5584)
at clojure.lang.Compiler.analyze(Compiler.java:5172)
... 100 more

Trying to use an else clause:

Exception in thread "main" java.lang.RuntimeException: java.lang.IllegalArgumentException: No method in multimethod 'to-source' for dispatch value: class clojure.core.match.core.WildcardPattern (notification.clj:42)
at clojure.lang.Compiler.analyzeSeq(Compiler.java:5376)

[MATCH-3] strange infinite lazy seq of nils pattern rows bug at leaf nodes

Sun, 25 Sep 2011 18:45:22 -0500

This is low priority, but should be investigated. To see this behavior just print out the pattern row at the leaf node cases. Encountered this while fixing symbol binding bug in vector patterns.

[MATCH-16] Empty Vector Patterns Fail to Match

Sun, 25 Sep 2011 17:53:48 -0500

(match [[]]
[[]] "asdf")
#<RuntimeException java.lang.RuntimeException: java.lang.Exception: No match found. Followed 0 branches. Breadcrumbs: []>

Macro-expand'd:

(let*
[ocr-4856 []]
(clojure.core/cond
(clojure.core/and
(clojure.core/instance? clojure.lang.IPersistentVector ocr-4856)
(clojure.core/= (clojure.core/count ocr-4856) 1)) (clojure.core/let
[ocr-4856_0__4857
(clojure.core/nth
ocr-4856
0)]
(clojure.core/cond
(clojure.core/=
ocr-4856_0__4857
nil)
"asdf"
:else
(throw
(java.lang.Exception.
(clojure.core/str
"No match found. "
"Followed "
1
" branches."
" Breadcrumbs: "
'[(clojure.core/and
(clojure.core/instance?
clojure.lang.IPersistentVector
ocr-4856)
(clojure.core/=
(clojure.core/count
ocr-4856)
1))])))))
:else (throw
(java.lang.Exception.
(clojure.core/str
"No match found. "
"Followed "
0
" branches."
" Breadcrumbs: "
'[])))))

Clearly this test is the issue: (clojure.core/= (clojure.core/count ocr-4856) 1))

[MATCH-12] Migrate to Maven

Fri, 23 Sep 2011 00:47:20 -0500

AFAIK we need to migrate to Maven for Contrib projects.

I used core.logic as a template and it seems to have been successful. Anything missing?

https://github.com/clojure/core.match/commit/5146212edecbd8d765028e165352d20005b44cc3

[MATCH-8] Implement (p|q)ba heuristics

Sun, 4 Sep 2011 10:00:57 -0500

We should implement the rest of Maranget's suggested heuristics.

p - needed prefix
q - constructor prefix
b - branching factor
a - constructor arity