                      (set! *tx-state* new-state)
                      (add-change [key new-val])
                      new-val))))
-  (-insert! [coll val]
-    (assert insert-fn "insert! not supported by collection")
-    (-transact!* coll (fn [] (insert-fn val))))
-  (-get-cursor [coll key]
-    (if-let [cursor (get cursors key)]
-      cursor
-      (set! (.-cursors coll)
-            assoc
-            cursors
-            key
-            (r/cursor*
-              coll
-              (fn [state] (get state key))
-              (fn [state new-val]
-                (add-change [key new-val])
-                (update state key new-val))
-              (fn [coll f]
-                (-transact!* coll (fn [] (set! *tx-state* (f *tx-state*)))))
-              false
-              (fn [_])
-              ;(fn [sully] (set! (.-cursors coll)
-              ;                  (assoc cursors key
-              ;                         (fn []
-              ;                           (set! (.-cursors coll) (dissoc cursors key))
-              ;                           (sully)))))
-              ))))
 
   ITransientAssociative
   (-assoc! [coll key val]

(defn observable-map
  ([])
  ([init]
   (ObservableCollection. init nil nil nil)))

(defn observable-seq
  ([])

    (-transact!* coll
                 (fn []
                   (set! *tx-state* (dissoc *tx-state* key))
                   (add-change [key])))))

(defn transact!* [coll f]
  (if *tx-coll*
