Clojure Q&A - Recent questions in core.match

Allow `core.match` patterns to contain fully qualified class names

Tue, 17 Jan 2023 15:12:12 +0000

When matching on Class objects in core.match, the symbol normally used to name the Class object is treated by default as a pattern wildcard, just like any other symbol. The basic usage documentation shows this behavior and suggests local rebinding to get the intended behavior.

Rebinding is an adequate solution, but I find that, when writing or reading code, it is easy to overlook a missing binding. Another solution might be to use a fully-qualified class name:

(match [(type 1)]
  [java.lang.String] :string
  [java.lang.Long] :long
  :else :no-match)

By adopting this convention, developers wouldn't need to look at any scope larger than the pattern itself to know whether the class names will resolve correctly, making it easier to spot bugs when reading the code (and likely also making it easier to lint for this).

However, this syntax is not currently supported:

Syntax error (ClassFormatError) compiling fn* at (REPL:1:1).
Illegal field name "java.lang.String" in class user$eval1591

Symbols with no namespace which contain one or more periods are in the general case documented as indicating class names, and they do not work in local bindings (hence the error), so supporting this syntax shouldn't conflict with any other possible meanings of the symbol.

core.match: syntax error during macro expansion when string key contains a slash character

Mon, 04 Apr 2022 19:11:31 +0000

When passed a map with a string key containing a slash character, clojure.core.match/match errors during macro expansion.

This happens in both Clojure and Clojurescript.

Example:

$ clj -Sdeps '{:deps {org.clojure/core.match {:mvn/version "1.0.0"}}}'

