                 :message-emitter {:sources [source]
                                   :msg-fn (fn [acc [message]]
                                             (when (fresh? message)
-                                              (->Fresh (f (:value message)
-                                                          (:value acc)))))}}))
-
-(defn reducep
-  "Create a past-dependent signal like `foldp`, but calls `f` with the arguments
-  reversed to align with Clojure's `reduce`: the first argument is the accumulator,
-  and the second is the current value of `source`. If `init` is omitted, the initial
-  value of the new signal will be obtained by calling `f` with no arguments."
-  ([f source] (reducep f (f) source))
-  ([f init source]
-   (->> source
-        (foldp (fn [val acc] (f acc val)) init)
-        drop-repeats)))
-
-(defn transducep
-  "Like `reducep`, but transforms the reducing function `f` with transducer `xform`."
-  ([xform f source] (reducep (xform f) (f) source))
-  ([xform f init source]
-   (reducep (xform f) init source)))
+                                              (->Fresh (f (value message)
+                                                          (value acc)))))}}))
 
 (defn drop-repeats
   "Returns a signal which relays values of `sig`, but drops repeated equal values."

                :message-emitter {:sources [sig]
                                  :msg-fn (fn [prev [msg]]
                                            (when (and (fresh? msg)
                                                       (not= (:value msg) (:value prev)))
                                              msg))}}))

(defn async
  "Returns an \"asynchronous\" version of `source`, splitting off a new subgraph which

                :message-emitter {:sources [sig]
                                  :msg-fn (fn [prev [msg]]
                                            (when (and (fresh? msg)
                                                       (pred (value msg)))
                                              (->Fresh (value msg))))}}))

(defn drop-if
  "Like `keep-if`, but drops values which match the predicate."
