Destructuring function arguments

[peaceamongworlds]

It would be nice to have support for destructuring within function arguments. For example,

(defn foo [[x y]]
  (+ x y))

(foo [1 2]) ; => 3

I think this would be relatively easy to add by slightly changing the definition of the defn macro, or maybe a new defn+ macro. A possible implementation could be (this ignores any possible &optional and &rest variables)

(defmacro defn+ [fn-name args &rest body]
  (setv arg-list (lfor _ args (gensym)))
  `(defn ~fn-name
     ~arg-list
     (setv ~args ~arg-list)
     ~@body))

Associative destructuring like in clojure would also be really useful, but I can't see how to make this work nicely with python's list destructuring. As a starting point, this simple example works but is not recursive:

(defmacro destructure-assoc [pattern coll]
  `(setv ~(.values pattern) (lfor k ~(.keys pattern) (.get ~coll k None))))

(destructure-assoc {"as" [a b] "c" c} {"as" [4 5] "c" 6})
[a b c] ; => [4 5 6]

[Kodiologist]

The sequence version used to be built-in, and then was removed by #1590. A pull request to add something more like Clojure, namely #1328, eventually petered out.