元数据 #

(meta ^:private {:a 1})

(meta ^{:doc "A variable"} #'map)

(meta (with-meta [1 2 3] {:type :vector}))

^{:private true} {:a 1}

^:private {:a 1}

^[String] {:name "test"}

^{:tag String} "hello"

(def data (with-meta [1 2 3] {:type :vector :count 3}))

(meta data)

data

(def data [1 2 3])

(def data-with-meta
  (vary-meta data assoc :type :vector))

(meta data-with-meta)

(def ^:private secret "hidden")

(def ^{:doc "A constant" :const true} PI 3.14159)

(meta #'secret)

(meta #'PI)

(def data (with-meta {:a 1} {:source :test}))

(meta data)

(meta ^:private [1 2 3])

(defn my-function
  "This is a doc string"
  [x]
  (* x x))

(meta #'my-function)

(:doc (meta #'my-function))

(:arglists (meta #'my-function))

(ns my-ns
  {:author "Alice"
   :version "1.0.0"})

(meta (find-ns 'my-ns))

(def ^:private internal-value 42)

(defn ^:private helper []
  "internal helper")

(def ^{:doc "The value of PI"} PI 3.14159)

(defn ^{:doc "Calculate square"} square [x] (* x x))

(defn ^String process [^String s]
  (.toUpperCase s))

(defn add [^Long a ^Long b]
  (+ a b))

(def ^:const MAX-VALUE 100)

(def ^:const DEFAULT-TIMEOUT 5000)

(def ^:dynamic *config* {:debug false})

(binding [*config* {:debug true}]
  *config*)

(defn ^:deprecated old-function []
  "Use new-function instead")

(def data (with-meta [1 2 3] {:type :vector}))

(meta data)

(meta (conj data 4))

(meta (seq data))

(def data (with-meta {:a 1} {:source :test}))

(meta (assoc data :b 2))

(meta (dissoc data :a))

(meta (into {} data))

(defn merge-with-meta [m1 m2]
  (let [merged (merge m1 m2)
        meta1 (meta m1)
        meta2 (meta m2)]
    (with-meta merged (merge meta1 meta2))))

(def m1 (with-meta {:a 1} {:source :test1}))
(def m2 (with-meta {:b 2} {:source :test2}))

(meta (merge-with-meta m1 m2))

(defn my-function
  "Documentation string"
  {:added "1.0"
   :deprecated "2.0"}
  [x]
  (* x x))

(meta #'my-function)

(defn process [^String name ^Long age]
  (str name " is " age " years old"))

(meta #'process)

(def f (with-meta
         (fn [x] (* x x))
         {:doc "Square function"}))

(meta f)

(defn with-validation [data validator]
  (vary-meta data assoc :validator validator))

(defn validate [data]
  (if-let [validator (:validator (meta data))]
    (validator data)
    true))

(def valid-data
  (with-validation
    {:name "Alice" :age 30}
    #(and (string? (:name %))
          (pos? (:age %)))))

(validate valid-data)

(defn with-source [data source]
  (vary-meta data assoc :source source :timestamp (System/currentTimeMillis)))

(defn get-source [data]
  (select-keys (meta data) [:source :timestamp]))

(def user-data (with-source {:id 1 :name "Alice"} :api))

(get-source user-data)

(defn with-cache-info [data ttl]
  (vary-meta data assoc
             :cached true
             :ttl ttl
             :created (System/currentTimeMillis)))

(defn is-cache-valid? [data]
  (let [{:keys [cached ttl created]} (meta data)]
    (and cached
         (< (- (System/currentTimeMillis) created) ttl))))

(def cached-data (with-cache-info {:result "data"} 60000))

(is-cache-valid? cached-data)

(defn with-api-version [data version]
  (vary-meta data assoc :api-version version))

(defn requires-version [data min-version]
  (let [version (:api-version (meta data))]
    (when (and version (< version min-version))
      (throw (ex-info "API version too old"
                      {:required min-version
                       :actual version})))))

(def v1-data (with-api-version {:users []} 1))

(requires-version v1-data 1)

(meta 42)

(meta "string")

(meta :keyword)

(= (with-meta {:a 1} {:x 1})
   (with-meta {:a 1} {:x 2}))

(defn show-meta [obj]
  (let [m (meta obj)]
    (when m
      (doseq [[k v] m]
        (println k "=" v)))))

(show-meta #'map)

(defn copy-meta [from to]
  (with-meta to (meta from)))

(def source (with-meta {:a 1} {:source :test}))
(def target {:b 2})

(meta (copy-meta source target))