     (constant (f))
     (let [sources (vec sources)
           emit-message (fn [prev messages]
-                         (if (some fresh? messages)
-                           (->Fresh (apply f (mapv :value messages)))
-                           (->Cached (:value prev))))]
+                         (when (some fresh? messages)
+                           (->Fresh (apply f (mapv :value messages)))))]
       (map->Signal {:init (->> sources
                                (mapv (comp ->Fresh :init))
                                (emit-message nil)

                       (core/map ->Fresh))
                 conj)
        msg-fn (fn [prev [msg :as msg-in-seq]]
                 (if (fresh? msg)
                   (reduce reducer [] msg-in-seq)
                   (->Cached (:value prev))))
        pipelined-init-msg (->> (:init sig) ->Fresh vector (msg-fn nil) last)
        init-val (if (nil? pipelined-init-msg)
                   base

  (map->Signal {:init (:init value-sig)
                :message-emitter {:sources [sampler-sig value-sig]
                                  :msg-fn (fn [prev [sampler-msg value-msg]]
                                            (when (fresh? sampler-msg)
                                              (->Fresh (:value value-msg))))}}))

(defn count
  [sig]