Clojure 1.10.3
user=> (require '[clojure.core.match :as match])
nil

user=> (match/match {} {"a/b" x} x)
Syntax error macroexpanding clojure.core/let at (REPL:1:1).
ocr-1539_a/b__1543 - failed: simple-symbol? at: [:bindings :form :local-symbol] spec: :clojure.core.specs.alpha/local-name

user=> (match/match {"a/b" 0} {"a/b" x} x)
Syntax error macroexpanding clojure.core/let at (REPL:1:1).
ocr-1545_a/b__1549 - failed: simple-symbol? at: [:bindings :form :local-symbol] spec: :clojure.core.specs.alpha/local-name

Expected behavior: it should be possible to match on all strings, even if they contain special characters.

Bug when matching on a vector with a map clause that uses `:only`

Fri, 19 Nov 2021 05:32:39 +0000

There seems to be a bug where a clause uses the :only qualifier to ensure that a map has a specific set of keys. If the value being matched is a vector a ClassCastException exception is thrown.

Here is an example that works as expected and does not use :only.

(let [x []]
  (match [x]
    [{:k v}] :a-map
    :else :not-a-map))
=> :not-a-map

If we teak it slightly to add the :only an unexpected error is thrown.

(let [x []]
  (match [x]
    [({:k v} :only [:k])] :a-map
    :else :not-a-map))
;; Execution error (ClassCastException) at ...
;; clojure.lang.PersistentVector cannot be cast to java.util.Map

Slack user @FiVo identified that the form produced for map patterns will perform the map checks on any value that is an ILookup, but the checks may will include a call to .keySet if the :only qualifier is used.

It was suggested that the references to ILookup here be changed to IPersistentMap. CLJ tests still pass with this change.

How do I contribute to the README for core.match?

Thu, 18 Feb 2021 05:35:52 +0000

I would like to add some information to the README for core.match. However, a simple PR on the README seems to be against the procedure.

How do I contribute? I already have a signed CA.

Also, JIRA appears to be down (tried that first).

Can core.match LiteralPattern emit more specialized code?

Tue, 01 Dec 2020 07:29:48 +0000

Hello,
Looking at the code emitted by core.match, I see that literals are always compared using =.
While it works, wouldn't it be faster to specialize equality for different literals, such as:

 (number? l) `(and (number? ~ocr) (== ~l ~ocr))
 (keyword? l) `(identical? ~l ~ocr)
 (nil? l) `(nil? ~ocr)
 (true? l) `(true? ~ocr)
 (false? l) `(false? ~ocr)
 (string? l) `(.equals ~l ~ocr)

(snippet added to LiteralPattern cond.

Crude benchmarks show it's faster than = and all the tests pass, too.

Think this warrants a patch?

Shadowing bindings does not work as expected

Fri, 12 Jan 2018 11:05:54 +0000

This is a bug with core.match, or (far less likely) with the macro expansion in Clojure.

This code:

`
(let (link: foo [:bar :baz)]
(match foo

(link: :bar boo) boo
:else :got-else))

returns :baz. While this code:

`
(let (link: foo [:bar :baz)]
(match foo

(link: :bar foo) foo
:else :got-else))

returns :got-else.

They should be equal, since the foo in the match should shadow the foo in
the let. In fact, when running macroexpand-1 on these forms, they only differ in
the gensym numbers and the letter f vs b in foo and bar.

I have created a repo that reproduces the bug:

https://github.com/magnars/bug-examples/tree/core-match-shadow-bindings

Keyword literal as function apply(:<<) result

Mon, 16 Oct 2017 09:55:14 +0000

Fails:

(let [x [:k1 :k2 :k3]]
  (m/match [x]
           [(:k1 :<< first)] :first))

Invalid list syntax :<< in (:k1 :<< first). Valid syntax:
   [[:default :guard] [:or :default] [:default :only] [:default :seq]
   [:default :when] [:default :as] [:default :<<] [:default
   :clojure.core.match/vector]]

Work:

(let [k1 :k1
      x [:k1 :k2 :k3]]
  (m/match [x]
           [(k1 :<< first)] :first))

Is it a bug or a feature?
How to match keywords correctly?

Exception when regexp-matching on a map key that does not exist.

Mon, 08 May 2017 07:16:03 +0000

When matching map values via regular expressions with a key that does not exist in the map, {{core.match}} throws an exception. Here is an example:

{code:none}
(= 2 (match {:foo "bar"}
            {:bar #"bar"} 1
            :else 2))))

throws

{code:none}
java.lang.ClassCastException: clojure.lang.Keyword cannot be cast to java.lang.CharSequence
at clojure.core$re_matcher.invoke (core.clj:4460)
    clojure.core$re_matches.invoke (core.clj:4497)
...

because {{re-match}} gets called with the {{:clojure.core.match/not-found}} keyword since the key was not found.

The attached patch contains a test case for the problem and offers a fix by making sure that {{re-match}} only gets called when the key was found and fails the match gently otherwise.

Or matches with vectors improperly match

Fri, 05 May 2017 00:35:15 +0000

Someone on reddit reported a problem they were having with core.match and or patterns. I looked into and after checking the macro expansion, there seemed to be a bug in core.match. I was able to fix the bug. I will attach the patch shortly.

This is my first time submitting a patch this way, so if I left anything off please let me know.

https://www.reddit.com/r/Clojure/comments/697l1i/is_this_a_clojurecorematch_bug_or_its_just_me/

Empty seq match can throw Exception

Sat, 01 Apr 2017 18:53:26 +0000

For example:

user=> (let [x 5] (m/match x ([] :seq) true :else false))
IllegalArgumentException Don't know how to create ISeq from: java.lang.Long clojure.lang.RT.seqFrom (RT.java:542)

The problem appears to be that empty seq patterns are converted to LiteralPatterns for (). IPatternCompile for LiteralPatterns checks if the literal is () -- if so it emits an {{empty?}} test without any check to see if the ocr is {{Seqable}}.

Fix typo on multimethod

Fri, 10 Mar 2017 22:06:44 +0000

Fix typo on multimethod

Simplify computation of necessary column

Wed, 07 Dec 2016 02:56:14 +0000

From match.clj:
;; IMPORTANT NOTE: this calculation is very very slow,
;; we should look at this more closely - David

This has to do with computing the necessary column, ie, the column that contains the most number of matches we will have to do. This patch simplifies this logic which is spread out over several functions and puts it into one location. Further, it improves complexity. When computing the necessity of a column, only patters above wildcards in a column need to be computed. the way the previous implementation worked was to compute the value for each entry in the pattern matrix and then check above each entry to see if there were wildcards. Now, we just group by column and then reduce on the column, adding up the same values as last time and immediately returning the accumulator with (reduced acc) if we hit a wildcard. This saves the repeated traversal of each column for each entry. A nice benefit is locality of everything inside of a single function.

I've timed this against master with the entries from bench.clj and was actually a little surprised to see that there was no time speedup, however.

Outdated dependencies

Fri, 02 Dec 2016 18:23:04 +0000

The Clojure version specified in core is 1.6, which is lower than the minimum supported version in CIDER (1.7)
The Clojurescript version is "0.0-2496" which seems rather outdated compared to the current "1.9.293"
The lein-cljsbuild is "1.0.4-snapshot" instead of current 1.1.4

Rather critically, this specifies its own version of cider-nrepl, a very out of date 0.8.1, rather than letting CIDER inject its current version (stable 0.14 or dev 0.15). These happen automatically now depending upon the version of CIDER you are running.

this just updates these versions in the project.clj file.

core.match clojurescript should be self-host compatible

Sun, 23 Oct 2016 15:17:58 +0000

core.match clojurescript should be self-host compatible

AppPattern with single wildcard throws exception

Fri, 29 Jul 2016 17:22:11 +0000

Example:

user=> (require '[clojure.core.match :as m]) nil user=> (m/match [[1 2 3]] [(x :<< first)] x) IllegalArgumentException No method in multimethod 'to-source' for dispatch value: null clojure.lang.MultiFn.getFn (MultiFn.java:156)

It seems this can be fixed by adding a dummy to-source for wildcards:

`
user=> (defmethod m/to-source nil [pattern ocr]
(if (m/wildcard-pattern? pattern)

true
(throw (AssertionError. (str "Don't know how to emit code for: " pattern)))))

object[clojure.lang.MultiFn 0x4bb9f7d4 "clojure.lang.MultiFn@4bb9f7d4"]

user=> (m/match [[1 2 3]] [(x :<< first)] x)<br> 1
`

Rather simple match fails with code too large

Sat, 02 Jul 2016 22:03:52 +0000

The following function fails to compile. If I change the row

(link: :context _ _)   formula

(link: :context _)   formula

it works.

(defn terms (link: formula)
(match formula

(link: :root r)      (recur r)
(link: :expr e)      (recur e)
(link: :call f [:args & args]] (for [arg args) (terms arg))
(link: :refer _ _)   formula
(link: :float _)     formula
(link: :context _ _)   formula
(link: :string _)    formula
(link: :eq e1 _ e2)  (concat (terms e1) (terms e2))
(link: :add & args ) (for (link: arg args) (terms arg))
(link: :sub & args ) (for (link: arg args) (terms arg))
(link: :div & args ) (for (link: arg args) (terms arg))
(link: :mul & args ) (for (link: arg args) (terms arg))

))

Typo in match.clj

Wed, 15 Jun 2016 18:31:26 +0000

Line 1710 of match.clj (0.3.0-alpha4) has this:

(defmethod groupable? [::predice ::predicate] [a b] (= (:gs a) (:gs b)))

I believe "predice" should be "predicate".

:as and & interaction issue

Fri, 18 Sep 2015 18:01:39 +0000

Unless i'm mistaken, it looks like there is some interaction problem between & patterns and :as patterns

(match (link: [:bar :baz)]
(link: ([:bar & r) :as m)] m)
-> (link: :bar)

I'm expecting (link: :bar :baz) here

This is as I expect :
(match (link: [:bar :baz)]
(link: [:bar & r)] :a)
-> :a

This is also as expected :
(match (link: [:bar :baz)]
(link: ([:bar :baz) :as m)] m)
-> (link: :bar :baz)

so & and :as each work on its own.

convert to .cljc

Wed, 05 Aug 2015 20:17:18 +0000

Upgrade org.clojure/tools.analyzer.jvm dependency to "0.6.6"

Wed, 20 May 2015 20:32:47 +0000

Currently core.match depends on tools.analyzer.jvm "0.6.5", the latest release is "0.6.6". The outdated dependency on tools.analyzer.jvm conflicts with core.async's dependency on version "0.6.6". This can cause unexpected behavior when a project depends on both core.match and core.async.

Map pattern with vector key raises "clojure.lang.PersistentVector cannot be cast to clojure.lang.Named" exception

Wed, 29 Apr 2015 03:07:16 +0000

The following pattern throws "CompilerException java.lang.ClassCastException: clojure.lang.PersistentVector cannot be cast to clojure.lang.Named":

(let (link: x {[1) 2}]
(match (link: x)

     (link: {[1] _}) true))

variable binding fails with :or guard

Tue, 07 Apr 2015 20:08:15 +0000

The following works
fine:

(match (link: 'F) (link: ('F :as x)) x) ;; => F

But fails when I try to use an :or guard:

(match (link: 'F) (link: ((:or 'F 'T) :as x)) x) ;; CompilerException java.lang.RuntimeException: Unable to resolve symbol: x in this context

Regex: only attempt to match string values.

Sat, 07 Mar 2015 05:52:37 +0000

Before this fix, matching a regex pattern against a non-string value would crash like so:

`
java.lang.ClassCastException: clojure.lang.Keyword cannot be cast to java.lang.CharSequence
at clojure.core$re_matcher.invoke (core.clj:4460)

clojure.core$re_matches.invoke (core.clj:4497)

...
`

Support for lists in patterns.

Thu, 18 Dec 2014 16:19:48 +0000

Currently it is not possible to use list literals with or without variables in a pattern.
Thus something like this

`
(match ['(1 2 3)]

   ['(a b c)] a)

will result in a failing assert.

AssertionError Invalid list syntax (a b c) in (quote (a b c)).

There is a workaround for this by using :seq and :guard, as in

`
(match ['(1 2 3)]

   [(([a b c] :seq) :guard list?)] a)

but it is rather tedious to write.

List matching would be very useful when writing macros and compilers.

Do :guard predicates really need to handle :clojure.core.match/not-found?

Wed, 17 Dec 2014 11:44:23 +0000

I'm very new to {{core.match}} and just started playing around. Doing so, I came up with this example:

(for [x [[1 2 3]
[1 2 3 4]
{:a 17, :b 2}
{:a 23, :b 7}]]
  (match [x]
   [[a b c]]                    [a b c]
   [{:a a, :b 2}]               {:a a}
   [{:a (a :guard odd?), :b b}] {:a a, :b b}
   :else                        :no-match))

This errors with the message ??"IllegalArgumentException Argument must be an integer: :clojure.core.match/not-found clojure.core/even? core.clj:1351)"??. The problem is that the keyword {{:clojure.core.match/not-found}} is passed to the {{:guard}} function {{odd?}} which passes it to {{even?}}.

I can fix it by ensuring the my guard only gets an integer like so:

(for [x [[1 2]
        [1 2 3]
        [1 2 3 4]
        {:a 17, :b 2}
        {:a 23, :b 7}]]
  (match [x]
   [[a b c]]                               [a b c]
   [{:a a, :b 2}]                          {:a a}
   [{:a (a :guard #(and (integer? %)
                        (odd? %))), :b b}] {:a a, :b b}
   :else                                   :no-match))

But is it really intensional that guards have to deal with {{:clojure.core.match/not-found?}} In my opinion, in the example above all maps that are matched have integer values, so it seems plausible that I can have a guard that only accepts integers.

Apparent regression for test sharing literals

Fri, 12 Dec 2014 22:17:20 +0000

Not sure when this one was introduced but literal tests appear to not share correctly and literals are needlessly retested.

Example in Overview Wiki Page Results in an Exception

Wed, 03 Dec 2014 00:15:12 +0000

The first example for "Or Patterns" on the Overview page in the wiki will cause an IllegalArgumentException.

`
user=> (use '[clojure.core.match :only (match)])
nil
user=> (let [x '(1 2 3)]
#=> (match [x]
#=> [[1 (:or 3 4) 3]] :a0
#_=> [[1 (:or 2 3) 3]] :a1))

IllegalArgumentException No matching clause: (1 2 3) user/eval5476 (form-init4056337243047274400.clj:2)
`

The example should probably either use a vector for x, or a seq pattern in the match. Included patch with the latter.

recur detection logic is too naive

Wed, 16 Apr 2014 20:30:50 +0000

The following explodes because of the presence of {{recur}}:

`
(defn rec [expr]
(match expr

     [:global] 'GLOBAL
     [:constant x] x
     [:variable x] x
     [:lazy-variable x] `(deref ~x)
     [:if test if-true if-false] `(if ~(rec test)
                                    ~(rec if-true)
                                    ~(rec if-false))
     [:delist list index] `(get ~(rec list) ~(rec index))
     [:depair pair key] `(get ~(rec pair) ~(match key :first 0 :second 1))
     [:list elements] (map rec elements)
     [:fold-recur index-arg list-sym] `(recur (+ 1 ~index-arg) (rest ~list-sym))
     [:zip left right] `(map vector ~(rec left) ~(rec right))
     [:filter list arg body] `(filter (fn [~arg] ~(rec body) ~(rec list)))
     [:len list] `(count ~(rec list))
     [:pair first second] [(rec first) (rec second)]
     [:block arg body] `(fn [~arg] ~(rec body))
     [:app f arg] `(~(rec f) ~(rec arg))
     [:query e annotations] `(QUERY ~(rec e) ~annotations)
     [:lookup key] `(LOOKUP ~key)
     [:let name value expr] `(let [~name ~value] expr)
     ; ... about 15 more
     ))

Simple capturing of :or matches with :as doesn't work

Thu, 30 Jan 2014 15:53:30 +0000

All three of these expressions should work (according to @dnolen in IRC):

user> (match/match [5] [((:or 5 6) :as x)] x) CompilerException java.lang.RuntimeException: Unable to resolve symbol: x in this context user> (match/match [5] [(:or (5 :as x) (6 :as x))] x) 5 user> (match/match [5] [(:or (5 :as x) (6 :as y))] x) CompilerException java.lang.RuntimeException: Unable to resolve symbol: x in this context

(The first makes sense to me, but the latter two don't; e.g. should {{y}} be {{nil}} in the last example, or something else?)

Though it's not necessary, it'd be nice if the following "sugared" form worked, too:

user> (match/match [5] [(:or 5 6 :as x)] x) CompilerException java.lang.RuntimeException: Unable to resolve symbol: x in this context

ignore duplicate wildcard check if matching a local multiple times in same pattern row

Tue, 19 Nov 2013 21:45:12 +0000

`
(let [v 10]
(match x

[v v v] ...))

Tidy up for 0.2.0, add comprehensive doc strings

Tue, 25 Jun 2013 18:12:32 +0000

Tidy up for 0.2.0, add comprehensive doc strings

Switches on literals should happen via `case` not `cond`

Tue, 25 Jun 2013 18:11:31 +0000

It worth investigating whether this improves performance at all.

rest patterns don't work on arrays

Thu, 20 Jun 2013 23:52:47 +0000

Currently they simply don't work. When we make it work we should probably wrap the array in something like ArraySeq. We might want to consider support for unwrapping ArraySeq. We need to carry type information as well as offset information.

pass occurrence to emit-pattern

Thu, 20 Jun 2013 16:44:40 +0000

Currently we have a hack to read type information at vector pattern specialization time overriding whatever the :t field is for a VectorPattern instance. We should instead pass the occurrence to emit-pattern so the vector-pattern can start with the correct type information.

complexity analysis

Wed, 19 Jun 2013 04:22:13 +0000

For smaller matches avoid backtracking actually greatly improves performance at the potential cost of code size. Perhaps we can devise a heuristic such that we employ the the best option available? Would need some serious hammock time.

cata matching

Fri, 23 Nov 2012 22:54:30 +0000

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

Improve match compile times

Wed, 15 Aug 2012 19:04:32 +0000

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

Thu, 12 Jan 2012 14:36:14 +0000

Allow or'ing of guard functions

Mon, 21 Nov 2011 17:11:42 +0000

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.

vector patterns should work on seq

Tue, 11 Oct 2011 04:35:41 +0000

This means abandoning subvec and using nth + offsets.

Implement (p|q)ba heuristics

Sun, 04 Sep 2011 16:00:57 +0000

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

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

Eliminate distinction between leaf-bind-expr and bind-expr

Sun, 04 Sep 2011 16:00:02 +0000

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

Optimized pattern matching on deftype/record, POJOs

Sun, 04 Sep 2011 15:56:54 +0000

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

Matching Diagnostics

Sun, 04 Sep 2011 15:54:33 +0000

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)