diff --git a/.eslintignore b/.eslintignore
new file mode 100644
index 0000000..22be1f9
--- /dev/null
+++ b/.eslintignore
@@ -0,0 +1,2 @@
+/coverage
+/dist
diff --git a/.eslintrc.js b/.eslintrc.js
index 25ad4d1..263f533 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -27,6 +27,7 @@ module.exports = {
     "@typescript-eslint/ban-ts-ignore": "off",
     "@typescript-eslint/no-this-alias": "off",
     "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/no-empty-function": "off"
+    "@typescript-eslint/no-empty-function": "off",
+    "@typescript-eslint/no-non-null-assertion": "error"
   }
 };
diff --git a/src/behavior.ts b/src/behavior.ts
index c566388..7153b96 100644
--- a/src/behavior.ts
+++ b/src/behavior.ts
@@ -1,16 +1,11 @@
-import { cons, DoubleLinkedList, Node, fromArray, nil } from "./datastructures";
-import { combine, isPlaceholder } from "./index";
-import { State, Reactive, Time, BListener, Parent, SListener } from "./common";
-import { Future, BehaviorFuture } from "./future";
+import { Cons, cons, DoubleLinkedList, fromArray, nil, Node } from "./datastructures";
+import { __UNSAFE_GET_LAST_BEHAVIOR_VALUE, combine, isPlaceholder } from "./index";
+import { BListener, Parent, Reactive, SListener, State, Time } from "./common";
 import * as F from "./future";
-import {
-  Stream,
-  FlatFuturesOrdered,
-  FlatFuturesLatest,
-  FlatFutures
-} from "./stream";
-import { tick, getTime } from "./clock";
-import { sample, Now } from "./now";
+import { BehaviorFuture, Future } from "./future";
+import { FlatFutures, FlatFuturesLatest, FlatFuturesOrdered, Stream } from "./stream";
+import { getTime, tick } from "./clock";
+import { Now, sample } from "./now";
 
 export type MapBehaviorTuple<A> = { [K in keyof A]: Behavior<A[K]> };
 
@@ -22,7 +17,7 @@ export type MapBehaviorTuple<A> = { [K in keyof A]: Behavior<A[K]> };
 export abstract class Behavior<A> extends Reactive<A, BListener>
   implements Parent<BListener> {
   // Behaviors cache their last value in `last`.
-  last: A;
+  last?: A;
   children: DoubleLinkedList<BListener> = new DoubleLinkedList();
   pulledAt: number | undefined;
   changedAt: number | undefined;
@@ -70,7 +65,7 @@ export abstract class Behavior<A> extends Reactive<A, BListener>
       const time = t === undefined ? tick() : t;
       this.pull(time);
     }
-    return this.last;
+    return __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this);
   }
   abstract update(t: number): A;
   pushB(t: number): void {
@@ -88,7 +83,11 @@ export abstract class Behavior<A> extends Reactive<A, BListener>
       for (const parent of this.parents) {
         if (isBehavior(parent)) {
           parent.pull(t);
-          shouldRefresh = shouldRefresh || this.changedAt < parent.changedAt;
+          shouldRefresh =
+            shouldRefresh ||
+            (this.changedAt !== undefined &&
+              parent.changedAt !== undefined &&
+              this.changedAt < parent.changedAt);
         }
       }
       if (shouldRefresh) {
@@ -122,7 +121,7 @@ export abstract class Behavior<A> extends Reactive<A, BListener>
   }
 }
 
-export function pushToChildren(t: number, b: Behavior<unknown>): void {
+export function pushToChildren<_>(t: number, b: Behavior<_>): void {
   for (const child of b.children) {
     child.pushB(t);
   }
@@ -139,7 +138,7 @@ function refresh<A>(b: Behavior<A>, t: number) {
 
 export function isBehavior<A>(b: unknown): b is Behavior<A> {
   return (
-    (typeof b === "object" && "at" in b && !isPlaceholder(b)) ||
+    (typeof b === "object" && b !== null && "at" in b && !isPlaceholder(b)) ||
     (isPlaceholder(b) && (b.source === undefined || isBehavior(b.source)))
   );
 }
@@ -184,14 +183,16 @@ class ProducerBehaviorFromFunction<A> extends ProducerBehavior<A> {
   ) {
     super();
   }
-  deactivateFn: () => void;
+  deactivateFn?: () => void;
   activateProducer(): void {
     this.state = State.Push;
     this.deactivateFn = this.activateFn(this.newValue.bind(this));
   }
   deactivateProducer(): void {
     this.state = State.Inactive;
-    this.deactivateFn();
+    if (this.deactivateFn !== undefined) {
+      this.deactivateFn();
+    }
   }
 }
 
@@ -243,17 +244,19 @@ export class MapBehavior<A, B> extends Behavior<B> {
     this.parents = cons(parent);
   }
   update(_t: number): B {
-    return this.f(this.parent.last);
+    return this.f(__UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.parent));
   }
 }
 
 class ApBehavior<A, B> extends Behavior<B> {
   constructor(private fn: Behavior<(a: A) => B>, private val: Behavior<A>) {
     super();
-    this.parents = cons<Behavior<((a: A) => B) | A>>(fn, cons(val));
+    this.parents = cons<Behavior<(a: A) => B> | Behavior<A>>(fn, cons(val));
   }
   update(_t: number): B {
-    return this.fn.last(this.val.last);
+    return __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.fn)(
+      __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.val)
+    );
   }
 }
 
@@ -295,19 +298,22 @@ export class LiftBehavior<A extends unknown[], R> extends Behavior<R> {
 
 class FlatMapBehavior<A, B> extends Behavior<B> {
   // The last behavior returned by the chain function
-  private innerB: Behavior<B>;
+  private innerB?: Behavior<B> | undefined;
   private innerNode: Node<this> = new Node(this);
   constructor(private outer: Behavior<A>, private fn: (a: A) => Behavior<B>) {
     super();
     this.parents = cons(this.outer);
   }
   update(t: number): B {
-    const outerChanged = this.outer.changedAt > this.changedAt;
+    const outerChanged =
+      this.outer.changedAt !== undefined &&
+      this.changedAt !== undefined &&
+      this.outer.changedAt > this.changedAt;
     if (outerChanged || this.changedAt === undefined) {
       if (this.innerB !== undefined) {
         this.innerB.removeListener(this.innerNode);
       }
-      this.innerB = this.fn(this.outer.last);
+      this.innerB = this.fn(__UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.outer));
       this.innerB.addListener(this.innerNode, t);
       if (this.state !== this.innerB.state) {
         this.changeStateDown(this.innerB.state);
@@ -317,28 +323,32 @@ class FlatMapBehavior<A, B> extends Behavior<B> {
         this.innerB.pull(t);
       }
     }
-    return this.innerB.last;
+    if (this.innerB === undefined) {
+      // panic!
+      throw new Error("FlatMapBehavior#innerB should be defined");
+    }
+    return __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.innerB);
   }
 }
 
 /** @private */
