Can you give an example? I don't understand what you mean.

If you're thinking of like let bindings, it's to ensure ordering

I mean malli , but I've seen this in other places as well.

@U03RQQ5E8Q1 The choice of data structure is usually driven by the patterns of access (and sometimes construction). If you want O(1) lookup by (arbitrary) key, use a hash map (or a set); if you want O(1) lookup by index, use a vector. Vectors are optimized for adding elements at the end; lists are optimized for adding elements at the beginning. Both vectors and lists are great for ordered, sequential access; hash maps and sets are unordered.

In malli / hiccup, vectors allow for concise, optional option maps.

;; with vectors:
[:a {:href "#section-2"} "Section 2"]

;; with a map:
{:tag :a
 :opts {:href "#sections"}
 :content "Section 2"}

;; but why not

{:a "Section 2"}

;; ?
;;
;; Well, where would you put the options?

#cljfx has gone the "it's all maps" route:

(fx/on-fx-thread
 (fx/create-component
  {:fx/type :stage
   :showing true
   :title "Cljfx example"
   :width 300
   :height 100
   :scene {:fx/type :scene
           :root {:fx/type :v-box
                  :alignment :center
                  :children [{:fx/type :label
                              :text "Hello world"}]}}}))

@U3X7174KS, yeah, that's what I mean. Thanks for understanding my poorly formulated question. And thanks everyone. Some things are not immediately obvious.

(defn f [] 1)
(meta #'f)
=>
{:arglists ([]), :line 1, :column 1, :file "NO_SOURCE_PATH", :name f, :ns #object[clojure.lang.Namespace 0xf876b9e "user"]}

doens't work for fn's though:

user=> (def x (fn [] 2))
#'user/x
user=> (meta #'x)
{:line 1, :column 1, :file "NO_SOURCE_PATH", :name x, :ns #object[clojure.lang.Namespace 0xf876b9e "user"]}

the #' is the way to get the symbol from the var, or something like that, otherwise you get the value instead of the symbol which is the thing that has the meta data on it

No, because when you use defn, the metadata is attached to the resulting var. And in the case of let, there are no vars, so no metadata.

thank you p-himik : )

(let [f (fn [x y z] (println x y z))]
    (require 'clojure.reflect)
    (->> (clojure.reflect/reflect f)
         :members
         (filter #(instance? clojure.reflect.Method %))
         first
         :parameter-types
         count))

(let [f (fn
            ([x] (println x))
            ([x y] (println x y))
            ([x y z] (println x y z)))]
    (require 'clojure.reflect)
    (->> (clojure.reflect/reflect f)
         :members
         (filter #(instance? clojure.reflect.Method %))
         (map (comp count :parameter-types))))

(3 2 1)

thank you dpsutton : )