   observable sequence and then returns the remaining
   elements."
   [n ob]
-  {:pre [(observable? ob) (number? f)]}
-  (.skip ob f))
+  {:pre [(observable? ob) (number? n)]}
+  (.skip ob n))
 
 (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))
+  {:pre [(observable? ob) (number? n)]}
+  (.take ob n))
 
 (defn take-while
   "Returns elements from an observable sequence as long as a
   specified predicate returns true."
-  [p ob]
-  {:pre [(observable? ob) (number? p)]}
+  [f ob]
+  {:pre [(observable? ob) (fn? f)]}
   (.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))
+   {:pre [(observable? ob) (fn? f)]}
+   (.reduce ob f))
   ([f seed ob]
-   (.reduce ob fn seed)))
-
+   {:pre [(observable? ob) (fn? f)]}
+   (.reduce ob f seed)))
+
+(defn tap
+  "Invokes an action for each element in the
+  observable sequence."
+  [f ob]
+  {:pre [(observable? ob) (fn? f)]}
+  (.tap ob f))
+
+(defn throttle
+  "Returns an Observable that emits only the first item
+  emitted by the source Observable during sequential
+  time windows of a specified duration."
+  [ms ob]
+  {:pre [(observable? ob) (number? ms)]}
+  (.throttle ob ms))
+
+(defn ignore
+  "Ignores all elements in an observable sequence leaving
+  only the termination messages."
+  [ob]
+  {:pre [(observable? ob)]}
+  (.ignoreElements ob))
+
+(defn pausable
+  [pauser ob]
+  {:pre [(observable? ob) (observable? pauser)]}
+  (.pausable ob pauser))
+
+

          (observable? b)]}
   (.concat a b))
  ([a b & more]
   (reduce concat (concat a b) more)))

(defn merge
  "Merges all the observable sequences and Promises

(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
