diff --git a/reactfx/src/main/java/org/reactfx/AccumulateBetweenStream.java b/reactfx/src/main/java/org/reactfx/AccumulateBetweenStream.java
index 5804178..5dc5e96 100644
--- a/reactfx/src/main/java/org/reactfx/AccumulateBetweenStream.java
+++ b/reactfx/src/main/java/org/reactfx/AccumulateBetweenStream.java
@@ -4,7 +4,7 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
-class AccumulateBetweenStream<T, A> extends LazilyBoundStream<T> {
+class AccumulateBetweenStream<T, A> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final EventStream<?> ticks;
     private final Function<? super T, ? extends A> initialTransformation;
diff --git a/reactfx/src/main/java/org/reactfx/AccumulateUntilLaterStream.java b/reactfx/src/main/java/org/reactfx/AccumulateUntilLaterStream.java
index 538e063..66c945a 100644
--- a/reactfx/src/main/java/org/reactfx/AccumulateUntilLaterStream.java
+++ b/reactfx/src/main/java/org/reactfx/AccumulateUntilLaterStream.java
@@ -5,7 +5,7 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
-class AccumulateUntilLaterStream<T, A> extends LazilyBoundStream<T> {
+class AccumulateUntilLaterStream<T, A> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final Function<? super T, ? extends A> initialTransformation;
     private final BiFunction<? super A, ? super T, ? extends A> accumulation;
diff --git a/reactfx/src/main/java/org/reactfx/AccumulatingStream.java b/reactfx/src/main/java/org/reactfx/AccumulatingStream.java
index 5daf205..0207ac0 100644
--- a/reactfx/src/main/java/org/reactfx/AccumulatingStream.java
+++ b/reactfx/src/main/java/org/reactfx/AccumulatingStream.java
@@ -3,7 +3,7 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
-class AccumulatingStream<T, U> extends LazilyBoundStream<U> {
+class AccumulatingStream<T, U> extends EventStreamBase<U> {
     private final EventStream<T> input;
     private final Function<? super T, ? extends U> initialTransformation;
     private final BiFunction<? super U, ? super T, ? extends U> reduction;
diff --git a/reactfx/src/main/java/org/reactfx/Await.java b/reactfx/src/main/java/org/reactfx/Await.java
index 50d23c6..f30bc75 100644
--- a/reactfx/src/main/java/org/reactfx/Await.java
+++ b/reactfx/src/main/java/org/reactfx/Await.java
@@ -14,7 +14,7 @@
 import org.reactfx.util.TriConsumer;
 import org.reactfx.util.Try;
 
-class Await<T, F, R> extends LazilyBoundStream<R> implements AwaitingEventStream<R> {
+class Await<T, F, R> extends EventStreamBase<R> implements AwaitingEventStream<R> {
 
     public static <T> AwaitingEventStream<T> awaitCompletionStage(
             EventStream<CompletionStage<T>> source,
@@ -61,7 +61,7 @@ static <T> void addCompletionHandler(
         t.addEventHandler(WORKER_STATE_CANCELLED, e -> handler.accept(null, null, true));
     }
 
-    static <T> TriConsumer<LazilyBoundStream<T>, T, Throwable> reportingEmitter() {
+    static <T> TriConsumer<EventStreamBase<T>, T, Throwable> reportingEmitter() {
         return (stream, value, error) -> {
             if(error == null) {
                 stream.emit(value);
@@ -71,7 +71,7 @@ static <T> TriConsumer<LazilyBoundStream<T>, T, Throwable> reportingEmitter() {
         };
     }
 
-    static <T> TriConsumer<LazilyBoundStream<Try<T>>, T, Throwable> tryEmitter() {
+    static <T> TriConsumer<EventStreamBase<Try<T>>, T, Throwable> tryEmitter() {
         return (stream, value, error) -> {
             if(error == null) {
                 stream.emit(Try.success(value));
@@ -84,12 +84,12 @@ static <T> TriConsumer<LazilyBoundStream<Try<T>>, T, Throwable> tryEmitter() {
     private final EventStream<F> source;
     private final Indicator pending = new Indicator();
     private final BiConsumer<F, TriConsumer<T, Throwable, Boolean>> addCompletionHandler;
-    private final TriConsumer<LazilyBoundStream<R>, T, Throwable> emitter;
+    private final TriConsumer<EventStreamBase<R>, T, Throwable> emitter;
 
     private Await(
             EventStream<F> source,
             BiConsumer<F, TriConsumer<T, Throwable, Boolean>> addCompletionHandler,
-            TriConsumer<LazilyBoundStream<R>, T, Throwable> emitter) {
+            TriConsumer<EventStreamBase<R>, T, Throwable> emitter) {
         this.source = source;
         this.addCompletionHandler = addCompletionHandler;
         this.emitter = emitter;
@@ -120,7 +120,7 @@ protected final Subscription subscribeToInputs() {
 }
 
 
-class AwaitLatest<T, F, R> extends LazilyBoundStream<R> implements AwaitingEventStream<R> {
+class AwaitLatest<T, F, R> extends EventStreamBase<R> implements AwaitingEventStream<R> {
 
     public static <T> AwaitingEventStream<T> awaitCompletionStage(
             EventStream<CompletionStage<T>> source,
@@ -214,7 +214,7 @@ public static <T> AwaitingEventStream<Try<T>> tryAwaitTask(
     private final EventStream<?> cancelImpulse;
     private final Consumer<F> canceller;
     private final BiConsumer<F, TriConsumer<T, Throwable, Boolean>> addCompletionHandler;
-    private final TriConsumer<LazilyBoundStream<R>, T, Throwable> emitter;
+    private final TriConsumer<EventStreamBase<R>, T, Throwable> emitter;
 
     private long revision = 0;
     private F expectedFuture = null;
@@ -226,7 +226,7 @@ private AwaitLatest(
             EventStream<?> cancelImpulse,
             Consumer<F> canceller,
             BiConsumer<F, TriConsumer<T, Throwable, Boolean>> addCompletionHandler,
-            TriConsumer<LazilyBoundStream<R>, T, Throwable> emitter) {
+            TriConsumer<EventStreamBase<R>, T, Throwable> emitter) {
         this.source = source;
         this.cancelImpulse = cancelImpulse;
         this.canceller = canceller;
diff --git a/reactfx/src/main/java/org/reactfx/ConnectableEventSource.java b/reactfx/src/main/java/org/reactfx/ConnectableEventSource.java
index 78de738..255728e 100644
--- a/reactfx/src/main/java/org/reactfx/ConnectableEventSource.java
+++ b/reactfx/src/main/java/org/reactfx/ConnectableEventSource.java
@@ -4,7 +4,7 @@
 
 
 public final class ConnectableEventSource<T>
-extends LazilyBoundStream<T>
+extends EventStreamBase<T>
 implements ConnectableEventStream<T>, ConnectableEventSink<T> {
 
     private MapHelper<EventStream<? extends T>, Subscription> subscriptions = null;
diff --git a/reactfx/src/main/java/org/reactfx/DistinctStream.java b/reactfx/src/main/java/org/reactfx/DistinctStream.java
index 7358386..61a27cc 100644
--- a/reactfx/src/main/java/org/reactfx/DistinctStream.java
+++ b/reactfx/src/main/java/org/reactfx/DistinctStream.java
@@ -3,7 +3,7 @@
 import java.util.Objects;
 
 
-class DistinctStream<T> extends LazilyBoundStream<T> {
+class DistinctStream<T> extends EventStreamBase<T> {
     static final Object NONE = new Object();
     private final EventStream<T> input;
     private Object previous = NONE;
diff --git a/reactfx/src/main/java/org/reactfx/EmitBothOnEachStream.java b/reactfx/src/main/java/org/reactfx/EmitBothOnEachStream.java
index 3b5d637..c500fe3 100644
--- a/reactfx/src/main/java/org/reactfx/EmitBothOnEachStream.java
+++ b/reactfx/src/main/java/org/reactfx/EmitBothOnEachStream.java
@@ -4,7 +4,7 @@
 
 import org.reactfx.util.Tuple2;
 
-class EmitBothOnEachStream<A, I> extends LazilyBoundStream<Tuple2<A, I>> {
+class EmitBothOnEachStream<A, I> extends EventStreamBase<Tuple2<A, I>> {
     private final EventStream<A> source;
     private final EventStream<I> impulse;
 
diff --git a/reactfx/src/main/java/org/reactfx/EmitOnEachStream.java b/reactfx/src/main/java/org/reactfx/EmitOnEachStream.java
index ce8f6fe..a74c9d8 100644
--- a/reactfx/src/main/java/org/reactfx/EmitOnEachStream.java
+++ b/reactfx/src/main/java/org/reactfx/EmitOnEachStream.java
@@ -1,7 +1,7 @@
 package org.reactfx;
 
 
-class EmitOnEachStream<T> extends LazilyBoundStream<T> {
+class EmitOnEachStream<T> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final EventStream<?> impulse;
 
diff --git a/reactfx/src/main/java/org/reactfx/EmitOnStream.java b/reactfx/src/main/java/org/reactfx/EmitOnStream.java
index 3daf369..e3a902a 100644
--- a/reactfx/src/main/java/org/reactfx/EmitOnStream.java
+++ b/reactfx/src/main/java/org/reactfx/EmitOnStream.java
@@ -1,7 +1,7 @@
 package org.reactfx;
 
 
-class EmitOnStream<T> extends LazilyBoundStream<T> {
+class EmitOnStream<T> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final EventStream<?> impulse;
 
diff --git a/reactfx/src/main/java/org/reactfx/EventSource.java b/reactfx/src/main/java/org/reactfx/EventSource.java
index 5bd68a5..b1996cf 100644
--- a/reactfx/src/main/java/org/reactfx/EventSource.java
+++ b/reactfx/src/main/java/org/reactfx/EventSource.java
@@ -17,4 +17,9 @@ public class EventSource<T>
     public final void push(T value) {
         emit(value);
     }
+
+    @Override
+    protected final Subscription subscribeToInputs() {
+        return Subscription.EMPTY;
+    }
 }
diff --git a/reactfx/src/main/java/org/reactfx/EventStream.java b/reactfx/src/main/java/org/reactfx/EventStream.java
index b2d0238..f9bbbb7 100644
--- a/reactfx/src/main/java/org/reactfx/EventStream.java
+++ b/reactfx/src/main/java/org/reactfx/EventStream.java
@@ -278,7 +278,7 @@ default <U> EventStream<U> flatMap(Function<? super T, ? extends EventStream<U>>
      */
     default <U> EventStream<Either<T, U>> or(EventStream<? extends U> right) {
         EventStream<T> left = this;
-        return new LazilyBoundStream<Either<T, U>>() {
+        return new EventStreamBase<Either<T, U>>() {
             @Override
             protected Subscription subscribeToInputs() {
                 return Subscription.multi(
@@ -1294,7 +1294,7 @@ default EventStream<T> guardedBy(Guardian... guardians) {
      * thrown by its subscribers.
      */
     default EventStream<Try<T>> materializeErrors() {
-        return new LazilyBoundStream<Try<T>>() {
+        return new EventStreamBase<Try<T>>() {
             @Override
             protected Subscription subscribeToInputs() {
                 return EventStream.this.subscribe(
@@ -1313,7 +1313,7 @@ protected Subscription subscribeToInputs() {
      * by its subscribers.
      */
     default EventStream<T> handleErrors(Consumer<? super Throwable> handler) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             @Override
             protected Subscription subscribeToInputs() {
                 return EventStream.this.subscribe(this::emit, handler);
@@ -1325,7 +1325,7 @@ protected Subscription subscribeToInputs() {
      * Returns a stream of errors reported by this event stream.
      */
     default EventStream<Throwable> errors() {
-        return new LazilyBoundStream<Throwable>() {
+        return new EventStreamBase<Throwable>() {
             @Override
             protected Subscription subscribeToInputs() {
                 return EventStream.this.monitor(this::emit);
diff --git a/reactfx/src/main/java/org/reactfx/EventStreamBase.java b/reactfx/src/main/java/org/reactfx/EventStreamBase.java
index 6470588..875d683 100644
--- a/reactfx/src/main/java/org/reactfx/EventStreamBase.java
+++ b/reactfx/src/main/java/org/reactfx/EventStreamBase.java
@@ -1,9 +1,13 @@
 package org.reactfx;
 
+import java.util.function.Consumer;
+
 
 /**
+ * Base class for event streams.
+ * Adds support for error propagation on top of {@link ObservableBase}.
  *
- * @param <T> type of events
+ * @param <T> type of events emitted by this event stream.
  */
 public abstract class EventStreamBase<T>
 extends ObservableBase<Subscriber<? super T>, T>
@@ -56,6 +60,19 @@ protected final void reportError(Throwable thrown) {
         }
     }
 
+    /**
+     * Subscribes to the given event stream by the given subscriber and also
+     * forwards errors reported by the given stream to this stream. This is
+     * equivalent to {@code stream.subscribe(subscriber, this::reportError)}.
+     * @return subscription used to unsubscribe {@code subscriber} from
+     * {@code stream} and stop forwarding the errors.
+     */
+    protected final <U> Subscription subscribeTo(
+            EventStream<U> stream,
+            Consumer<? super U> subscriber) {
+        return stream.subscribe(subscriber, this::reportError);
+    }
+
     @Override
     public final Subscription subscribe(Subscriber<? super T> subscriber) {
         return observe(subscriber);
diff --git a/reactfx/src/main/java/org/reactfx/EventStreams.java b/reactfx/src/main/java/org/reactfx/EventStreams.java
index 350816c..a3b0515 100644
--- a/reactfx/src/main/java/org/reactfx/EventStreams.java
+++ b/reactfx/src/main/java/org/reactfx/EventStreams.java
@@ -57,7 +57,7 @@ public static <T> EventStream<T> never() {
      * of the given observable.
      */
     public static EventStream<Void> invalidationsOf(Observable observable) {
-        return new LazilyBoundStream<Void>() {
+        return new EventStreamBase<Void>() {
             @Override
             protected Subscription subscribeToInputs() {
                 InvalidationListener listener = obs -> emit(null);
@@ -74,7 +74,7 @@ protected Subscription subscribeToInputs() {
      */
     public static <O extends Observable>
     EventStream<O> repeatOnInvalidation(O observable) {
-        return new LazilyBoundStream<O>() {
+        return new EventStreamBase<O>() {
             @Override
             protected Subscription subscribeToInputs() {
                 InvalidationListener listener = obs -> emit(observable);
@@ -95,7 +95,7 @@ protected void newObserver(Subscriber<? super O> subscriber) {
      * every change.
      */
     public static <T> EventStream<T> valuesOf(ObservableValue<T> observable) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             @Override
             protected Subscription subscribeToInputs() {
                 ChangeListener<T> listener = (obs, old, val) -> emit(val);
@@ -111,7 +111,7 @@ protected void newObserver(Subscriber<? super T> subscriber) {
     }
 
     public static <T> EventStream<T> nonNullValuesOf(ObservableValue<T> observable) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             @Override
             protected Subscription subscribeToInputs() {
                 ChangeListener<T> listener = (obs, old, val) -> {
@@ -134,7 +134,7 @@ protected void newObserver(Subscriber<? super T> subscriber) {
     }
 
     public static <T> EventStream<Change<T>> changesOf(ObservableValue<T> observable) {
-        return new LazilyBoundStream<Change<T>>() {
+        return new EventStreamBase<Change<T>>() {
             @Override
             protected Subscription subscribeToInputs() {
                 ChangeListener<T> listener = (obs, old, val) -> emit(new Change<>(old, val));
@@ -145,7 +145,7 @@ protected Subscription subscribeToInputs() {
     }
 
     public static <T> EventStream<ListChangeListener.Change<? extends T>> changesOf(ObservableList<T> list) {
-        return new LazilyBoundStream<ListChangeListener.Change<? extends T>>() {
+        return new EventStreamBase<ListChangeListener.Change<? extends T>>() {
             @Override
             protected Subscription subscribeToInputs() {
                 ListChangeListener<T> listener = c -> emit(c);
@@ -156,7 +156,7 @@ protected Subscription subscribeToInputs() {
     }
 
     public static <T> EventStream<TransientListChange<T>> simpleChangesOf(ObservableList<T> list) {
-        return new LazilyBoundStream<TransientListChange<T>>() {
+        return new EventStreamBase<TransientListChange<T>>() {
             @Override
             protected Subscription subscribeToInputs() {
                 ListChangeListener<T> listener = c ->  {
@@ -171,7 +171,7 @@ protected Subscription subscribeToInputs() {
     }
 
     public static <T> EventStream<SetChangeListener.Change<? extends T>> changesOf(ObservableSet<T> set) {
-        return new LazilyBoundStream<SetChangeListener.Change<? extends T>>() {
+        return new EventStreamBase<SetChangeListener.Change<? extends T>>() {
             @Override
             protected Subscription subscribeToInputs() {
                 SetChangeListener<T> listener = c -> emit(c);
@@ -182,7 +182,7 @@ protected Subscription subscribeToInputs() {
     }
 
     public static <K, V> EventStream<MapChangeListener.Change<? extends K, ? extends V>> changesOf(ObservableMap<K, V> map) {
-        return new LazilyBoundStream<MapChangeListener.Change<? extends K, ? extends V>>() {
+        return new EventStreamBase<MapChangeListener.Change<? extends K, ? extends V>>() {
             @Override
             protected Subscription subscribeToInputs() {
                 MapChangeListener<K, V> listener = c -> emit(c);
@@ -201,7 +201,7 @@ public static EventStream<Integer> sizeOf(ObservableMap<?, ?> map) {
     }
 
     private static <T> EventStream<T> create(Supplier<? extends T> computeValue, Observable... dependencies) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             private T previousValue;
 
             @Override
@@ -233,7 +233,7 @@ protected void newObserver(Subscriber<? super T> subscriber) {
     }
 
     public static <T extends Event> EventStream<T> eventsOf(Node node, EventType<T> eventType) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             @Override
             protected Subscription subscribeToInputs() {
                 EventHandler<T> handler = event -> emit(event);
@@ -244,7 +244,7 @@ protected Subscription subscribeToInputs() {
     }
 
     public static <T extends Event> EventStream<T> eventsOf(Scene scene, EventType<T> eventType) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             @Override
             protected Subscription subscribeToInputs() {
                 EventHandler<T> handler = event -> emit(event);
@@ -264,7 +264,7 @@ protected Subscription subscribeToInputs() {
      * returned stream.
      */
     public static EventStream<?> ticks(Duration interval) {
-        return new LazilyBoundStream<Void>() {
+        return new EventStreamBase<Void>() {
             private final Timer timer = FxTimer.createPeriodic(
                     interval, () -> emit(null));
 
@@ -293,7 +293,7 @@ public static EventStream<?> ticks(
             Duration interval,
             ScheduledExecutorService scheduler,
             Executor eventThreadExecutor) {
-        return new LazilyBoundStream<Void>() {
+        return new EventStreamBase<Void>() {
             private final Timer timer = ScheduledExecutorServiceTimer.createPeriodic(
                     interval, () -> emit(null), scheduler, eventThreadExecutor);
 
@@ -314,7 +314,7 @@ protected Subscription subscribeToInputs() {
      */
     @SafeVarargs
     public static <T> EventStream<T> merge(EventStream<? extends T>... inputs) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             @Override
             protected Subscription subscribeToInputs() {
                 return Subscription.multi(i -> subscribeTo(i, this::emit), inputs);
@@ -331,7 +331,7 @@ protected Subscription subscribeToInputs() {
      */
     public static <T> EventStream<T> merge(
             ObservableSet<? extends EventStream<T>> set) {
-        return new LazilyBoundStream<T>() {
+        return new EventStreamBase<T>() {
             @Override
             protected Subscription subscribeToInputs() {
                 return Subscription.dynamic(set, s -> subscribeTo(s, this::emit));
@@ -349,7 +349,7 @@ protected Subscription subscribeToInputs() {
     public static <T, U> EventStream<U> merge(
             ObservableSet<? extends T> set,
             Function<? super T, ? extends EventStream<U>> f) {
-        return new LazilyBoundStream<U>() {
+        return new EventStreamBase<U>() {
             @Override
             protected Subscription subscribeToInputs() {
                 return Subscription.dynamic(
@@ -360,7 +360,7 @@ protected Subscription subscribeToInputs() {
     }
 
     public static <A, B> EventStream<Tuple2<A, B>> zip(EventStream<A> srcA, EventStream<B> srcB) {
-        return new LazilyBoundStream<Tuple2<A, B>>() {
+        return new EventStreamBase<Tuple2<A, B>>() {
             Pocket<A> pocketA = new ExclusivePocket<>();
             Pocket<B> pocketB = new ExclusivePocket<>();
 
@@ -382,7 +382,7 @@ protected void tryEmit() {
     }
 
     public static <A, B, C> EventStream<Tuple3<A, B, C>> zip(EventStream<A> srcA, EventStream<B> srcB, EventStream<C> srcC) {
-        return new LazilyBoundStream<Tuple3<A, B, C>>() {
+        return new EventStreamBase<Tuple3<A, B, C>>() {
             Pocket<A> pocketA = new ExclusivePocket<>();
             Pocket<B> pocketB = new ExclusivePocket<>();
             Pocket<C> pocketC = new ExclusivePocket<>();
@@ -409,7 +409,7 @@ protected void tryEmit() {
     public static <A, B> EventStream<Tuple2<A, B>> combine(
             EventStream<A> srcA,
             EventStream<B> srcB) {
-        return new LazilyBoundStream<Tuple2<A, B>>() {
+        return new EventStreamBase<Tuple2<A, B>>() {
             Pocket<A> pocketA = new Pocket<>();
             Pocket<B> pocketB = new Pocket<>();
 
@@ -434,7 +434,7 @@ public static <A, B, C> EventStream<Tuple3<A, B, C>> combine(
             EventStream<A> srcA,
             EventStream<B> srcB,
             EventStream<C> srcC) {
-        return new LazilyBoundStream<Tuple3<A, B, C>>() {
+        return new EventStreamBase<Tuple3<A, B, C>>() {
             Pocket<A> pocketA = new Pocket<>();
             Pocket<B> pocketB = new Pocket<>();
             Pocket<C> pocketC = new Pocket<>();
@@ -463,7 +463,7 @@ public static <A, B, C, D> EventStream<Tuple4<A, B, C, D>> combine(
             EventStream<B> srcB,
             EventStream<C> srcC,
             EventStream<D> srcD) {
-        return new LazilyBoundStream<Tuple4<A, B, C, D>>() {
+        return new EventStreamBase<Tuple4<A, B, C, D>>() {
             Pocket<A> pocketA = new Pocket<>();
             Pocket<B> pocketB = new Pocket<>();
             Pocket<C> pocketC = new Pocket<>();
@@ -499,7 +499,7 @@ public static <A, B, C, D, E> EventStream<Tuple5<A, B, C, D, E>> combine(
             EventStream<C> srcC,
             EventStream<D> srcD,
             EventStream<E> srcE) {
-        return new LazilyBoundStream<Tuple5<A, B, C, D, E>>() {
+        return new EventStreamBase<Tuple5<A, B, C, D, E>>() {
             Pocket<A> pocketA = new Pocket<>();
             Pocket<B> pocketB = new Pocket<>();
             Pocket<C> pocketC = new Pocket<>();
@@ -540,7 +540,7 @@ public static <A, B, C, D, E, F> EventStream<Tuple6<A, B, C, D, E, F>> combine(
             EventStream<D> srcD,
             EventStream<E> srcE,
             EventStream<F> srcF) {
-        return new LazilyBoundStream<Tuple6<A, B, C, D, E, F>>() {
+        return new EventStreamBase<Tuple6<A, B, C, D, E, F>>() {
             Pocket<A> pocketA = new Pocket<>();
             Pocket<B> pocketB = new Pocket<>();
             Pocket<C> pocketC = new Pocket<>();
diff --git a/reactfx/src/main/java/org/reactfx/FilterMapStream.java b/reactfx/src/main/java/org/reactfx/FilterMapStream.java
index 90b4878..b01bbd8 100644
--- a/reactfx/src/main/java/org/reactfx/FilterMapStream.java
+++ b/reactfx/src/main/java/org/reactfx/FilterMapStream.java
@@ -3,7 +3,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
-class FilterMapStream<T, U> extends LazilyBoundStream<U> {
+class FilterMapStream<T, U> extends EventStreamBase<U> {
     private final EventStream<T> source;
     private final Predicate<? super T> predicate;
     private final Function<? super T, ? extends U> f;
diff --git a/reactfx/src/main/java/org/reactfx/FilterStream.java b/reactfx/src/main/java/org/reactfx/FilterStream.java
index e089191..86aeca1 100644
--- a/reactfx/src/main/java/org/reactfx/FilterStream.java
+++ b/reactfx/src/main/java/org/reactfx/FilterStream.java
@@ -2,7 +2,7 @@
 
 import java.util.function.Predicate;
 
-class FilterStream<T> extends LazilyBoundStream<T> {
+class FilterStream<T> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final Predicate<? super T> predicate;
 
diff --git a/reactfx/src/main/java/org/reactfx/FlatMapStream.java b/reactfx/src/main/java/org/reactfx/FlatMapStream.java
index 96f29c5..8d00bc6 100644
--- a/reactfx/src/main/java/org/reactfx/FlatMapStream.java
+++ b/reactfx/src/main/java/org/reactfx/FlatMapStream.java
@@ -3,7 +3,7 @@
 import java.util.Optional;
 import java.util.function.Function;
 
-class FlatMapStream<T, U> extends LazilyBoundStream<U> {
+class FlatMapStream<T, U> extends EventStreamBase<U> {
     private final EventStream<T> source;
     private final Function<? super T, ? extends EventStream<U>> mapper;
 
@@ -30,7 +30,7 @@ protected Subscription subscribeToInputs() {
     }
 }
 
-class FlatMapOptStream<T, U> extends LazilyBoundStream<U> {
+class FlatMapOptStream<T, U> extends EventStreamBase<U> {
     private final EventStream<T> source;
     private final Function<? super T, Optional<U>> mapper;
 
diff --git a/reactfx/src/main/java/org/reactfx/GuardedStream.java b/reactfx/src/main/java/org/reactfx/GuardedStream.java
index 2998285..82eb955 100644
--- a/reactfx/src/main/java/org/reactfx/GuardedStream.java
+++ b/reactfx/src/main/java/org/reactfx/GuardedStream.java
@@ -1,7 +1,7 @@
 package org.reactfx;
 
 
-class GuardedStream<T> extends LazilyBoundStream<T> {
+class GuardedStream<T> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final Guardian guardian;
 
diff --git a/reactfx/src/main/java/org/reactfx/LazilyBoundStream.java b/reactfx/src/main/java/org/reactfx/LazilyBoundStream.java
deleted file mode 100644
index f4668ce..0000000
--- a/reactfx/src/main/java/org/reactfx/LazilyBoundStream.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.reactfx;
-
-import java.util.function.Consumer;
-
-/**
- * Event stream that has one or more sources (most commonly event streams,
- * but not necessarily) to which it is subscribed only when it itself has
- * at least one subscriber.
- *
- * @param <T> type of events emitted by this event stream.
- */
-public abstract class LazilyBoundStream<T>
-extends EventStreamBase<T> {
-    private Subscription subscription = null;
-
-    public LazilyBoundStream() {
-        super();
-    }
-
-    LazilyBoundStream(EmptyPendingNotifications<Subscriber<? super T>, T> pn) {
-        super(pn);
-    }
-
-    protected abstract Subscription subscribeToInputs();
-
-    @Override
-    protected final void firstObserver() {
-        runUnsafeAction(() -> subscription = subscribeToInputs());
-    }
-
-    @Override
-    protected final void noObservers() {
-        runUnsafeAction(() -> {
-            subscription.unsubscribe();
-            subscription = null;
-        });
-    }
-
-    protected final boolean isBound() {
-        return subscription != null;
-    }
-
-    /**
-     * Subscribes to the given event stream by the given subscriber and also
-     * forwards errors reported by the given stream to this stream. This is
-     * equivalent to {@code stream.subscribe(subscriber, this::reportError)}.
-     * @return subscription used to unsubscribe {@code subscriber} from
-     * {@code stream} and stop forwarding the errors.
-     */
-    protected final <U> Subscription subscribeTo(
-            EventStream<U> stream,
-            Consumer<? super U> subscriber) {
-        return stream.subscribe(subscriber, this::reportError);
-    }
-}
\ No newline at end of file
diff --git a/reactfx/src/main/java/org/reactfx/MappedStream.java b/reactfx/src/main/java/org/reactfx/MappedStream.java
index f0b974d..a626a7a 100644
--- a/reactfx/src/main/java/org/reactfx/MappedStream.java
+++ b/reactfx/src/main/java/org/reactfx/MappedStream.java
@@ -5,7 +5,7 @@
 
 import javafx.concurrent.Task;
 
-class MappedStream<T, U> extends LazilyBoundStream<U> {
+class MappedStream<T, U> extends EventStreamBase<U> {
     private final EventStream<T> input;
     private final Function<? super T, ? extends U> f;
 
diff --git a/reactfx/src/main/java/org/reactfx/ObservableBase.java b/reactfx/src/main/java/org/reactfx/ObservableBase.java
index 01be95d..97ee5dc 100644
--- a/reactfx/src/main/java/org/reactfx/ObservableBase.java
+++ b/reactfx/src/main/java/org/reactfx/ObservableBase.java
@@ -6,12 +6,22 @@
 import org.reactfx.util.ListHelper;
 
 /**
+ * Base class for observable objects. This abstract class implements:
+ * <ol>
+ *   <li><b>Observer management:</b> adding and removing observers.</li>
+ *   <li><b>Lazy binding to inputs.</b> An observable has 0 or more inputs,
+ *   most commonly, but not necessarily, other observables. Lazy binding to
+ *   inputs means that the observable observes its inputs only when it is
+ *   itself being observed.</li>
+ *   <li><b>Observer notification.</b></li>
+ * </ol>
  *
  * @param <O> type of the observer
  * @param <T> type of observed values
  */
 abstract class ObservableBase<O, T> {
     private ListHelper<O> observers = null;
+    private Subscription subscription = null;
     private PendingNotifications<O, T> pendingNotifications;
 
     ObservableBase(EmptyPendingNotifications<O, T> pendingNotifications) {
@@ -22,9 +32,16 @@ public ObservableBase() {
         this(EmptyNonRecursivePN.empty());
     }
 
-    protected final int getObserverCount() {
-        return ListHelper.size(observers);
-    }
+    /**
+     * Starts observing this observable's input(s), if any.
+     * This method is called when the number of observers goes from 0 to 1.
+     * This method is called <em>before</em> {@link #newObserver(Object)}
+     * is called for the first observer.
+     * @return subscription used to stop observing inputs. The subscription
+     * is unsubscribed (i.e. input observation stops) when the number of
+     * observers goes down to 0.
+     */
+    protected abstract Subscription subscribeToInputs();
 
     /**
      * Runs the given action. If {@code action} does not throw an exception,
@@ -35,6 +52,14 @@ protected final int getObserverCount() {
      */
     protected abstract boolean runUnsafeAction(Runnable action);
 
+    protected final boolean isBound() {
+        return subscription != null;
+    }
+
+    protected final int getObserverCount() {
+        return ListHelper.size(observers);
+    }
+
     protected final void notifyObservers(BiConsumer<O, T> notifier, T event) {
         try {
             boolean added = runUnsafeAction(() -> {
@@ -65,44 +90,22 @@ protected final void forEachObserver(Consumer<O> action) {
         ListHelper.forEach(observers, o -> action.accept(o));
     }
 
-    /**
-     * Called when the number of observers goes from 0 to 1.
-     * Overriding this method is a convenient way for subclasses
-     * to handle this event.
-     *
-     * <p>This method is called <em>before</em> the
-     * {@link #newObserver(Object)} method.</p>
-     */
-    protected void firstObserver() {
-        // default implementation is empty
-    }
-
     /**
      * Called for each new observer.
      * Overriding this method is a convenient way for subclasses
      * to handle this event, for example to publish some initial events.
      *
      * <p>This method is called <em>after</em> the
-     * {@link #firstObserver()} method.</p>
+     * {@link #subscribeToInputs()} method.</p>
      */
     protected void newObserver(O observer) {
         // default implementation is empty
     }
 
-    /**
-     * Called when the number of observers goes down to 0.
-     * Overriding this method is a convenient way for subclasses
-     * to handle this event.
-     */
-    protected void noObservers() {
-        // default implementation is empty
-    }
-
     protected final Subscription observe(O observer) {
-
         observers = ListHelper.add(observers, observer);
         if(ListHelper.size(observers) == 1) {
-            firstObserver();
+            runUnsafeAction(() -> subscription = subscribeToInputs());
         }
         newObserver(observer);
 
@@ -111,8 +114,11 @@ protected final Subscription observe(O observer) {
 
     private void unobserve(O observer) {
         observers = ListHelper.remove(observers, observer);
-        if(ListHelper.isEmpty(observers)) {
-            noObservers();
+        if(ListHelper.isEmpty(observers) && subscription != null) {
+            runUnsafeAction(() -> {
+                subscription.unsubscribe();
+                subscription = null;
+            });
         }
     }
 }
diff --git a/reactfx/src/main/java/org/reactfx/RecursiveStream.java b/reactfx/src/main/java/org/reactfx/RecursiveStream.java
index 3442864..880565c 100644
--- a/reactfx/src/main/java/org/reactfx/RecursiveStream.java
+++ b/reactfx/src/main/java/org/reactfx/RecursiveStream.java
@@ -1,7 +1,7 @@
 package org.reactfx;
 
 
-class RecursiveStream<T> extends LazilyBoundStream<T> {
+class RecursiveStream<T> extends EventStreamBase<T> {
     private final EventStream<T> input;
 
     public RecursiveStream(
diff --git a/reactfx/src/main/java/org/reactfx/RepeatOnStream.java b/reactfx/src/main/java/org/reactfx/RepeatOnStream.java
index fb2ff58..342227f 100644
--- a/reactfx/src/main/java/org/reactfx/RepeatOnStream.java
+++ b/reactfx/src/main/java/org/reactfx/RepeatOnStream.java
@@ -1,7 +1,7 @@
 package org.reactfx;
 
 
-class RepeatOnStream<T> extends LazilyBoundStream<T> {
+class RepeatOnStream<T> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final EventStream<?> impulse;
 
diff --git a/reactfx/src/main/java/org/reactfx/SideEffectStream.java b/reactfx/src/main/java/org/reactfx/SideEffectStream.java
index 68b540c..60cda99 100644
--- a/reactfx/src/main/java/org/reactfx/SideEffectStream.java
+++ b/reactfx/src/main/java/org/reactfx/SideEffectStream.java
@@ -2,7 +2,7 @@
 
 import java.util.function.Consumer;
 
-class SideEffectStream<T> extends LazilyBoundStream<T> {
+class SideEffectStream<T> extends EventStreamBase<T> {
     private final EventStream<T> source;
     private final Consumer<? super T> sideEffect;
     private boolean sideEffectInProgress = false;
diff --git a/reactfx/src/main/java/org/reactfx/StateMachine.java b/reactfx/src/main/java/org/reactfx/StateMachine.java
index 49652e9..5d34a43 100644
--- a/reactfx/src/main/java/org/reactfx/StateMachine.java
+++ b/reactfx/src/main/java/org/reactfx/StateMachine.java
@@ -120,7 +120,7 @@ public Binding<S> toObservableState() {
     }
 }
 
-class StateStream<S> extends LazilyBoundStream<S> {
+class StateStream<S> extends EventStreamBase<S> {
     private final InputHandler[] inputHandlers;
 
     private S state;
@@ -173,7 +173,7 @@ public EventStream<O> toEventStream() {
     }
 }
 
-class StatefulStream<S, O> extends LazilyBoundStream<O> {
+class StatefulStream<S, O> extends EventStreamBase<O> {
     private final List<InputHandler> inputHandlers;
 
     private S state;
diff --git a/reactfx/src/main/java/org/reactfx/SuccessionReducingStream.java b/reactfx/src/main/java/org/reactfx/SuccessionReducingStream.java
index cd55688..b71b71c 100644
--- a/reactfx/src/main/java/org/reactfx/SuccessionReducingStream.java
+++ b/reactfx/src/main/java/org/reactfx/SuccessionReducingStream.java
@@ -8,7 +8,7 @@
 
 import org.reactfx.util.Timer;
 
-class SuccessionReducingStream<I, O> extends LazilyBoundStream<O> implements AwaitingEventStream<O> {
+class SuccessionReducingStream<I, O> extends EventStreamBase<O> implements AwaitingEventStream<O> {
     private final EventStream<I> input;
     private final Function<? super I, ? extends O> initial;
     private final BiFunction<? super O, ? super I, ? extends O> reduction;
diff --git a/reactfx/src/main/java/org/reactfx/SuspendWhenStream.java b/reactfx/src/main/java/org/reactfx/SuspendWhenStream.java
index a4a56ab..03e1cf1 100644
--- a/reactfx/src/main/java/org/reactfx/SuspendWhenStream.java
+++ b/reactfx/src/main/java/org/reactfx/SuspendWhenStream.java
@@ -2,7 +2,7 @@
 
 import javafx.beans.value.ObservableValue;
 
-class SuspendWhenStream<T> extends LazilyBoundStream<T> {
+class SuspendWhenStream<T> extends EventStreamBase<T> {
     private final SuspendableEventStream<T> source;
     private final ObservableValue<Boolean> condition;
 
diff --git a/reactfx/src/main/java/org/reactfx/SuspendableEventStream.java b/reactfx/src/main/java/org/reactfx/SuspendableEventStream.java
index 9808194..5eaf077 100644
--- a/reactfx/src/main/java/org/reactfx/SuspendableEventStream.java
+++ b/reactfx/src/main/java/org/reactfx/SuspendableEventStream.java
@@ -32,7 +32,7 @@ default EventStream<T> suspendWhen(ObservableValue<Boolean> condition) {
 }
 
 abstract class SuspendableEventStreamBase<T>
-extends LazilyBoundStream<T>
+extends EventStreamBase<T>
 implements SuspendableEventStream<T> {
 
     private final EventStream<T> source;
diff --git a/reactfx/src/main/java/org/reactfx/ThenAccumulateForStream.java b/reactfx/src/main/java/org/reactfx/ThenAccumulateForStream.java
index 6876ddf..276e16c 100644
--- a/reactfx/src/main/java/org/reactfx/ThenAccumulateForStream.java
+++ b/reactfx/src/main/java/org/reactfx/ThenAccumulateForStream.java
@@ -10,7 +10,7 @@
 
 import org.reactfx.util.Timer;
 
-class ThenAccumulateForStream<T, A> extends LazilyBoundStream<T> implements AwaitingEventStream<T> {
+class ThenAccumulateForStream<T, A> extends EventStreamBase<T> implements AwaitingEventStream<T> {
     private static enum State {
         READY, ACC_NO_EVENT, ACC_HAS_EVENT
     }
diff --git a/reactfx/src/main/java/org/reactfx/ThreadBridge.java b/reactfx/src/main/java/org/reactfx/ThreadBridge.java
index 69d00b1..1e6f46e 100644
--- a/reactfx/src/main/java/org/reactfx/ThreadBridge.java
+++ b/reactfx/src/main/java/org/reactfx/ThreadBridge.java
@@ -3,7 +3,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 
-class ThreadBridge<T> extends LazilyBoundStream<T> {
+class ThreadBridge<T> extends EventStreamBase<T> {
     private final EventStream<T> input;
     private final Executor sourceThreadExecutor;
     private final Executor targetThreadExecutor;