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


(defn- ensure-sequential
  [x-or-xs]
  (if (sequential? x-or-xs) x-or-xs [x-or-xs]))

(defn pad
  [msg-lists]
  (if (>= 1 (core/count msg-lists))
    msg-lists

  (map->Signal {:init init
                :message-emitter {:sources [source]
                                  :msg-fn (fn [acc [message]]
                                            (when (fresh? message)
                                              (->Fresh (f (:value message)
                                                          (:value acc)))))}}))

(defn drop-repeats
  [sig]
  (map->Signal {:init (:init sig)
                :message-emitter {:sources [sig]
                                  :msg-fn (fn [prev [msg]]
                                            (when (and (fresh? msg)
                                                       (not= (:value msg) (:value prev)))
                                              msg))}}))


(defn reducep
