How to reuse matching patterns in match clauses?

Question

I need to match two kinds of tuples and produce maps from them.

Both have a keyword and a string. One can have a third item (a language code).

[<key> <value>]        ~> {:type <key> :value <value>}
[<key> <value> <lang>] ~> {:type <key> :value <value> :lang <lang>}

I only need to match those which keyword is either :foo or :bar and decided that I would use clojure.core.match:

(ns so.example
  (:require
   [clojure.core.match :refer [match]]))

(defn example-1 [ast]
  (let [l10n-key #{:foo :bar}]
    (match ast
      [(k :guard l10n-key) v lang] {:type k :value v :lang lang}
      [(k :guard l10n-key) v]      {:type k :value v})))

(example-1 [:foo 10])
;=> {:type :foo, :value 10}

(example-1 [:bar 20 "en"])
;=> {:type :bar, :value 20, :lang "en"}

That works but I wanted to reuse the matching pattern :guard l10n-key in different clauses. So I thought I could use some syntax quoting and unquote splicing:

(defn example-2 [ast]
  (let [l10n-key-match [:guard #{:foo :bar}]]
    (match ast
      [`(k ~@l10n-key-match) v lang] {:type k :value v :lang lang}
      [`(k ~@l10n-key-match) v]      {:type k :value v})))

However the defn expression crashes with:

Unexpected error (AssertionError) macroexpanding match at (form-init11111096422056977084.clj:3:5).
Invalid list syntax (clojure.core/concat (clojure.core/list (quote so.example/k)) l10n-key-match) in (clojure.core/seq (clojure.core/concat (clojure.core/list (quote so.example/k)) l10n-key-match)). Valid syntax: [[:default :guard] [:or :default] [:default :only] [:default :seq] [:default :when] [:default :as] [:default :<<] [:default :clojure.core.match/vector]]

What am I doing wrong?

Answer 1

Isn't this what spec, that already ships with Clojure, does? You would define your pattern like

(ns playground.catspec
  (:require [clojure.spec.alpha :as spec]))

(spec/def ::type #{:foo :bar})
(spec/def ::value number?)
(spec/def ::lang #{"en" "sv" "fr"})

(spec/def ::key-value-lang (spec/cat :type ::type
                                     :value ::value
                                     :lang (spec/? ::lang)))

We use spec/def to define a spec, spec/cat to concatenate specs and spec/? for a spec that is optional.

Then we use conform to parse the tuple:

(spec/conform ::key-value-lang [:foo 10])
;; => {:type :foo, :value 10}

(spec/conform ::key-value-lang [:bar 20 "en"])
;; => {:type :bar, :value 20, :lang "en"}

(spec/conform ::key-value-lang [:bar 119 "fr"])
;; => {:type :bar, :value 119, :lang "fr"}

(spec/conform ::key-value-lang [119 :foo])
;; => :clojure.spec.alpha/invalid

(spec/conform ::key-value-lang [:bar 119 "uj"])
;; => :clojure.spec.alpha/invalid

(spec/conform ::key-value-lang [:bar])
;; => :clojure.spec.alpha/invalid

(spec/conform ::key-value-lang [:bar 119 "fr" :asdfasdf])
;; => :clojure.spec.alpha/invalid

(spec/conform ::key-value-lang {:a 1 :b 4})
;; => :clojure.spec.alpha/invalid

Answer 2

Doesn't solve the problem with clojure.core.match, but you don't really need it for something this simple:

(ns tst.demo.core
  (:use tupelo.core tupelo.test))

(dotest
  (let [data      [[:foo 10]
                   [:bar 20 "en"]
                   [:fizz 10]
                   [:buzz 20 "en"]]
        keep-tags #{:foo :bar}
        data-keep (filterv #(contains? keep-tags (first %)) data)
        result    (forv [tuple data-keep]
                    (zipmap [:type :value :lang] tuple))]
    (is= result [{:type :foo, :value 10}
                 {:type :bar, :value 20, :lang "en"}])))

You may also be interested in these helper functions:

• tupelo.core/matches? A nicer interface to clojure.core.match
• tupelo.core/submatch?
• tupelo.core/wild-match?
• tupelo.core/wild-submatch?