Interpret symbols as strings in clause parser.

Author: neshtea

src/active/clojure/match.clj

@@ -337,7 +337,6 @@
         :key-matches-with-binding ::key-matches-with-binding
         :path-matches ::path-matches
         :path-matches-with-binding ::path-matches-with-binding))
-(s/conform ::clause (list :k (list :compare-fn even?)))
 
 (defn match-value->matcher
   [[kind match-value]]
@@ -347,6 +346,11 @@
     (= :compare-fn kind) (match-predicate (:fn match-value))
     :else                (match-const match-value)))
 
+(defn make-key
+  "Returns k as a string if k is a symbol, otherwise returns k."
+  [[kind k]]
+  (if (= :symbol kind) (str k) k))
+
 (defn parse-clause
   [p]
   (letfn [(optional? [k]
@@ -362,49 +366,49 @@
           (case match
             :key-exists
             (if (optional? mode)
-              (opt (key-exists-clause (second (:key body))))
-              (key-exists-clause (second body)))
+              (opt (key-exists-clause (make-key (:key body))))
+              (key-exists-clause (make-key body)))
 
             :key-exists-with-binding
-            (let [clause (-> (key-exists-clause (second (:key body)))
+            (let [clause (-> (key-exists-clause (make-key (:key body)))
                              (bind-match (:binding body)))]
               (if (optional? mode) (opt clause) clause))
 
             :path-exists
             (if (optional? mode)
-              (opt (path-exists-clause (mapv second (:path body))))
-              (path-exists-clause (mapv second body)))
+              (opt (path-exists-clause (mapv make-key (:path body))))
+              (path-exists-clause (mapv make-key body)))
 
             :path-exists-with-binding
             (let [{:keys [path binding]} body
 
-                  components (mapv second path)
+                  components (mapv make-key path)
                   clause     (bind-match (path-exists-clause components) binding)]
               (if (optional? mode) (opt clause) clause))
 
             :key-matches
             (let [{:keys [key match-value]} body
 
-                  clause (key-matches-clause (second key) (match-value->matcher match-value))]
+                  clause (key-matches-clause (make-key key) (match-value->matcher match-value))]
               (if (optional? mode) (opt clause) clause))
 
             :key-matches-with-binding
             (let [{:keys [key match-value binding]} body
 
-                  clause (bind-match (key-matches-clause (second key) (match-value->matcher match-value)) binding)]
+                  clause (bind-match (key-matches-clause (make-key key) (match-value->matcher match-value)) binding)]
               (if (optional? mode) (opt clause) clause))
 
             :path-matches
             (let [{:keys [path match-value]} body
 
-                  components (mapv second path)
+                  components (mapv make-key path)
                   clause     (path-matches-clause components (match-value->matcher match-value))]
               (if (optional? mode) (opt clause) clause))
 
             :path-matches-with-binding
             (let [{:keys [path match-value binding]} body
 
-                  components (mapv second path)
+                  components (mapv make-key path)
                   clause     (bind-match (path-matches-clause components (match-value->matcher match-value)) binding)]
               (if (optional? mode) (opt clause) clause))))))))
 

test/active/clojure/match_test.clj

@@ -14,11 +14,11 @@
              (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)
+    (t/is (= (p/make-path-exists-clause [:k "V"] p/the-existence-matcher 'V)
              (p/parse-clause [:k 'V]))))
 
   (t/testing "path exists clause with binding"
-    (t/is (= (p/make-path-exists-clause [:k 'V] p/the-existence-matcher 'Binding)
+    (t/is (= (p/make-path-exists-clause [:k "V"] p/the-existence-matcher 'Binding)
              (p/parse-clause (list [:k 'V] :as 'Binding)))))
 
   (t/testing "key matches clause"
@@ -36,11 +36,11 @@
              (p/parse-clause (list :k "foo" :as 'Binding)))))
 
   (t/testing "path matches clause"
-    (t/is (= (p/make-path-matches-clause [:k 'bar 'baz] (p/make-constant-matcher "foo") 'baz)
+    (t/is (= (p/make-path-matches-clause [:k "bar" "baz"] (p/make-constant-matcher "foo") 'baz)
              (p/parse-clause (list [:k 'bar 'baz] "foo")))))
 
   (t/testing "path matches clause with binding"
-    (t/is (= (p/make-path-matches-clause [:k 'bar 'baz] (p/make-constant-matcher "foo") 'Binding)
+    (t/is (= (p/make-path-matches-clause [:k "bar" "baz"] (p/make-constant-matcher "foo") 'Binding)
              (p/parse-clause (list [:k 'bar 'baz] "foo" :as 'Binding)))))
 
   (t/testing "with an options matcher"
@@ -58,7 +58,7 @@
              (p/parse-clause (list '? :k))))
     (t/is (= (p/make-optional-clause (p/make-key-exists-clause :k p/the-existence-matcher 'Binding))
              (p/parse-clause (list '? :k :as 'Binding))))
-    (t/is (= (p/make-optional-clause (p/make-path-matches-clause [:k 'bar 'baz] (p/make-constant-matcher "foo") 'Binding))
+    (t/is (= (p/make-optional-clause (p/make-path-matches-clause [:k "bar" "baz"] (p/make-constant-matcher "foo") 'Binding))
              (p/parse-clause (list '? [:k 'bar 'baz] "foo" :as 'Binding))))))
 
 (t/deftest parse-pattern-test