           (observable? b)]}
    (.merge a b))
   ([a b & more]
-   (reduce merge (merge a b) more)))
+   (cljs.core/reduce merge (merge a b) more)))
 
 (defn filter
   "Filters the elements of an observable sequence

  observable sequence and then returns the remaining
  elements."
  [n ob]
  {:pre [(observable? ob) (number? f)]}
  (.skip ob f))

(defn take
  "Bypasses a specified number of elements in an
  observable sequence and then returns the remaining
  elements."
  [n ob]
  {:pre [(observable? ob) (number? f)]}
  (.take ob f))

(defn take-while
  "Returns elements from an observable sequence as long as a
  specified predicate returns true."
  [p ob]
  {:pre [(observable? ob) (number? p)]}
  (.takeWhile ob f))

(defn on-value
  "Subscribes a function to invoke for each element
  in the observable sequence."
  [obs f]
  (.subscribeOnNext obs f))

(defn on-error
  "Subscribes a function to invoke upon exceptional termination
  of the observable sequence."
  [obs f]
  (.subscribeOnError obs f))

(defn on-end
  "Subscribes a function to invoke upon graceful termination
  of the observable sequence."
  [obs f]
  (.subscribeOnCompleted obs f))

(defn subscribe
  "Subscribes an observer to the observable sequence."
  [obs nf ef cf]
  (.subscribe obs nf ef cf))

(defn reduce
  "Applies an accumulator function over an observable
  sequence, returning the result of the aggregation as a
  single element in the result sequence."
  ([f ob]
   (.reduce ob fn))
  ([f seed ob]
   (.reduce ob fn seed)))


(ns beicon.core
  (:require [beicon.extern.rxjs]
            [cats.protocols :as p]
            [cats.context :as ctx])
  (:refer-clojure :exclude [true? map filter reduce merge repeat repeatedly zip
