`clojure.core/transient`¶

Type: function Added: Clojure 1.1 Examples: 4 Runnable: 2

([coll])

Returns a new, transient version of the collection, in constant time.

Transients support a parallel set of 'changing' operations, with similar names followed by ! - assoc!, conj! etc. These do the same things as their persistent counterparts except the return values are themselves transient.

Note in particular that transients are not designed to be bashed in-place. You must capture and use the return value in the next call. In this way, they support the same code structure as the functional persistent code they replace.

Examples¶

by gstamp on 2010-10-12

by yasuto on 2011-06-10 . May have evaluation errors.

by sanel on 2024-10-10 . May have evaluation errors.

by claj on 2025-11-22

;; This pattern emerges in serialized php-data, where both associative arrays 
;; (hash-maps) and vectors are serialized in the same way, but vectors only have
;; ordered positional keys.

;; The fun trick here is to do transient versions of both a hash-map and vector
;; but then only persist the accumulator we need.

(defn to-map-or-vector [kv-pairs]
  (let [n-keys (count kv-pairs)]
    (loop [[[k v] & rest-of-kv-pairs] kv-pairs 
           n 0
           ;; ^^ in reality k and v would be read from 
           ;; an input stream, hence the imperative `loop`

only-positional-keys? true

;; transient hash-map accumulator
           map-acc (transient {})
           ;; transient vector accumulator
           vec-acc (transient [])]
      (if (= n n-keys)
        ;; End case, now only persist the result we need:
        (if only-positional-keys?
          (persistent! vec-acc)
          (persistent! map-acc))
        (recur
         rest-of-kv-pairs
         (inc n)

;; when (not= n k) once this stays false
         (and only-positional-keys? (= n k))

;; update both accumulators optimistically
         (assoc! map-acc k v)
         ;; the vector thing could be optimized with the only-positional-keys? 
         ;; (but branching also has a cost)
         (conj! vec-acc v))))))

;; a vector
(to-map-or-vector [[0 :a] [1 :b] [2 :c]]) 
;;=>
[:a :b :c]

;; a hash-map. Could have be a vector at first glance, but no, it was a map!
(to-map-or-vector [[0 :a] [:cat :b] [:dog :c]]) 
;;=>
{0 :a, :cat :b, :dog :c}

clojure.core/transient¶

Examples¶

See also¶

`clojure.core/transient`¶