如何在ClojureScript中实现持久化TypedArray？

Great question! Dealing with persistent data structures alongside mutable TypedArrays in ClojureScript can definitely feel tricky, especially when performance is a concern. Let’s break down some practical approaches to handle this, balancing idiomatic ClojureScript style and performance:

1. Wrap Mutable TypedArrays in Persistent Wrappers #

The simplest approach is to create a persistent wrapper around a mutable Uint8Array that mimics ClojureScript’s persistent vector interface. Every modification returns a new wrapper instance with a copied underlying TypedArray, leaving the original unchanged.

Here’s a minimal implementation:

(defrecord PersistentUint8Array [arr]
  cljs.core/ILookup
  (get [_ k] (aget arr k))
  
  cljs.core/Associative
  (assoc [_ k v]
    (let [new-arr (js/Uint8Array. arr)] ; Shallow copy the original array
      (aset new-arr k v)
      (->PersistentUint8Array new-arr)))
  
  cljs.core/Counted
  (-count [_] (.-length arr))
  
  cljs.core/Seqable
  (-seq [_] (seq (js/Array.from arr))))

;; Usage example
(def p-arr (->PersistentUint8Array (js/Uint8Array. [1 2 3])))
(def updated-p-arr (assoc p-arr 1 5))

;; Original remains intact
(println (get p-arr 1))       ; Output: 2
(println (get updated-p-arr 1)) ; Output: 5

Pros: Follows familiar ClojureScript persistent data patterns, easy to implement and use.
Cons: Full array copy on every modification can be slow for large arrays (10k+ elements). Best suited for small to medium-sized datasets.

2. Structural Sharing with Chunked Arrays #

For larger arrays, we can borrow the chunked structure of ClojureScript’s vectors to minimize copying. Split the underlying data into smaller chunks (e.g., 32 or 64 elements), so only the modified chunk is copied on updates—all other chunks are shared between instances.

Here’s a simplified chunked implementation:

(defn create-chunked-persistent-uint8 [size chunk-size]
  (let [num-chunks (js/Math.ceil (/ size chunk-size))
        chunks (vec (repeatedly num-chunks #(js/Uint8Array. chunk-size)))]
    {:chunks chunks :chunk-size chunk-size :length size}))

(defn chunked-assoc [p-arr idx val]
  (let [{:keys [chunks chunk-size length]} p-arr
        chunk-idx (js/Math.floor (/ idx chunk-size))
        offset (mod idx chunk-size)
        old-chunk (nth chunks chunk-idx)
        new-chunk (js/Uint8Array. old-chunk)] ; Copy only the target chunk
    (aset new-chunk offset val)
    (assoc p-arr :chunks (assoc chunks chunk-idx new-chunk))))

;; Usage example
(def big-p-arr (create-chunked-persistent-uint8 1000 64))
(def updated-big-arr (chunked-assoc big-p-arr 450 255))

Pros: Dramatically reduces copy overhead for large arrays—only a small chunk is duplicated per update.
Cons: Requires more boilerplate to handle chunk indexing, boundary cases (e.g., partial final chunks), and additional operations like iteration or slicing.

3. Batch Transformations with Transducers #

If your workflow involves a series of transformations before needing a TypedArray, use ClojureScript’s transducers to process persistent data efficiently first, then generate the TypedArray in one final step. This avoids repeated conversions between persistent structures and TypedArrays.

Example:

;; Start with a persistent vector of raw data
(def raw-data (vec (range 1000)))

;; Use transducers to apply transformations efficiently
(def processed-data
  (into []
        (comp
          (filter even?)
          (map #(* % 3)))
        raw-data))

;; Generate the TypedArray once after all processing
(def final-typed-arr (js/Uint8Array. processed-data))

Pros: Minimizes performance overhead by leveraging transducers’ efficient, lazy processing, with only one conversion to a TypedArray.
Cons: Only applicable if you can batch all transformations before needing the TypedArray—doesn’t help with incremental updates.

4. Use Immutable.js’s Persistent TypedArray Wrappers #

If you don’t want to roll your own implementation, Immutable.js provides a ready-made persistent wrapper for TypedArrays (like Immutable.Uint8Array) that handles structural sharing out of the box. It integrates well with ClojureScript and avoids manual copy management.

Pros: Production-ready, battle-tested implementation with full structural sharing support.
Cons: Adds an external dependency to your project.

Final Recommendations #

• For small arrays: Go with the simple persistent wrapper.
• For large arrays with frequent updates: Implement a chunked structure or use Immutable.js.
• For batch processing workflows: Use transducers to minimize conversion overhead.

内容的提问来源于stack exchange，提问作者Addict