-class WhenBehavior extends Behavior<Future<{}>> {
+class WhenBehavior extends Behavior<Future<boolean>> {
   constructor(private parent: Behavior<boolean>) {
     super();
     this.parents = cons(parent);
   }
-  update(_t: number): Future<{}> {
+  update(_t: number): Future<boolean> {
     return this.parent.last === true
-      ? Future.of({})
+      ? Future.of<boolean>(true)
       : new BehaviorFuture(this.parent);
   }
 }
 
-export function whenFrom(b: Behavior<boolean>): Behavior<Future<{}>> {
+export function whenFrom(b: Behavior<boolean>): Behavior<Future<boolean>> {
   return new WhenBehavior(b);
 }
 
-export function when(b: Behavior<boolean>): Now<Future<{}>> {
+export function when(b: Behavior<boolean>): Now<Future<boolean>> {
   return sample(whenFrom(b));
 }
 
@@ -359,7 +369,7 @@ class SnapshotBehavior<A> extends Behavior<Future<A>> implements SListener<A> {
     }
   }
   pushS(t: number, _val: A): void {
-    this.last.resolve(this.parent.at(t), t);
+    __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this).resolve(this.parent.at(t), t);
     this.parents = cons(this.parent);
     this.changeStateDown(this.state);
     this.parent.addListener(this.node, t);
@@ -368,7 +378,7 @@ class SnapshotBehavior<A> extends Behavior<Future<A>> implements SListener<A> {
     if (this.future.state === State.Done) {
       return Future.of(this.parent.at(t));
     } else {
-      return this.last;
+      return __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this);
     }
   }
 }
@@ -440,7 +450,7 @@ class SwitcherBehavior<A> extends ActiveBehavior<A>
     next.addListener(this.nNode, t);
   }
   update(_t: Time): A {
-    return this.b.last;
+    return __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.b);
   }
   pushS(t: number, value: Behavior<A>): void {
     this.doSwitch(t, value);
@@ -486,7 +496,9 @@ export function switcherFrom<A>(
   init: Behavior<A>,
   stream: Stream<Behavior<A>>
 ): Behavior<Behavior<A>> {
-  return fromFunction((t) => new SwitcherBehavior(init, stream, t));
+  return fromFunction<Behavior<A>>(
+    (t) => new SwitcherBehavior(init, stream, t)
+  );
 }
 
 export function switcher<A>(
@@ -636,10 +648,10 @@ export function stepper<B>(initial: B, steps: Stream<B>): Now<Behavior<B>> {
  * @param turnOn the streams that turn the behavior on
  * @param turnOff the streams that turn the behavior off
  */
-export function toggleFrom(
+export function toggleFrom<A, B>(
   initial: boolean,
-  turnOn: Stream<unknown>,
-  turnOff: Stream<unknown>
+  turnOn: Stream<A>,
+  turnOff: Stream<B>
 ): Behavior<Behavior<boolean>> {
   return stepperFrom(initial, turnOn.mapTo(true).combine(turnOff.mapTo(false)));
 }
@@ -650,10 +662,10 @@ export function toggleFrom(
  * @param turnOn the streams that turn the behavior on
  * @param turnOff the streams that turn the behavior off
  */
-export function toggle(
+export function toggle<A, B>(
   initial: boolean,
-  turnOn: Stream<unknown>,
-  turnOff: Stream<unknown>
+  turnOn: Stream<A>,
+  turnOff: Stream<B>
 ): Now<Behavior<boolean>> {
   return sample(toggleFrom(initial, turnOn, turnOff));
 }
@@ -662,7 +674,7 @@ export type SampleAt = <B>(b: Behavior<B>) => B;
 
 class MomentBehavior<A> extends Behavior<A> {
   private sampleBound: SampleAt;
-  private currentSampleTime: Time;
+  private currentSampleTime?: Time;
   constructor(private f: (at: SampleAt) => A) {
     super();
     this.sampleBound = (b) => this.sample(b);
@@ -703,17 +715,18 @@ class MomentBehavior<A> extends Behavior<A> {
         parent.removeListener(node);
       }
     }
-    this.parents = undefined;
-    const value = this.f(this.sampleBound);
-    return value;
+    this.parents = nil;
+    return this.f(this.sampleBound);
   }
   sample<B>(b: Behavior<B>): B {
     const node = new Node(this);
     this.listenerNodes = cons({ node, parent: b }, this.listenerNodes);
-    b.addListener(node, this.currentSampleTime);
-    b.at(this.currentSampleTime);
+    if (this.currentSampleTime !== undefined) {
+      b.addListener(node, this.currentSampleTime);
+      b.at(this.currentSampleTime);
+    }
     this.parents = cons(b, this.parents);
-    return b.last;
+    return __UNSAFE_GET_LAST_BEHAVIOR_VALUE(b);
   }
 }
 
@@ -727,9 +740,9 @@ class FormatBehavior extends Behavior<string> {
     private behaviors: Array<string | number | Behavior<string | number>>
   ) {
     super();
-    let parents = undefined;
+    let parents: Cons<Behavior<string | number>> = nil;
     for (const b of behaviors) {
-      if (isBehavior(b)) {
+      if (isBehavior<string | number>(b)) {
         parents = cons(b, parents);
       }
     }
@@ -739,7 +752,9 @@ class FormatBehavior extends Behavior<string> {
     let resultString = this.strings[0];
     for (let i = 0; i < this.behaviors.length; ++i) {
       const b = this.behaviors[i];
-      const value = isBehavior(b) ? b.last : b;
+      const value = isBehavior<string | number>(b)
+        ? __UNSAFE_GET_LAST_BEHAVIOR_VALUE(b)
+        : b;
       resultString += value.toString() + this.strings[i + 1];
     }
     return resultString;
@@ -763,7 +778,8 @@ export function flatFutures<A>(stream: Stream<Future<A>>): Now<Stream<A>> {
 
 export const flatFuturesOrderedFrom = <A>(
   stream: Stream<Future<A>>
-): Behavior<Stream<A>> => fromFunction(() => new FlatFuturesOrdered(stream));
+): Behavior<Stream<A>> =>
+  fromFunction<Stream<A>>(() => new FlatFuturesOrdered(stream));
 
 export function flatFuturesOrdered<A>(
   stream: Stream<Future<A>>
@@ -773,7 +789,8 @@ export function flatFuturesOrdered<A>(
 
 export const flatFuturesLatestFrom = <A>(
   stream: Stream<Future<A>>
-): Behavior<Stream<A>> => fromFunction(() => new FlatFuturesLatest(stream));
+): Behavior<Stream<A>> =>
+  fromFunction<Stream<A>>(() => new FlatFuturesLatest(stream));
 
 export function flatFuturesLatest<A>(
   stream: Stream<Future<A>>
diff --git a/src/common.ts b/src/common.ts
index 072f087..c28a509 100644
--- a/src/common.ts
+++ b/src/common.ts
@@ -1,15 +1,28 @@
-import { Cons, cons, DoubleLinkedList, Node } from "./datastructures";
+import { Cons, cons, DoubleLinkedList, nil, Node } from "./datastructures";
 import { Behavior } from "./behavior";
 import { tick } from "./clock";
 
 export type Time = number;
 
 function isBehavior(b: unknown): b is Behavior<unknown> {
-  return typeof b === "object" && "at" in b;
+  return typeof b === "object" && b !== null && "at" in b;
 }
 
 export type PullHandler = (pull: (t?: number) => void) => () => void;
 
+/**
+ * @internal
+ * Do not use!
+ * @throws {Error}
+ */
+export const __UNSAFE_GET_LAST_BEHAVIOR_VALUE = <A>(b: Behavior<A>): A => {
+  if (b.last === undefined) {
+    // panic!
+    throw new Error("Behavior#last value should be defined");
+  }
+  return b.last;
+};
+
 /**
  * The various states that a reactive can be in. The order matters here: Done <
  * Push < Pull < Inactive. The idea is that a reactive can calculate its current
@@ -56,7 +69,7 @@ export class PushOnlyObserver<A> implements BListener, SListener<A> {
     }
   }
   pushB(_t: number): void {
-    this.callback((this.source as Behavior<A>).last);
+    this.callback(__UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.source as Behavior<A>));
   }
   pushS(_t: number, value: A): void {
     this.callback(value);
@@ -73,13 +86,10 @@ export type NodeParentPair = {
 };
 
 export abstract class Reactive<A, C extends Child> implements Child {
-  state: State;
-  parents: Cons<Parent<unknown>>;
+  state: State = State.Inactive;
+  parents: Cons<Parent<unknown>> = nil;
   listenerNodes: Cons<NodeParentPair> | undefined;
   children: DoubleLinkedList<C> = new DoubleLinkedList();
-  constructor() {
-    this.state = State.Inactive;
-  }
   addListener(node: Node<C>, t: number): State {
     const firstChild = this.children.head === undefined;
     this.children.prepend(node);
@@ -135,18 +145,22 @@ export abstract class Reactive<A, C extends Child> implements Child {
 }
 
 export class CbObserver<A> implements BListener, SListener<A> {
-  private endPulling: () => void;
+  private endPulling?: () => void;
   node: Node<CbObserver<A>> = new Node(this);
   constructor(
     private callback: (a: A) => void,
     readonly handlePulling: PullHandler,
-    private time: Time,
+    private time: Time | undefined,
     readonly source: ParentBehavior<A>
   ) {
     source.addListener(this.node, tick());
     if (source.state === State.Pull) {
       this.endPulling = handlePulling(this.pull.bind(this));
-    } else if (isBehavior(source) && source.state === State.Push) {
+    } else if (
+      isBehavior(source) &&
+      source.state === State.Push &&
+      source.last !== undefined
+    ) {
       callback(source.last);
     }
     this.time = undefined;
@@ -156,11 +170,13 @@ export class CbObserver<A> implements BListener, SListener<A> {
       time !== undefined ? time : this.time !== undefined ? this.time : tick();
     if (isBehavior(this.source) && this.source.state === State.Pull) {
       this.source.pull(t);
-      this.callback(this.source.last);
+      if (this.source.last !== undefined) {
+        this.callback(this.source.last);
+      }
     }
   }
   pushB(_t: number): void {
-    this.callback((this.source as Behavior<A>).last);
+    this.callback(__UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.source as Behavior<A>));
   }
   pushS(_t: number, value: A): void {
     this.callback(value);
diff --git a/src/datastructures.ts b/src/datastructures.ts
index 638cc47..068178e 100644
--- a/src/datastructures.ts
+++ b/src/datastructures.ts
@@ -1,25 +1,40 @@
-export class Cons<A> {
-  constructor(
-    public readonly value: A,
-    public readonly tail: Cons<A>,
-    public readonly isNil: boolean
-  ) {}
-  *[Symbol.iterator](): IterableIterator<A> {
-    let head: Cons<A> = this;
-    while (head.isNil === false) {
-      const v = head.value;
-      head = head.tail;
-      yield v;
-    }
-  }
+export interface ConsNil {
+  readonly isNil: true;
+  [Symbol.iterator](): Generator<never, void, undefined>;
 }
 
-export const nil: Cons<undefined> = new Cons(undefined, undefined, true);
+export interface ConsValue<A> {
+  readonly isNil: false;
+  readonly value: A;
+  readonly tail: Cons<A>;
+  [Symbol.iterator](): Generator<A, void, undefined>;
+}
+
+export type Cons<A> = ConsNil | ConsValue<A>;
 
-export function cons<A>(value: A, tail: Cons<A> = nil): Cons<A> {
-  return new Cons(value, tail, false);
+function* generator<A>(this: Cons<A>) {
+  let head: Cons<A> = this;
+  while (!head.isNil) {
+    const v = head.value;
+    head = head.tail;
+    yield v;
+  }
 }
 
+export const nil: Cons<never> = {
+  isNil: true,
+  [Symbol.iterator]: generator
+};
+
+export const cons = <A>(value: A, tail: Cons<A> = nil): Cons<A> => {
+  return {
+    isNil: false,
+    value,
+    tail,
+    [Symbol.iterator]: generator
+  };
+};
+
 export function fromArray<A>(values: A[]): Cons<A> {
   let list = cons(values[0]);
   for (let i = 1; i < values.length; ++i) {
diff --git a/src/dom.ts b/src/dom.ts
index eaaee37..9cae00b 100644
--- a/src/dom.ts
+++ b/src/dom.ts
@@ -12,7 +12,7 @@ class DomEventStream<A> extends ProducerStream<A> {
   constructor(
     private target: EventTarget,
     private eventName: string,
-    private extractor: Extractor<unknown, EventTarget, A>
+    private extractor: Extractor<Event, EventTarget, A>
   ) {
     super();
   }
@@ -66,8 +66,8 @@ export function streamFromEvent<A>(
 export function streamFromEvent<A>(
   target: EventTarget,
   eventName: string,
-  extractor: Extractor<A, EventTarget, A> = id
-): Stream<A> {
+  extractor: Extractor<Event, EventTarget, Event> = id
+): Stream<Event> {
   return new DomEventStream(target, eventName, extractor);
 }
 
diff --git a/src/future.ts b/src/future.ts
index ed5cfd1..3bafc1e 100644
--- a/src/future.ts
+++ b/src/future.ts
@@ -1,4 +1,11 @@
-import { State, SListener, Parent, BListener, Time } from "./common";
+import {
+  State,
+  SListener,
+  Parent,
+  BListener,
+  Time,
+  __UNSAFE_GET_LAST_BEHAVIOR_VALUE
+} from "./common";
 import { Reactive } from "./common";
 import { cons, fromArray, Node } from "./datastructures";
 import { Behavior, FunctionBehavior } from "./behavior";
@@ -8,6 +15,13 @@ import { sample, Now } from "./now";
 
 export type MapFutureTuple<A> = { [K in keyof A]: Future<A[K]> };
 
+const __UNSAFE_GET_LAST_FUTURE_VALUE = <A>(f: Future<A>): A => {
+  if (f.value === undefined) {
+    // panic!
+    throw new Error("Future#value should be defined");
+  }
+  return f.value;
+};
 /**
  * A future is a thing that occurs at some point in time with a value.
  * It can be understood as a pair consisting of the time the future
@@ -17,7 +31,7 @@ export type MapFutureTuple<A> = { [K in keyof A]: Future<A[K]> };
 export abstract class Future<A> extends Reactive<A, SListener<A>>
   implements Parent<SListener<unknown>> {
   // The value of the future. Often `undefined` until occurrence.
-  value: A;
+  value?: A;
   constructor() {
     super();
   }
@@ -37,7 +51,7 @@ export abstract class Future<A> extends Reactive<A, SListener<A>>
   }
   addListener(node: Node<SListener<A>>, t: number): State {
     if (this.state === State.Done) {
-      node.value.pushS(t, this.value);
+      node.value.pushS(t, __UNSAFE_GET_LAST_FUTURE_VALUE(this));
       return State.Done;
     } else {
       return super.addListener(node, t);
@@ -52,7 +66,7 @@ export abstract class Future<A> extends Reactive<A, SListener<A>>
     return new MapFuture(f, this);
   }
   mapTo<B>(b: B): Future<B> {
-    return new MapToFuture<B>(b, this);
+    return new MapToFuture(b, this);
   }
   // A future is an applicative. `of` gives a future that has always
   // occurred at all points in time.
@@ -62,7 +76,7 @@ export abstract class Future<A> extends Reactive<A, SListener<A>>
   of<B>(b: B): Future<B> {
     return new OfFuture(b);
   }
-  ap: <B>(f: Future<(a: A) => B>) => Future<B>;
+  // ap: <B>(f: Future<(a: A) => B>) => Future<B>;
   lift<A extends unknown[], R>(
     f: (...args: A) => R,
     ...args: MapFutureTuple<A>
@@ -88,7 +102,7 @@ export abstract class Future<A> extends Reactive<A, SListener<A>>
 }
 
 export function isFuture(a: unknown): a is Future<unknown> {
-  return typeof a === "object" && "resolve" in a;
+  return typeof a === "object" && a !== null && "resolve" in a;
 }
 
 export class CombineFuture<A> extends Future<A> {
@@ -111,8 +125,8 @@ export class MapFuture<A, B> extends Future<B> {
   }
 }
 
-export class MapToFuture<A> extends Future<A> {
-  constructor(public value: A, readonly parent: Future<unknown>) {
+export class MapToFuture<A, _> extends Future<A> {
+  constructor(public value: A, readonly parent: Future<_>) {
     super();
     this.parents = cons(parent);
   }
@@ -241,7 +255,7 @@ export class BehaviorFuture<A> extends SinkFuture<A> implements BListener {
   }
   pushB(t: number): void {
     this.b.removeListener(this.node);
-    this.resolve(this.b.last, t);
+    this.resolve(__UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.b), t);
   }
 }
 
@@ -256,7 +270,9 @@ export class NextOccurrenceFuture<A> extends Future<A> implements SListener<A> {
 }
 
 export function nextOccurrenceFrom<A>(stream: Stream<A>): Behavior<Future<A>> {
-  return new FunctionBehavior((t: Time) => new NextOccurrenceFuture(stream, t));
+  return new FunctionBehavior<Future<A>>(
+    (t: Time) => new NextOccurrenceFuture(stream, t)
+  );
 }
 
 export function nextOccurrence<A>(stream: Stream<A>): Now<Future<A>> {
diff --git a/src/now.ts b/src/now.ts
index cb47dba..d0fef81 100644
--- a/src/now.ts
+++ b/src/now.ts
@@ -137,7 +137,7 @@ export class PerformMapNow<A, B> extends Now<Stream<B> | Future<B>> {
     super();
   }
   run(): Stream<B> | Future<B> {
-    return isStream(this.s)
+    return isStream<A>(this.s)
       ? mapCbStream((value, done) => done(this.cb(value)), this.s)
       : mapCbFuture((value, done) => done(this.cb(value)), this.s);
   }
@@ -153,7 +153,7 @@ export function performMap<A, B>(
   s: Stream<A> | Future<A>
 ): Now<Stream<B> | Future<B>> {
   return perform(() =>
-    isStream(s)
+    isStream<A>(s)
       ? mapCbStream((value, done) => done(cb(value)), s)
       : mapCbFuture((value, done) => done(cb(value)), s)
   );
diff --git a/src/placeholder.ts b/src/placeholder.ts
index ecebcae..fc4fe59 100644
--- a/src/placeholder.ts
+++ b/src/placeholder.ts
@@ -1,20 +1,25 @@
-import { Reactive, State, SListener, BListener, Time } from "./common";
-import { Behavior, isBehavior, MapBehavior, pushToChildren } from "./behavior";
+import { Reactive, State, SListener, BListener, Time, __UNSAFE_GET_LAST_BEHAVIOR_VALUE } from "./common";
+import {
+  Behavior,
+  isBehavior,
+  MapBehavior,
+  pushToChildren
+} from "./behavior";
 import { Node, cons } from "./datastructures";
 import { Stream, MapToStream } from "./stream";
 import { tick } from "./clock";
 import { Future } from "./future";
 
-class SamplePlaceholderError {
+class SamplePlaceholderError<A> {
   message = "Attempt to sample non-replaced placeholder";
-  constructor(public placeholder: Placeholder<unknown>) {}
+  constructor(public placeholder: Placeholder<A>) {}
   toString(): string {
     return this.message;
   }
 }
 
 export class Placeholder<A> extends Behavior<A> {
-  source: Reactive<A, SListener<A> | BListener>;
+  source?: Reactive<A, SListener<A> | BListener>;
   private node: Node<this> = new Node(this);
   replaceWith(parent: Reactive<A, SListener<A> | BListener>, t?: Time): void {
     this.source = parent;
@@ -45,7 +50,7 @@ export class Placeholder<A> extends Behavior<A> {
     }
   }
   update(_t: number): A {
-    return (this.source as Behavior<A>).last;
+    return __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.source as Behavior<A>);
   }
   activate(t: number): void {
     if (this.source !== undefined) {
@@ -73,7 +78,7 @@ export class Placeholder<A> extends Behavior<A> {
 }
 
 export function isPlaceholder<A>(p: unknown): p is Placeholder<A> {
-  return typeof p === "object" && "replaceWith" in p;
+  return typeof p === "object" && p !== null && "replaceWith" in p;
 }
 
 class MapPlaceholder<A, B> extends MapBehavior<A, B> {
@@ -84,7 +89,7 @@ class MapPlaceholder<A, B> extends MapBehavior<A, B> {
 }
 
 class MapToPlaceholder<A, B> extends MapToStream<A, B> {
-  changedAt: Time;
+  changedAt?: Time;
   constructor(parent: Stream<A>, public last: B) {
     super(parent, last);
   }
diff --git a/src/stream.ts b/src/stream.ts
index 5bcaeaf..28d22b0 100644
--- a/src/stream.ts
+++ b/src/stream.ts
@@ -1,4 +1,12 @@
-import { Reactive, State, Time, SListener, Parent, BListener } from "./common";
+import {
+  Reactive,
+  State,
+  Time,
+  SListener,
+  Parent,
+  BListener,
+  __UNSAFE_GET_LAST_BEHAVIOR_VALUE
+} from "./common";
 import { cons, Node, DoubleLinkedList } from "./datastructures";
 import {
   Behavior,
@@ -19,11 +27,7 @@ import { Future } from ".";
  */
 export abstract class Stream<A> extends Reactive<A, SListener<A>>
   implements Parent<SListener<unknown>> {
-  constructor() {
-    super();
-  }
   children: DoubleLinkedList<SListener<A>> = new DoubleLinkedList();
-  state: State;
   combine<B>(stream: Stream<B>): Stream<A | B> {
     return new CombineStream(stream, this);
   }
@@ -40,7 +44,9 @@ export abstract class Stream<A> extends Reactive<A, SListener<A>>
     return scan(fn, startingValue, this);
   }
   scanFrom<B>(fn: (a: A, b: B) => B, startingValue: B): Behavior<Stream<B>> {
-    return fromFunction((t) => new ScanStream(fn, startingValue, this, t));
+    return fromFunction<Stream<B>>(
+      (t) => new ScanStream(fn, startingValue, this, t)
+    );
   }
   accum<B>(fn: (a: A, b: B) => B, init: B): Now<Behavior<B>> {
     return accum(fn, init, this);
@@ -201,23 +207,25 @@ export function scan<A, B>(
 class ShiftBehaviorStream<A> extends Stream<A> implements BListener {
   private bNode: Node<this> = new Node(this);
   private sNode: Node<this> = new Node(this);
-  private currentSource: Stream<A>;
+  private currentSource?: Stream<A>;
   constructor(private b: Behavior<Stream<A>>) {
     super();
   }
   activate(t: number): void {
     this.b.addListener(this.bNode, t);
     if (this.b.state !== State.Inactive) {
-      this.currentSource = this.b.last;
+      this.currentSource = __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.b);
       this.currentSource.addListener(this.sNode, t);
     }
   }
   deactivate(): void {
     this.b.removeListener(this.bNode);
-    this.currentSource.removeListener(this.sNode);
+    if (this.currentSource !== undefined) {
+      this.currentSource.removeListener(this.sNode);
+    }
   }
   pushB(t: number): void {
-    const newStream = this.b.last;
+    const newStream = __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.b);
     if (this.currentSource !== undefined) {
       this.currentSource.removeListener(this.sNode);
     }
@@ -254,7 +262,7 @@ export function shiftFrom<A>(s: Stream<Stream<A>>): Behavior<Stream<A>> {
 }
 
 class ChangesStream<A> extends Stream<A> implements BListener {
-  last: A;
+  last?: A;
   initialized: boolean;
   constructor(
     readonly parent: Behavior<A>,
@@ -269,17 +277,20 @@ class ChangesStream<A> extends Stream<A> implements BListener {
     // The parent may be an unreplaced placeholder and in that case
     // we can't read its current value.
     if (this.parent.state === State.Push) {
-      this.last = this.parent.last;
+      this.last = __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.parent);
       this.initialized = true;
     }
   }
   pushB(t: number): void {
     if (!this.initialized) {
       this.initialized = true;
-      this.last = this.parent.last;
-    } else if (!this.comparator(this.last, this.parent.last)) {
-      this.pushSToChildren(t, this.parent.last);
-      this.last = this.parent.last;
+      this.last = __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.parent);
+    } else {
+      const parentLast = __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.parent);
+      if (this.last !== undefined && !this.comparator(this.last, parentLast)) {
+        this.pushSToChildren(t, parentLast);
+        this.last = parentLast;
+      }
     }
   }
   pushS(_t: number, _a: A): void {}
@@ -300,7 +311,7 @@ export function changes<A>(
 export class CombineStream<A, B> extends Stream<A | B> {
   constructor(readonly s1: Stream<A>, readonly s2: Stream<B>) {
     super();
-    this.parents = cons<Stream<A | B>>(s1, cons(s2));
+    this.parents = cons<Stream<A> | Stream<B>>(s1, cons(s2));
   }
   pushS(t: number, a: A | B): void {
     this.pushSToChildren(t, a);
@@ -325,7 +336,7 @@ class ProducerStreamFromFunction<A> extends ProducerStream<A> {
   constructor(private activateFn: ProducerStreamFunction<A>) {
     super();
   }
-  deactivateFn: () => void;
+  deactivateFn?: () => void;
   publish(a: A, t: number = tick()): void {
     this.pushS(t, a);
   }
@@ -335,7 +346,9 @@ class ProducerStreamFromFunction<A> extends ProducerStream<A> {
   }
   deactivate(): void {
     this.state = State.Inactive;
-    this.deactivateFn();
+    if (this.deactivateFn !== undefined) {
+      this.deactivateFn();
+    }
   }
 }
 
@@ -376,9 +389,9 @@ export function subscribe<A>(fn: (a: A) => void, stream: Stream<A>): void {
   stream.subscribe(fn);
 }
 
-export class SnapshotStream<B> extends Stream<B> {
+export class SnapshotStream<B, _> extends Stream<B> {
   private node: Node<this> = new Node(this);
-  constructor(readonly target: Behavior<B>, readonly trigger: Stream<unknown>) {
+  constructor(readonly target: Behavior<B>, readonly trigger: Stream<_>) {
     super();
     this.parents = cons(trigger);
   }
@@ -394,9 +407,9 @@ export class SnapshotStream<B> extends Stream<B> {
   }
 }
 
-export function snapshot<B>(
+export function snapshot<B, _>(
   target: Behavior<B>,
-  trigger: Stream<unknown>
+  trigger: Stream<_>
 ): Stream<B> {
   return new SnapshotStream(target, trigger);
 }
@@ -447,8 +460,8 @@ export function selfie<A>(stream: Stream<Behavior<A>>): Stream<A> {
   return new SelfieStream(stream);
 }
 
-export function isStream(s: unknown): s is Stream<unknown> {
-  return typeof s === "object" && "scanFrom" in s;
+export function isStream<A>(s: unknown): s is Stream<A> {
+  return typeof s === "object" && s !== null && "scanFrom" in s;
 }
 
 class PerformCbStream<A, B> extends ActiveStream<B> implements SListener<A> {
@@ -509,11 +522,12 @@ export class FlatFuturesOrdered<A> extends Stream<A> {
     });
   }
   pushFromBuffer(): void {
-    while (this.buffer[0] !== undefined) {
+    let a = this.buffer.shift();
+    while (a !== undefined) {
       const t = tick();
-      const { value } = this.buffer.shift();
-      this.pushSToChildren(t, value);
+      this.pushSToChildren(t, a.value);
       this.next++;
+      a = this.buffer.shift();
     }
   }
 }
diff --git a/src/testing.ts b/src/testing.ts
index da9f477..31bdfa2 100644
--- a/src/testing.ts
+++ b/src/testing.ts
@@ -44,31 +44,42 @@ import {
   InstantRun
 } from "./now";
 import { time, DelayStream } from "./time";
+import { ConsValue } from "./datastructures";
 
 // Future
 
-export type Occurrence<A> = {
-  time: Time;
-  value: A;
-};
-
 declare module "./future" {
   interface Future<A> {
     model(): SemanticFuture<A>;
   }
 }
 
-export const neverOccurringFuture = {
-  time: "infinity" as "infinity",
-  value: undefined as undefined
+export interface Occurrence<A> {
+  tag: "Occurrence";
+  time: Time;
+  value: A;
+}
+
+export const occurrence = <A>(time: Time, value: A): Occurrence<A> => ({
+  tag: "Occurrence",
+  time,
+  value
+});
+
+export interface NeverOccurringFuture {
+  readonly tag: "NeverOccurringFuture";
+}
+
+export const neverOccurringFuture: NeverOccurringFuture = {
+  tag: "NeverOccurringFuture"
 };
 
-export type SemanticFuture<A> = Occurrence<A> | typeof neverOccurringFuture;
+export type SemanticFuture<A> = Occurrence<A> | NeverOccurringFuture;
 
 export function doesOccur<A>(
   future: SemanticFuture<A>
 ): future is Occurrence<A> {
-  return future.time !== "infinity";
+  return future.tag === "Occurrence";
 }
 
 CombineFuture.prototype.model = function() {
@@ -80,30 +91,31 @@ CombineFuture.prototype.model = function() {
 MapFuture.prototype.model = function() {
   const p = this.parent.model();
   return doesOccur(p)
-    ? { time: p.time, value: this.f(p.value) }
+    ? occurrence(p.time, this.f(p.value))
     : neverOccurringFuture;
 };
 
 MapToFuture.prototype.model = function() {
   const p = this.parent.model();
-  return doesOccur(p)
-    ? { time: p.time, value: this.value }
-    : neverOccurringFuture;
+  return doesOccur(p) ? occurrence(p.time, this.value) : neverOccurringFuture;
 };
 
 OfFuture.prototype.model = function() {
-  return { time: -Infinity, value: this.value };
+  return occurrence(-Infinity, this.value);
 };
 
 NeverFuture.prototype.model = function() {
   return neverOccurringFuture;
 };
 
+const allOccurred = <A>(fs: SemanticFuture<A>[]): fs is Occurrence<A>[] =>
+  fs.every((f) => f.tag === "Occurrence");
+
 LiftFuture.prototype.model = function() {
   const sems = (this.futures as Future<unknown>[]).map((f) => f.model());
   const time = Math.max(...sems.map((s) => (doesOccur(s) ? s.time : Infinity)));
-  return time !== Infinity
-    ? { time, value: this.f(...sems.map((s) => s.value)) }
+  return time !== Infinity && allOccurred(sems)
+    ? occurrence(time, this.f(...sems.map((s) => s.value)))
     : neverOccurringFuture;
 };
 
@@ -112,7 +124,7 @@ FlatMapFuture.prototype.model = function() {
   if (doesOccur(a)) {
     const b = this.f(a.value).model();
     if (doesOccur(b)) {
-      return { time: Math.max(a.time, b.time), value: b.value };
+      return occurrence(Math.max(a.time, b.time), b.value);
     }
   }
   return neverOccurringFuture;
@@ -143,7 +155,7 @@ class TestFuture<A> extends Future<A> {
 }
 
 export function testFuture<A>(time: number, value: A): Future<A> {
-  return new TestFuture({ time, value });
+  return new TestFuture(occurrence(time, value));
 }
 
 export function assertFutureEqual<A>(
@@ -167,12 +179,12 @@ declare module "./stream" {
 
 MapStream.prototype.model = function<A, B>(this: MapStream<A, B>) {
   const s = this.parent.model();
-  return s.map(({ time, value }) => ({ time, value: this.f(value) }));
+  return s.map(({ time, value }) => occurrence(time, this.f(value)));
 };
 
 MapToStream.prototype.model = function<A, B>(this: MapToStream<A, B>) {
-  const s = (this.parents.value as Stream<A>).model();
-  return s.map(({ time }) => ({ time, value: this.b }));
+  const s = (this.parents as ConsValue<Stream<A>>).value.model();
+  return s.map(({ time }) => occurrence(time, this.b));
 };
 
 FilterStream.prototype.model = function<A>(this: FilterStream<A>) {
@@ -189,7 +201,7 @@ ScanStream.prototype.model = function<A, B>(this: ScanStream<A, B>) {
     .filter((o) => this.t < o.time)
     .map(({ time, value }) => {
       acc = this.f(value, acc);
-      return { time, value: acc };
+      return occurrence(time, acc);
     });
 };
 
@@ -209,48 +221,51 @@ CombineStream.prototype.model = function<A, B>(this: CombineStream<A, B>) {
   return result;
 };
 
-SnapshotStream.prototype.model = function<B>(this: SnapshotStream<B>) {
+SnapshotStream.prototype.model = function<B, _>(this: SnapshotStream<B, _>) {
   return this.trigger
     .model()
-    .map(({ time }) => ({ time, value: testAt(time, this.target) }));
+    .map(({ time }) => occurrence(time, testAt(time, this.target)));
 };
 
 DelayStream.prototype.model = function<A>(this: DelayStream<A>) {
-  const s = (this.parents.value as Stream<A>).model();
-  return s.map(({ time, value }) => ({ time: time + this.ms, value }));
+  const s = (this.parents as ConsValue<Stream<A>>).value.model();
+  return s.map(({ time, value }) => occurrence(time + this.ms, value));
 };
 
-const flatFuture = <A>(o: Occurrence<Future<A>>) => {
-  const { time, value } = o.value.model();
-  return time === "infinity" ? [] : [{ time: Math.max(o.time, time), value }];
+const flatFuture = <A>(o: Occurrence<Future<A>>): Occurrence<A>[] => {
+  const f = o.value.model();
+  if (f.tag === "NeverOccurringFuture") {
+    return [];
+  } else {
+    return [occurrence(Math.max(o.time, f.time), f.value)];
+  }
 };
 
 FlatFutures.prototype.model = function<A>(this: FlatFutures<A>) {
-  return (this.parents.value as Stream<Future<A>>)
+  return (this.parents as ConsValue<Stream<Future<A>>>).value
     .model()
     .flatMap(flatFuture)
     .sort((o, p) => o.time - p.time); // FIXME: Should use stable sort here
 };
 
 FlatFuturesOrdered.prototype.model = function<A>(this: FlatFuturesOrdered<A>) {
-  return (this.parents.value as Stream<Future<A>>)
+  return (this.parents as ConsValue<Stream<Future<A>>>).value
     .model()
     .flatMap(flatFuture)
-    .reduce((acc, o) => {
-      const last = acc.length === 0 ? -Infinity : acc[acc.length - 1].time;
-      return acc.concat([{ time: Math.max(last, o.time), value: o.value }]);
+    .reduce<Occurrence<A>[]>((acc, o) => {
+      const last: Time =
+        acc.length === 0 ? -Infinity : acc[acc.length - 1].time;
+      return acc.concat([occurrence(Math.max(last, o.time), o.value)]);
     }, []);
 };
 
 FlatFuturesLatest.prototype.model = function<A>(this: FlatFuturesLatest<A>) {
-  return (this.parents.value as Stream<Future<A>>)
+  return (this.parents as ConsValue<Stream<Future<A>>>).value
     .model()
     .flatMap(flatFuture)
     .reduceRight<Occurrence<A>[]>((acc, o) => {
       const last = acc.length === 0 ? Infinity : acc[0].time;
-      return last < o.time
-        ? acc
-        : [{ time: o.time, value: o.value }].concat(acc);
+      return last < o.time ? acc : [occurrence(o.time, o.value)].concat(acc);
     }, []);
 };
 
@@ -276,31 +291,28 @@ class TestStream<A> extends Stream<A> {
 }
 
 export function testStreamFromArray<A>(array: ([Time, A])[]): Stream<A> {
-  const semanticStream = array.map(([t, value]) => ({ value, time: t }));
+  const semanticStream = array.map(([t, value]) => occurrence(t, value));
   return new TestStream(semanticStream);
 }
 
 export function testStreamFromObject<A>(object: Record<string, A>): Stream<A> {
-  const semanticStream = Object.keys(object).map((key) => ({
-    time: parseFloat(key),
-    value: object[key]
-  }));
+  const semanticStream = Object.keys(object).map((key) =>
+    occurrence(parseFloat(key), object[key])
+  );
   return new TestStream(semanticStream);
 }
 
 export function assertStreamEqual<A>(s1: Stream<A>, s2: Stream<A>): void;
 export function assertStreamEqual<A>(
   s1: Stream<A>,
-  s2: {
-    [time: number]: A;
-  }
+  s2: Record<number, A>
 ): void;
 export function assertStreamEqual<A>(s1: Stream<A>, s2: ([Time, A])[]): void;
 export function assertStreamEqual<A>(
   s1: Stream<A>,
-  s2: Stream<A> | ([Time, A])[]
+  s2: Stream<A> | ([Time, A])[] | Record<number, A>
 ): void {
-  const s2_ = isStream(s2)
+  const s2_ = isStream<A>(s2)
     ? s2
     : Array.isArray(s2)
     ? testStreamFromArray(s2)
diff --git a/src/time.ts b/src/time.ts
index ba32c18..3ddb84c 100644
--- a/src/time.ts
+++ b/src/time.ts
@@ -1,7 +1,10 @@
-import { Time, State } from "./common";
+import { Time, State, __UNSAFE_GET_LAST_BEHAVIOR_VALUE } from "./common";
 import { cons } from "./datastructures";
 import { Stream } from "./stream";
-import { Behavior, fromFunction } from "./behavior";
+import {
+  Behavior,
+  fromFunction
+} from "./behavior";
 import { sample, Now, perform } from "./now";
 
 /*
@@ -51,7 +54,9 @@ class DebounceStream<A> extends Stream<A> {
   }
   private timer: NodeJS.Timeout | undefined = undefined;
   pushS(t: number, a: A): void {
-    clearTimeout(this.timer);
+    if (this.timer !== undefined) {
+      clearTimeout(this.timer);
+    }
     this.timer = setTimeout(() => {
       this.pushSToChildren(t, a);
     }, this.ms);
@@ -81,19 +86,20 @@ export const measureTime = sample(measureTimeFrom);
 
 class IntegrateBehavior extends Behavior<number> {
   private lastPullTime: Time;
+  last = 0;
+  state = State.Pull;
   constructor(private parent: Behavior<number>, t: number) {
     super();
     this.lastPullTime = time.at(t);
-    this.state = State.Pull;
-    this.last = 0;
     this.pulledAt = t;
     this.changedAt = t;
     this.parents = cons(parent, cons(time));
   }
   update(_t: Time): number {
-    const currentPullTime = time.last;
+    const currentPullTime = __UNSAFE_GET_LAST_BEHAVIOR_VALUE(time);
     const deltaMs = currentPullTime - this.lastPullTime;
-    const value = this.last + deltaMs * this.parent.last;
+    const value =
+      this.last + deltaMs * __UNSAFE_GET_LAST_BEHAVIOR_VALUE(this.parent);
     this.lastPullTime = currentPullTime;
     return value;
   }
@@ -117,5 +123,5 @@ export function integrate(behavior: Behavior<number>): Now<Behavior<number>> {
 export function integrateFrom(
   behavior: Behavior<number>
 ): Behavior<Behavior<number>> {
-  return fromFunction((t) => new IntegrateBehavior(behavior, t));
+  return fromFunction<Behavior<number>>((t) => new IntegrateBehavior(behavior, t));
 }
diff --git a/test/behavior.ts b/test/behavior.ts
index 5bb2974..ee4c956 100644
--- a/test/behavior.ts
+++ b/test/behavior.ts
@@ -18,13 +18,22 @@ import {
   Stream,
   time,
   runNow,
-  Time
+  Time,
+  SinkBehavior
 } from "../src";
 
 import * as H from "../src";
 
 import { subscribeSpy } from "./helpers";
 import { placeholder } from "../src/placeholder";
+import { MonadDictionary } from "@funkia/jabz/dist/monad";
+
+declare module "@funkia/jabz" {
+  export function go<T, TReturn, TYield>(
+    gen: () => Generator<T, TReturn, TYield>,
+    monad?: MonadDictionary
+  ): any; // sorry
+}
 
 function double(n: number): number {
   return n * 2;
@@ -95,7 +104,7 @@ describe("behavior", () => {
     });
     it("can push and pull", () => {
       let variable = 0;
-      let push: (t: Time) => void;
+      let push: undefined | ((t: Time) => void);
       const setVar = (n: number) => {
         variable = n;
         if (push !== undefined) {
@@ -257,20 +266,22 @@ describe("behavior", () => {
         const numE = H.fromFunction(() => n);
         const applied = H.ap(fnB, numE);
         const cb = spy();
-        let pull: () => void;
+        let pull: (() => void) | undefined;
         applied.observe(cb, (pull_) => {
           pull = pull_;
           return () => {};
         });
-        pull();
-        push(add(2), fnB);
-        pull();
-        n = 4;
-        pull();
-        push(double, fnB);
-        pull();
-        n = 8;
-        pull();
+        if (pull !== undefined) {
+          pull();
+          push(add(2), fnB);
+          pull();
+          n = 4;
+          pull();
+          push(double, fnB);
+          pull();
+          n = 8;
+          pull();
+        }
         assert.deepEqual(cb.args, [[6], [3], [6], [8], [16]]);
       });
     });
@@ -389,13 +400,12 @@ describe("behavior", () => {
       const inner1 = sinkBehavior(1);
       const inner2 = sinkBehavior(3);
       const b = outer.flatMap((n) => {
-        if (n === 0) {
-          return Behavior.of(0);
-        } else if (n === 1) {
+        if (n === 1) {
           return inner1;
         } else if (n === 2) {
           return inner2;
         }
+        return Behavior.of(0);
       });
       b.observe(() => {}, () => () => {});
       assert.strictEqual(at(b), 0);
@@ -444,8 +454,12 @@ describe("behavior", () => {
     });
     it("works with go-notation", () => {
       const a = H.sinkBehavior(1);
-      const b = go(function*(): IterableIterator<any> {
-        const val: number = yield a;
+      const b: SinkBehavior<unknown> = go(function*(): Generator<
+        SinkBehavior<number>,
+        number,
+        number
+      > {
+        const val = yield a;
         return val * 2;
       });
       const cb = spy();
@@ -624,7 +638,7 @@ describe("Behavior and Future", () => {
   });
   describe("snapshotAt", () => {
     it("snapshots behavior at future occurring in future", () => {
-      let result: number;
+      let result: number | undefined = undefined;
       const bSink = sinkBehavior(1);
       const futureSink = H.sinkFuture();
       const mySnapshot = at(H.snapshotAt(bSink, futureSink));
@@ -636,7 +650,7 @@ describe("Behavior and Future", () => {
       assert.strictEqual(result, 3);
     });
     it("uses current value when future occurred in the past", () => {
-      let result: number;
+      let result: number | undefined = undefined;
       const bSink = sinkBehavior(1);
       const occurredFuture = H.Future.of({});
       bSink.push(2);
@@ -935,7 +949,7 @@ describe("Behavior and Stream", () => {
       const outer = sinkBehavior<Behavior<number>>(pushingB);
       const flattened = H.flat(outer);
       const pushSpy = spy();
-      let pull: () => void;
+      let pull: undefined | (() => void);
       const handlePulling = (p: () => void): (() => void) => {
         pull = p;
         return () => undefined;
@@ -943,11 +957,13 @@ describe("Behavior and Stream", () => {
       flattened.observe(pushSpy, handlePulling);
       outer.push(pullingB);
       variable = 1;
-      pull();
-      variable = 2;
-      pull();
-      variable = 3;
-      pull();
+      if (pull !== undefined) {
+        pull();
+        variable = 2;
+        pull();
+        variable = 3;
+        pull();
+      }
       assert.deepEqual(pushSpy.args, [[0], [1], [2], [3]]);
     });
   });
diff --git a/test/future.ts b/test/future.ts
index 2b1331c..ce9da82 100644
--- a/test/future.ts
+++ b/test/future.ts
@@ -30,7 +30,7 @@ describe("Future", () => {
   });
   describe("sink", () => {
     it("notifies subscriber", () => {
-      let result: number;
+      let result: number | undefined;
       const s = sinkFuture<number>();
       s.subscribe((x: number) => {
         result = x;
@@ -40,7 +40,7 @@ describe("Future", () => {
       assert.strictEqual(result, 2);
     });
     it("notifies subscriber several layers down", () => {
-      let result: number;
+      let result: number | undefined;
       const s = sinkFuture<number>();
       const s2 = s.map((n) => n + 2).mapTo(9);
       s2.subscribe((x: number) => {
@@ -61,7 +61,7 @@ describe("Future", () => {
   });
   describe("Semigroup", () => {
     it("returns the first future if it occurs first", () => {
-      let result: number;
+      let result: number | undefined;
       const future1 = sinkFuture<number>();
       const future2 = sinkFuture<number>();
       const combined = future1.combine(future2);
@@ -71,7 +71,7 @@ describe("Future", () => {
       assert.strictEqual(result, 1);
     });
     it("returns the seconds future if it occurs first", () => {
-      let result: number;
+      let result: number | undefined;
       const future1 = sinkFuture<number>();
       const future2 = sinkFuture<number>();
       const combined = future1.combine(future2);
@@ -81,8 +81,8 @@ describe("Future", () => {
       assert.strictEqual(result, 2);
     });
     it("returns when only one occurs", () => {
-      let result1: number;
-      let result2: number;
+      let result1: number | undefined;
+      let result2: number | undefined;
       const future1 = sinkFuture<number>();
       const future2 = sinkFuture<number>();
       const combined = future1.combine(future2);
@@ -106,7 +106,7 @@ describe("Future", () => {
   });
   describe("Functor", () => {
     it("maps over value", () => {
-      let result: number;
+      let result: number | undefined;
       const s = sinkFuture<number>();
       const mapped = s.map((x) => x * x);
       mapped.subscribe((x: number) => {
@@ -117,7 +117,7 @@ describe("Future", () => {
       assert.strictEqual(result, 16);
     });
     it("maps to constant", () => {
-      let result: string;
+      let result: string | undefined;
       const s = sinkFuture<number>();
       const mapped = s.mapTo("horse");
       mapped.subscribe((x: string) => {
@@ -130,7 +130,7 @@ describe("Future", () => {
   });
   describe("Apply", () => {
     it("lifts a function of one argument", () => {
-      let result: string;
+      let result: string | undefined;
       const fut = sinkFuture<string>();
       const lifted = H.lift((s: string) => s + "!", fut);
       lifted.subscribe((s: string) => (result = s));
@@ -139,7 +139,7 @@ describe("Future", () => {
       assert.strictEqual(result, "Hello!");
     });
     it("lifts a function of three arguments", () => {
-      let result: string;
+      let result: string | undefined;
       const fut1 = sinkFuture<string>();
       const fut2 = sinkFuture<string>();
       const fut3 = sinkFuture<string>();
@@ -163,7 +163,7 @@ describe("Future", () => {
   });
   describe("Applicative", () => {
     it("of gives future that has occurred", () => {
-      let result: number;
+      let result: number | undefined;
       const o = Future.of(12);
       o.subscribe((x) => (result = x));
       assert.strictEqual(result, 12);
@@ -203,19 +203,21 @@ describe("Future", () => {
     });
   });
   it("can convert Promise to Future", async () => {
-    let result: number;
-    let resolve: (n: number) => void;
+    let result: number | undefined;
+    let resolve: ((n: number) => void) | undefined;
     const promise = new Promise((res) => (resolve = res));
     const future = fromPromise(promise);
     future.subscribe((res: number) => (result = res));
     assert.strictEqual(result, undefined);
-    resolve(12);
+    if (resolve !== undefined) {
+      resolve(12);
+    }
     await promise;
     assert.strictEqual(result, 12);
   });
   describe("nextOccurence", () => {
     it("resolves on next occurence", () => {
-      let result: string;
+      let result: string | undefined;
       const s = new SinkStream<string>();
       const next = nextOccurrenceFrom(s);
       s.push("a");
@@ -230,8 +232,8 @@ describe("Future", () => {
     it("resolves with result when done callback invoked", () => {
       const fut = sinkFuture<number>();
       const cb = spy();
-      let value: number;
-      let done: (result: unknown) => void;
+      let value: number | undefined;
+      let done: ((result: unknown) => void) | undefined;
       const fut2 = mapCbFuture((v, d) => {
         value = v;
         done = d;
@@ -240,7 +242,9 @@ describe("Future", () => {
       fut.resolve(3);
       assert.equal(value, 3);
       assert.equal(cb.callCount, 0);
-      done(value + 1);
+      if (done !== undefined && value !== undefined) {
+        done(value + 1);
+      }
       assert.equal(cb.callCount, 1);
       assert.deepEqual(cb.args, [[4]]);
     });
diff --git a/test/now.ts b/test/now.ts
index 0b76c97..5f685bb 100644
--- a/test/now.ts
+++ b/test/now.ts
@@ -157,7 +157,9 @@ describe("Now", () => {
     function loop(n: number): Now<Behavior<number>> {
       return go(function*() {
         const nextNumber: Future<number> = yield performIO(getNextNr(1));
-        const future = yield plan(nextNumber.map(loop));
+        const future: Future<Behavior<number>> = yield plan(
+          nextNumber.map(loop)
+        );
         return switchTo(Behavior.of(n), future);
       });
     }
@@ -235,22 +237,24 @@ describe("Now", () => {
   describe("loopNow", () => {
     it("should loop the reactives", () => {
       const result: unknown[] = [];
-      let s: SinkStream<string>;
+      let s: SinkStream<string> | undefined;
       const now = loopNow(({ stream }) => {
         stream.subscribe((a) => result.push(a));
         s = sinkStream();
         return Now.of({ stream: s });
       });
       runNow(now);
-      s.push("a");
-      s.push("b");
-      s.push("c");
+      if (s !== undefined) {
+        s.push("a");
+        s.push("b");
+        s.push("c");
+      }
 
       assert.deepEqual(result, ["a", "b", "c"]);
     });
     it("should return the reactives", () => {
       const result: unknown[] = [];
-      let s: SinkStream<string>;
+      let s: SinkStream<string> | undefined;
       const now = loopNow(({ stream }) => {
         stream.subscribe((a) => a);
         s = sinkStream();
@@ -258,9 +262,11 @@ describe("Now", () => {
       });
       const { stream } = runNow(now);
       stream.subscribe((a) => result.push(a));
-      s.push("a");
-      s.push("b");
-      s.push("c");
+      if (s !== undefined) {
+        s.push("a");
+        s.push("b");
+        s.push("c");
+      }
       assert.deepEqual(result, ["a", "b", "c"]);
     });
   });
diff --git a/test/placeholder.ts b/test/placeholder.ts
index c1edd23..cb31972 100644
--- a/test/placeholder.ts
+++ b/test/placeholder.ts
@@ -24,7 +24,7 @@ import { createTestProducerBehavior } from "./helpers";
 describe("placeholder", () => {
   describe("behavior", () => {
     it("subscribers are notified when placeholder is replaced", () => {
-      let result: number;
+      let result: number | undefined;
       const p = placeholder<string>();
       const mapped = p.map((s) => s.length);
       mapped.subscribe((n: number) => (result = n));
@@ -32,7 +32,7 @@ describe("placeholder", () => {
       assert.strictEqual(result, 5);
     });
     it("subscribers are notified when placeholder is replaced 2", () => {
-      let result: string;
+      let result: string | undefined;
       const p = placeholder<string>();
       p.subscribe((s) => (result = s));
       p.replaceWith(Behavior.of("Hello"));
@@ -86,7 +86,7 @@ describe("placeholder", () => {
       const mapResult: unknown[] = [];
       const pm = p.map((n) => (mapResult.push(n), n));
       const result: Array<number> = [];
-      let pull: (t?: number) => void;
+      let pull: ((t?: number) => void) | undefined;
       observe(
         (a) => {
           result.push(a);
@@ -100,11 +100,13 @@ describe("placeholder", () => {
         pm
       );
       p.replaceWith(b);
-      pull();
-      variable = 1;
-      pull();
-      variable = 2;
-      pull();
+      if (pull !== undefined) {
+        pull();
+        variable = 1;
+        pull();
+        variable = 2;
+        pull();
+      }
       assert.deepEqual(result, [0, 1, 2], "result");
       assert.deepEqual(mapResult, [0, 1, 2], "mapResult");
     });
@@ -192,7 +194,7 @@ describe("placeholder", () => {
       const change = sum.map((_) => 1);
       const sum2 = H.at(H.switcherFrom(H.at(H.integrateFrom(change)), H.empty));
       const results: unknown[] = [];
-      let pull: () => void;
+      let pull: (() => void) | undefined;
       observe(
         (n: number) => results.push(n),
         (p) => {
@@ -202,11 +204,13 @@ describe("placeholder", () => {
         sum
       );
       sum.replaceWith(sum2);
-      pull();
-      setTime(4000);
-      pull();
-      setTime(7000);
-      pull();
+      if (pull !== undefined) {
+        pull();
+        setTime(4000);
+        pull();
+        setTime(7000);
+        pull();
+      }
       assert.deepEqual(results, [0, 2000, 5000]);
       restore();
     });
@@ -373,14 +377,14 @@ describe("placeholder", () => {
       assert.isTrue(H.isFuture(placeholder()));
     });
     it("subscribers are notified when replaced with occurred future", () => {
-      let result: string;
+      let result: string | undefined;
       const p = placeholder<string>();
       p.subscribe((n: string) => (result = n));
       p.replaceWith(H.Future.of("Hello"));
       assert.strictEqual(result, "Hello");
     });
     it("subscribers are notified when placeholder has been replaced", () => {
-      let result: string;
+      let result: string | undefined;
       const p = placeholder<string>();
       p.replaceWith(H.Future.of("Hello"));
       p.subscribe((n: string) => (result = n));
diff --git a/test/stream.ts b/test/stream.ts
index 196c24f..d0fe06f 100644
--- a/test/stream.ts
+++ b/test/stream.ts
@@ -89,7 +89,7 @@ describe("stream", () => {
     });
     it("pushes to listener", () => {
       const callback = spy();
-      let push: (t: number, n: number) => void;
+      let push: ((t: number, n: number) => void) | undefined;
       class MyProducer<A> extends H.ProducerStream<A> {
         activate(): void {
           push = this.pushS.bind(this);
@@ -100,8 +100,10 @@ describe("stream", () => {
       }
       const producer = new MyProducer();
       producer.subscribe(callback);
-      push(1, 1);
-      push(2, 2);
+      if (push !== undefined) {
+        push(1, 1);
+        push(2, 2);
+      }
       assert.deepEqual(callback.args, [[1], [2]]);
     });
   });
@@ -120,14 +122,16 @@ describe("stream", () => {
     });
     it("pushes to listener", () => {
       const callback = spy();
-      let push: (n: number) => void;
+      let push: ((n: number) => void) | undefined;
       const producer = H.producerStream((p) => {
         push = p;
         return () => (push = undefined);
       });
       producer.subscribe(callback);
-      push(1);
-      push(2);
+      if (push !== undefined) {
+        push(1);
+        push(2);
+      }
       assert.deepEqual(callback.args, [[1], [2]]);
     });
   });
diff --git a/test/testing.ts b/test/testing.ts
index e72f7aa..8ef2023 100644
--- a/test/testing.ts
+++ b/test/testing.ts
@@ -10,11 +10,42 @@ import {
   assertStreamEqual,
   testBehavior,
   testNow,
-  assertBehaviorEqual
+  assertBehaviorEqual,
+  neverOccurringFuture,
+  occurrence
 } from "../src/testing";
 import { createRef, mutateRef } from "./helpers";
 import { fgo } from "@funkia/jabz";
 import { withEffects } from "@funkia/io";
+import { MonadDictionary } from "@funkia/jabz/dist/monad";
+import { F1, F2, F3, F4, F5 } from "@funkia/jabz/dist/utils";
+
+declare module "@funkia/jabz" {
+  export function fgo<A, T, TReturn, TYield>(
+    gen: (a: A) => Generator<T, TReturn, TYield>,
+    monad?: MonadDictionary
+  ): F1<A, any>;
+  export function fgo<A, B, T, TReturn, TYield>(
+    gen: (a: A, b: B) => Generator<T, TReturn, TYield>,
+    monad?: MonadDictionary
+  ): F2<A, B, any>;
+  export function fgo<A, B, C, T, TReturn, TYield>(
+    gen: (a: A, b: B, c: C) => Generator<T, TReturn, TYield>,
+    monad?: MonadDictionary
+  ): F3<A, B, C, any>;
+  export function fgo<A, B, C, D, T, TReturn, TYield>(
+    gen: (a: A, b: B, c: C, d: D) => Generator<T, TReturn, TYield>,
+    monad?: MonadDictionary
+  ): F4<A, B, C, D, any>;
+  export function fgo<A, B, C, D, E, T, TReturn, TYield>(
+    gen: (a: A, b: B, c: C, d: D, e: E) => Generator<T, TReturn, TYield>,
+    monad?: MonadDictionary
+  ): F5<A, B, C, D, E, any>;
+  export function fgo(
+    gen: (...a: any[]) => Generator<any, any, any>,
+    monad?: MonadDictionary
+  ): any;
+}
 
 describe("testing", () => {
   describe("future", () => {
@@ -59,7 +90,7 @@ describe("testing", () => {
     });
     describe("never", () => {
       it("never occurs", () => {
-        assert.strictEqual(H.never.model().time, "infinity");
+        assert.strictEqual(H.never.model(), neverOccurringFuture);
       });
     });
     describe("lift", () => {
@@ -110,10 +141,10 @@ describe("testing", () => {
       it("creates test stream with increasing times from array", () => {
         const s = testStreamFromArray([[0, 0], [1, 1], [2, 2], [3, 3]]);
         assert.deepEqual(s.model(), [
-          { value: 0, time: 0 },
-          { value: 1, time: 1 },
-          { value: 2, time: 2 },
-          { value: 3, time: 3 }
+          occurrence(0, 0),
+          occurrence(1, 1),
+          occurrence(2, 2),
+          occurrence(3, 3)
         ]);
       });
       it("creates test stream from object", () => {
@@ -123,9 +154,9 @@ describe("testing", () => {
           5.5: "three"
         });
         assert.deepEqual(s.model(), [
-          { value: "one", time: 2 },
-          { value: "two", time: 4 },
-          { value: "three", time: 5.5 }
+          occurrence(2, "one"),
+          occurrence(4, "two"),
+          occurrence(5.5, "three")
         ]);
       });
     });
@@ -156,11 +187,11 @@ describe("testing", () => {
         const s2 = testStreamFromObject({ 1: "#2", 2: "#4", 3: "#5" });
         const combined = s2.combine(s1);
         assert.deepEqual(combined.model(), [
-          { time: 0, value: "#1" },
-          { time: 1, value: "#2" },
-          { time: 2, value: "#3" },
-          { time: 2, value: "#4" },
-          { time: 3, value: "#5" }
+          occurrence(0, "#1"),
+          occurrence(1, "#2"),
+          occurrence(2, "#3"),
+          occurrence(2, "#4"),
+          occurrence(3, "#5")
         ]);
       });
     });
@@ -344,7 +375,7 @@ describe("testing", () => {
         const ref1 = createRef(1);
         const comp = H.performIO(mutateRef(2, ref1));
         const result = testNow(comp, [testFuture(0, "foo")]);
-        assert(result.model().value, "foo");
+        assert.deepStrictEqual(result.model(), occurrence(0, "foo"));
       });
     });
     describe("sample", () => {
@@ -370,6 +401,9 @@ describe("testing", () => {
     describe("performStream", () => {
       it("can be tested", () => {
         const requests: number[] = [];
+        interface Foo {
+          readonly click: Stream<unknown>;
+        }
         const model = fgo(function*({ click }) {
           const request = click.mapTo(
             withEffects((n: number) => {
diff --git a/test/time.ts b/test/time.ts
index 44a41e2..1bf04f6 100644
--- a/test/time.ts
+++ b/test/time.ts
@@ -77,7 +77,7 @@ describe("behavior", () => {
         const [setTime, restore] = mockNow();
         setTime(3);
         const time = H.runNow(H.measureTime);
-        let pull: (t?: number) => void;
+        let pull: ((t?: number) => void) | undefined;
         const results: number[] = [];
         H.observe(
           (n: number) => {
@@ -89,11 +89,13 @@ describe("behavior", () => {
           },
           time
         );
-        pull();
-        setTime(4);
-        pull();
-        setTime(7);
-        pull();
+        if (pull !== undefined) {
+          pull();
+          setTime(4);
+          pull();
+          setTime(7);
+          pull();
+        }
         assert.deepEqual(results, [0, 1, 4]);
         restore();
       });
diff --git a/tsconfig.json b/tsconfig.json
index 5b71b67..4a58655 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -7,7 +7,11 @@
     "importHelpers": true,
     "sourceMap": true,
     "skipLibCheck": true,
-    "lib": ["dom", "es5", "es2015", "es2019"]
+    "lib": ["dom", "es5", "es2015", "es2019"],
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true
   },
   "include": ["src/**/*", "test/**/*"],
   "exclude": ["node_modules"]