Support destructuring namespaced symbols (#1009)

Fixes #836

Author: chrisrink10

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Added `basilisp.pprint/print-table` function (#983)
  * Added `basilisp.core/read-seq` function (#986, #999)
  * Added various compiler arguments to CLI commands (#989)
+ * Added support for destructuring namespaced symbols using the `:ns/syms` syntax and non-keyword values in standard associative destructuring forms (#836)
 
 ### Changed
  * Improved on the nREPL server exception messages by matching that of the REPL user-friendly format (#968)

docs/concepts.rst

@@ -590,17 +590,17 @@ There exists a corresponding construct for the symbol and string key cases as we
 
    The keys for the ``:strs`` construct must be convertible to valid Basilisp symbols.
 
-It is possible to bind namespaced keys directly using either namespaced individual keys or a namespaced version of ``:keys`` as ``:ns/keys``.
+It is possible to bind namespaced keys and symbols directly using either namespaced individual values or a namespaced version of ``:keys`` (such as ``:ns/keys``) or ``:syms`` (``:ns/syms``).
 Values will be bound to the symbol by their *name* only (as by :lpy:fn:`name`) -- the namespace is only used for lookup in the associative data structure.
 
 .. code-block::
 
-   (let [{a :a b :a/b :c/keys [c d]} {:a   "a"
-                                      :b   "b"
-                                      :a/a "aa"
-                                      :a/b "bb"
-                                      :c/c "cc"
-                                      :c/d "dd"}]
+   (let [{a :a b 'a/b :c/keys [c] :c/syms [d]} {:a   "a"
+                                                :b   "b"
+                                                :a/a "aa"
+                                                'a/b "bb"
+                                                :c/c "cc"
+                                                'c/d "dd"}]
      [a b c d])
    ;;=> ["a" "bb" "cc" "dd"]
 

src/basilisp/core.lpy

@@ -5578,6 +5578,12 @@
                      (filter keyword?)
                      (filter #(= "keys" (name %))))
 
+        ;; Symbols may also be destructured from namespaced values as
+        ;; keywords can.
+        sym-keys (->> (keys arg)
+                      (filter keyword?)
+                      (filter #(= "syms" (name %))))
+
         ;; Keyword, string, and symbol keys may all be destructured from
         ;; associative types.
         kws  (mapcat (fn [kw]
@@ -5587,14 +5593,19 @@
                            kw-ns (map #(symbol kw-ns (name %))))))
                      kw-keys)
         strs (:strs arg)
-        syms (:syms arg)
+        syms (mapcat (fn [sym]
+                       (let [sym-ns (namespace sym)
+                             syms   (get arg sym)]
+                         (cond->> syms
+                           sym-ns (map #(symbol sym-ns (name %))))))
+                     sym-keys)
 
         ;; Fetch all the remaining keys in the map which do not
         ;; correspond to special functionality.
         ;; Destructuring forms may be nested arbitrarily, so generate the
         ;; definitions for any nested destructured forms as well.
         children (->> [:as :or :strs :syms]
-                      (concat kw-keys)
+                      (concat kw-keys sym-keys)
                       (apply dissoc arg)
                       (map (fn [arg]
                              ;; The val in this case is actually the key from
@@ -5640,10 +5651,8 @@
 
 (defmethod destructure-def :default
   [arg]
-  (throw
-   (ex-info "Invalid destructuring argument type"
-            {:type (python/type arg)
-             :arg  arg})))
+  {:name arg
+   :type :other})
 
 (defmulti ^:private destructure-binding
   (fn [ddef]
@@ -5700,11 +5709,12 @@
                           [arg `(get ~fn-arg ~k)])))
 
         sym-binding (fn [arg]
-                      (let [k          (symbol (name arg))
-                            or-binding (get ors arg)]
+                      (let [sym-name   (name arg)
+                            sym        (symbol sym-name)
+                            or-binding (get ors sym)]
                         (if or-binding
-                          [arg `(or (get ~fn-arg (quote ~k)) ~or-binding)]
-                          [arg `(get ~fn-arg (quote ~k))])))
+                          [sym `(or (get ~fn-arg (quote ~arg)) ~or-binding)]
+                          [sym `(get ~fn-arg (quote ~arg))])))
 
         named-binding (fn [arg]
                         (let [binding    (get-in arg [:binding :name])

tests/basilisp/test_core_macros.lpy

@@ -825,16 +825,39 @@
       (is (= [:c m] (f m)))
       (is (= ["aa" m1] (f m1)))))
 
+  (testing "destructuring namespaced symbols"
+    (let [m {'a   "a"
+             'b   "b"
+             'a/a "aa"
+             'a/b "bb"
+             'c/c "cc"
+             'c/d "dd"}
+
+          f (fn [{:a/syms [a] :syms [b]}]
+              [a b])
+          g (fn [{:syms [a b] :c/syms [c d]}]
+              [a b c d])]
+      (is (= ["aa" "b"] (f m)))
+      (is (= ["a" "b" "cc" "dd"] (g m))))
+
+    (let [m  {'a "a"}
+          m1 {'a/a "aa" 'a "a"}
+
+          f (fn [{:a/syms [a] :as m :or {a :c}}]
+              [a m])]
+      (is (= [:c m] (f m)))
+      (is (= ["aa" m1] (f m1)))))
+
   (testing "destructuring individual keys"
-    (let [m {:a "a" :b "b"}
+    (let [m {:a "a" :b "b" 3 "three" "key" "string-key"}
 
-          f (fn [{a :a}]
-              [a])
+          f (fn [{a :a three 3 s "key"}]
+              [a three s])
           g (fn [{a :a :as m}]
               [a m])
           h (fn [{a :a b :b :as m}]
               [a b m])]
-      (is (= ["a"] (f m)))
+      (is (= ["a" "three" "string-key"] (f m)))
       (is (= ["a" m] (g m)))
       (is (= ["a" "b" m] (h m))))
 
@@ -1042,9 +1065,11 @@
       (is (= {:a 1 :b "b" 'a :a} m))))
 
   (testing "destructuring individual keys"
-    (let [{a :a b :b} {:a "a" :b "b"}]
-      (is (= "a" a))
-      (is (= "b" b)))
+    (let [{a :a b :b three 3 s "key"} {:a "a"
+                                       :b "b"
+                                       3 "three"
+                                       "key" "string-key"}]
+      (is (= [a b three s] ["a" "b" "three" "string-key"])))
 
     (let [{a :a b :b :as m} {:a "a" :b "b"}]
       (is (= "a" a))
@@ -1089,6 +1114,36 @@
       (is (= "ee" c))
       (is (= "dd" d))))
 
+(testing "destructuring namespaced symbols"
+    (let [{:a/syms [a b] old-a 'a old-b 'b} {'a   "a"
+                                             'b   "b"
+                                             'a/a "aa"
+                                             'a/b "bb"
+                                             'c/c "cc"
+                                             'c/d "dd"}]
+      (is (= "aa" a))
+      (is (= "bb" b))
+      (is (= "a" old-a))
+      (is (= "b" old-b)))
+
+    (let [{:syms [a b] :c/syms [c d]} {'a   "a"
+                                       'b   "b"
+                                       'a/a "aa"
+                                       'a/b "bb"
+                                       'c/c "cc"
+                                       'c/d "dd"}]
+      (is (= "a" a))
+      (is (= "b" b))
+      (is (= "cc" c))
+      (is (= "dd" d)))
+
+    (let [{:syms [a b] :c/syms [c d] :or {c "ee"}}
+          {'a "a" 'b "b" 'a/a "aa" 'a/b "bb" 'c/d "dd"}]
+      (is (= "a" a))
+      (is (= "b" b))
+      (is (= "ee" c))
+      (is (= "dd" d))))
+
   (testing "nested destructuring"
     (let [{{:keys [a b] :as nested} :nested :as m} {:nested {:a "aa" :b "bb"} :a "a" :b "b"}]
       (is (= "aa" a))
@@ -1276,15 +1331,36 @@
         (is (= [:c m] (f m)))
         (is (= ["aa" m1] (f m1))))))
 
+  (testing "destructuring namespaced symbols"
+    (let [m {'a   "a"
+             'b   "b"
+             'a/a "aa"
+             'a/b "bb"
+             'c/c "cc"
+             'c/d "dd"}]
+      (letfn [(f [{:a/syms [a b] old-a 'a old-b 'b}]
+                [old-a old-b a b])
+              (g [{:syms [a b] :c/syms [c d]}]
+                [a b c d])]
+        (is (= ["a" "b" "aa" "bb"] (f m)))
+        (is (= ["a" "b" "cc" "dd"] (g m)))))
+
+    (let [m  {'a "a"}
+          m1 {'a/a "aa" 'a "a"}]
+      (letfn [(f [{:a/syms [a] :as m :or {a :c}}]
+                [a m])]
+        (is (= [:c m] (f m)))
+        (is (= ["aa" m1] (f m1))))))
+
   (testing "destructuring individual keys"
-    (let [m {:a "a" :b "b"}]
-      (letfn [(f [{a :a}]
-                [a])
+    (let [m {:a "a" :b "b" 3 "three" "key" "string-key"}]
+      (letfn [(f [{a :a three 3 s "key"}]
+                [a three s])
               (g [{a :a :as m}]
                 [a m])
               (h [{a :a b :b :as m}]
                 [a b m])]
-        (is (= ["a"] (f m)))
+        (is (= ["a" "three" "string-key"] (f m)))
         (is (= ["a" m] (g m)))
         (is (= ["a" "b" m] (h m)))))
 
@@ -1507,6 +1583,24 @@
                       (conj accum a b))
                [coll (apply str accum)])))))
 
+  (testing "destructuring namespaced syms"
+    (is (= [[{'a/a "A" 'a "a" 'b "b"}
+             {'a/a "C" 'a "c" 'b "d"}
+             {'a "e" 'b "e"}]
+            "AbCdZe"]
+           (loop [items                                [{'a/a "A" 'a "a" 'b "b"}
+                                                        {'a/a "C" 'a "c" 'b "d"}
+                                                        {'a "e" 'b "e"}]
+                  {:a/syms [a] b 'b :as m :or {a "Z"}} (first items)
+                  coll                                 []
+                  accum                                []]
+             (if m
+               (recur (rest items)
+                      (first (rest items))
+                      (conj coll m)
+                      (conj accum a b))
+               [coll (apply str accum)])))))
+
   (testing "nested destructuring"
     (is (= [[{:nested {:a "A"} :a "a" :b "b"}
              {:nested {:a "C"} :a "c" :b "d"}