               (let [[m m-chs ch-in :as cache] (get subs identifier)
                     m-chs (dec m-chs)
                     chs (dissoc chs target)]
-                (println ["cache canceling" identifier])
+                #_(println ["cache canceling" identifier])
                 (untap m target-step)
                 (close! target-step)
                 (if (zero? m-chs)

              (reset! chs nil)
              (recur cache
                     false))
            (do (when-let [chs (seq @chs)]
                  (reset! dctr (count chs))
                  (doseq [ch chs]
                    (when-not (put! ch v done)
                      (a/untap* m ch)))
                  (<! dchan))
                (recur (accumulate cache v)
                       true))))))
    m))

(defn- cached-service
  [service accumulate]
  (let [subscribe-ch (chan)
        cancel-ch (chan)]
    (go-loop [subs {}

                [m :as cache]
                (or (get subs identifier)
                    (let [ch-in (chan)
                          m (caching-mult ch-in opts)]
                      (subscribe (caching service this)
                                 identifier
                                 ch-in)
                      [m 0 ch-in]))
                target-step (wrap-on-close target
                                           #(cancel this target))]
            #_(println ["cache subscribing" identifier])
            (tap m target-step)
            (recur (assoc subs identifier (update cache 1 inc))
                   (assoc chs target [identifier target-step])))
