 
 (core/defn destructure [bindings]
   (core/let [bents (partition 2 bindings)
-         pb (core/fn pb [bvec b v]
-              (core/let [pvec
-                     (core/fn [bvec b val]
-                       (core/let [gvec (gensym "vec__")]
-                         (core/loop [ret (core/-> bvec (conj gvec) (conj val))
-                                     n 0
-                                     bs b
-                                     seen-rest? false]
-                           (if (seq bs)
-                             (core/let [firstb (first bs)]
-                               (core/cond
-                                 (= firstb '&) (recur (pb ret (second bs) (core/list `nthnext gvec n))
-                                                      n
-                                                      (nnext bs)
-                                                      true)
-                                 (= firstb :as) (pb ret (second bs) gvec)
-                                 :else (if seen-rest?
-                                         (throw
-                                           #?(:clj (new Exception "Unsupported binding form, only :as can follow & parameter")
-                                              :cljs (new js/Error "Unsupported binding form, only :as can follow & parameter")))
-                                         (recur (pb ret firstb (core/list `nth gvec n nil))
-                                                (core/inc n)
-                                                (next bs)
-                                                seen-rest?))))
-                             ret))))
-                     pmap
-                     (core/fn [bvec b v]
-                       (core/let [gmap (gensym "map__")
-                                  defaults (:or b)]
-                         (core/loop [ret (core/-> bvec (conj gmap) (conj v)
-                                             (conj gmap) (conj `(if (seq? ~gmap) (apply core/hash-map ~gmap) ~gmap))
-                                             ((core/fn [ret]
-                                                (if (:as b)
-                                                  (conj ret (:as b) gmap)
-                                                  ret))))
-                                     bes (reduce
-                                          (core/fn [bes entry]
-                                            (reduce #(assoc %1 %2 ((val entry) %2))
-                                                    (dissoc bes (key entry))
-                                                    ((key entry) bes)))
-                                          (dissoc b :as :or)
-                                          {:keys #(if (core/keyword? %) % (keyword (core/str %))),
-                                           :strs core/str, :syms #(core/list `quote %)})]
-                           (if (seq bes)
-                             (core/let [bb (key (first bes))
-                                        bk (val (first bes))
-                                        has-default (contains? defaults bb)]
-                               (recur (pb ret bb (if has-default
-                                                   (core/list `get gmap bk (defaults bb))
-                                                   (core/list `get gmap bk)))
-                                      (next bes)))
-                             ret))))]
+             pb (core/fn pb [bvec b v]
+                  (core/let [pvec
+                             (core/fn [bvec b val]
+                               (core/let [gvec (gensym "vec__")]
+                                 (core/loop [ret (core/-> bvec (conj gvec) (conj val))
+                                             n 0
+                                             bs b
+                                             seen-rest? false]
+                                   (if (seq bs)
+                                     (core/let [firstb (first bs)]
+                                       (core/cond
+                                         (= firstb '&) (recur (pb ret (second bs) (core/list `nthnext gvec n))
+                                                         n
+                                                         (nnext bs)
+                                                         true)
+                                         (= firstb :as) (pb ret (second bs) gvec)
+                                         :else (if seen-rest?
+                                                 (throw
+                                                   #?(:clj (new Exception "Unsupported binding form, only :as can follow & parameter")
+                                                      :cljs (new js/Error "Unsupported binding form, only :as can follow & parameter")))
+                                                 (recur (pb ret firstb (core/list `nth gvec n nil))
+                                                   (core/inc n)
+                                                   (next bs)
+                                                   seen-rest?))))
+                                     ret))))
+                             pmap
+                             (core/fn [bvec b v]
+                               (core/let [gmap (gensym "map__")
+                                          defaults (:or b)]
+                                 (core/loop [ret (core/-> bvec (conj gmap) (conj v)
+                                                   (conj gmap) (conj `(if (seq? ~gmap) (apply core/hash-map ~gmap) ~gmap))
+                                                   ((core/fn [ret]
+                                                      (if (:as b)
+                                                        (conj ret (:as b) gmap)
+                                                        ret))))
+                                             bes (reduce
+                                                   (core/fn [bes entry]
+                                                     (reduce #(assoc %1 %2 ((val entry) %2))
+                                                       (dissoc bes (key entry))
+                                                       ((key entry) bes)))
+                                                   (dissoc b :as :or)
+                                                   {:keys #(if (core/keyword? %) % (keyword (core/str %))),
+                                                    :strs core/str, :syms #(core/list `quote %)})]
+                                   (if (seq bes)
+                                     (core/let [bb (key (first bes))
+                                                bk (val (first bes))
+                                                has-default (contains? defaults bb)]
+                                       (recur (pb ret bb (if has-default
+                                                           (core/list `get gmap bk (defaults bb))
+                                                           (core/list `get gmap bk)))
+                                         (next bes)))
+                                     ret))))]
                     (core/cond
                       (core/symbol? b) (core/-> bvec (conj (if (namespace b) (symbol (name b)) b)) (conj v))
                       (core/keyword? b) (core/-> bvec (conj (symbol (name b))) (conj v))

                               (core/list form x))]
           (recur threaded (next forms)))
         x))))

(core/defn- ^{:dynamic true} assert-valid-fdecl
  "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn."

                      :else (throw
                              #?(:clj (new Exception (core/str "Unsupported binding form: " b))
                                 :cljs (new js/Error (core/str "Unsupported binding form: " b)))))))
             process-entry (core/fn [bvec b] (pb bvec (first b) (second b)))]
    (if (every? core/symbol? (map first bents))
      bindings
      (core/if-let [kwbs (seq (filter #(core/keyword? (first %)) bents))]
        (throw
          #?(:clj (new Exception (core/str "Unsupported binding key: " (ffirst kwbs)))
             :cljs (new js/Error (core/str "Unsupported binding key: " (ffirst kwbs)))))
        (reduce process-entry [] bents)))))

(core/defmacro let
  "binding => binding-form init-expr
