Allow path and key exists clauses to be wrapped in a list.

Author: neshtea

src/active/clojure/match.clj

@@ -297,15 +297,17 @@
 (s/def ::qmark #{'?})
 
 (s/def ::key-exists
-  (s/or :required ::key
+  (s/or :required (s/or :flat ::key
+                        :list (s/cat :key ::key))
         :optional (s/cat :qmark ::qmark :key ::key)))
 
 (s/def ::key-exists-with-binding
   (s/or :required (s/cat :key ::key :binding-key ::binding-key :binding ::binding)
         :optional (s/cat :qmark ::qmark :key ::key :binding-key ::binding-key :binding ::binding)))
 
 (s/def ::path-exists
-  (s/or :required ::path
+  (s/or :required (s/or :flat ::path
+                        :list (s/cat :path ::path))
         :optional (s/cat :qmark ::qmark :path ::path)))
 
 (s/def ::path-exists-with-binding
@@ -351,6 +353,8 @@
   [[kind k]]
   (if (= :symbol kind) (str k) k))
 
+(def flat? (partial = :flat))
+
 (defn parse-clause
   [p]
   (letfn [(optional? [k]
@@ -367,7 +371,10 @@
             :key-exists
             (if (optional? mode)
               (opt (key-exists-clause (make-key (:key body))))
-              (key-exists-clause (make-key body)))
+              (let [[mode body] body]
+                (if (flat? mode)
+                  (key-exists-clause (make-key body))
+                  (key-exists-clause (make-key (:key body))))))
 
             :key-exists-with-binding
             (let [clause (-> (key-exists-clause (make-key (:key body)))
@@ -377,7 +384,10 @@
             :path-exists
             (if (optional? mode)
               (opt (path-exists-clause (mapv make-key (:path body))))
-              (path-exists-clause (mapv make-key body)))
+              (let [[mode body] body]
+                (if (flat? mode)
+                  (path-exists-clause (mapv make-key body))
+                  (path-exists-clause (mapv make-key (:path body))))))
 
             :path-exists-with-binding
             (let [{:keys [path binding]} body

test/active/clojure/match_test.clj

@@ -6,16 +6,24 @@
 
 (t/deftest parse-clause-test
   (t/testing "key exists clause"
-    (t/is (= (p/make-key-exists-clause :k p/the-existence-matcher 'k)
-             (p/parse-clause :k))))
+    (t/testing "flat"
+      (t/is (= (p/make-key-exists-clause :k p/the-existence-matcher 'k)
+               (p/parse-clause :k))))
+    (t/testing "list"
+      (t/is (= (p/make-key-exists-clause :k p/the-existence-matcher 'k)
+               (p/parse-clause (list :k))))))
 
   (t/testing "key exists with binding clause"
     (t/is (= (p/make-key-exists-clause :k p/the-existence-matcher 'Binding)
              (p/parse-clause (list :k :as 'Binding)))))
 
   (t/testing "path exists clause"
-    (t/is (= (p/make-path-exists-clause [:k "V"] p/the-existence-matcher 'V)
-             (p/parse-clause [:k 'V]))))
+    (t/testing "flat"
+      (t/is (= (p/make-path-exists-clause [:k "V"] p/the-existence-matcher 'V)
+               (p/parse-clause [:k 'V]))))
+    (t/testing "list"
+      (t/is (= (p/make-path-exists-clause [:k "V"] p/the-existence-matcher 'V)
+               (p/parse-clause (list [:k 'V]))))))
 
   (t/testing "path exists clause with binding"
     (t/is (= (p/make-path-exists-clause [:k "V"] p/the-existence-matcher 'Binding)