   (map->Signal {:init (:init (first sigs))
                 :message-emitter {:sources sigs
                                   :msg-fn (fn [prev messages]
-                                            (or (first (filter fresh? messages))
-                                                (->Cached (:value prev))))}}))
+                                            (first (filter fresh? messages)))}}))
 
 (defn merge
   [& sigs]

    {:sources [:events]
     :relayed-event-topics topics
     :msg-fn (fn [prev [event]]
               (if (contains? topics (:topic event))
                 (->Fresh (:value event))
                 (->Cached (:value prev))))}))

(defrecord Signal
  [init message-emitter deps event-sources]

  (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
