From 1b44ddae31112caddb8f9eef88874ecdf80a279d Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Mon, 27 Jul 2015 14:44:07 +0200
Subject: [PATCH] Dissolve using Generators.

---
 example-complex.js | 103 ++++---
 example-loop.js    |  35 ++-
 example.js         |  44 ++-
 index.js           | 310 +++++--------------
 test/integer.js    | 728 ++++++++++++++++++++++++++-------------------
 test/loop.js       |  83 ++----
 test/tap.js        |  63 ----
 7 files changed, 625 insertions(+), 741 deletions(-)
 delete mode 100644 test/tap.js

diff --git a/example-complex.js b/example-complex.js
index 17847d6..df78378 100755
--- a/example-complex.js
+++ b/example-complex.js
@@ -1,58 +1,83 @@
 #!/usr/bin/env node
+"use strict";
 
 var Dissolve = require("./index"),
     util = require("util");
 
-function Parser() {
-  Dissolve.call(this);
-
-  this.loop(function(end) {
-    this.uint8("pid").tap(function() {
-      switch (this.vars.pid) {
-        case 0x00: this.uint32be("token"); break;
-        case 0x01: this.uint32be("eid").mcstring16("level_type").uint8("game_mode").uint8("dimension").uint8("difficulty").uint8("junk").uint8("max_players"); break;
-        case 0x02: this.uint8("protocol_version").mcstring16("username").mcstring16("server_host").uint32be("server_port"); break;
-        case 0x03: this.mcstring16("message"); break;
-        case 0x04: this.uint64be("time"); break;
-        case 0xfe: break;
-      }
-    }).tap(function() {
-      this.push(this.vars);
-      this.vars = {};
-    });
-  });
-}
-util.inherits(Parser, Dissolve);
+class Parser extends Dissolve {
+  *parser() {
+    var data;
+    while (true) {
+      data = {
+        pid: yield this.uint8()
+      };
+
+      switch (data.pid) {
+        case 0x00:
+          data.token = yield this.uint32be();
+        break;
+
+        case 0x01:
+          data.eid = yield this.uint32be();
+          data.level_type = yield *this.mcstring16();
+          data.game_mode = yield this.uint8();
+          data.dimension = yield this.uint8();
+          data.difficulty = yield this.uint8();
+          data.junk = yield this.uint8();
+          data.max_players = yield this.uint8();
+        break;
 
-Parser.prototype.mcstring16 = function string16(name) {
-  var len = [name, "len"].join("_");
+        case 0x02:
+          data.protocol_version = yield this.uint8();
+          data.username = yield *this.mcstring16();
+          data.server_host = yield *this.mcstring16();
+          data.server_port = yield this.uint32be();
+        break;
 
-  return this.uint16be(len).tap(function() {
-    this.buffer(name, this.vars[len] * 2).tap(function() {
-      delete this.vars[len];
+        case 0x03:
+          data.message = yield *this.mcstring16();
+        break;
 
-      for (var i=0;i<this.vars[name].length/2;++i) {
-        var t = this.vars[name][i*2];
-        this.vars[name][i*2] = this.vars[name][i*2+1];
-        this.vars[name][i*2+1] = t;
+        case 0x04:
+          data.time = yield this.uint64be();
+        break;
+
+        case 0xfe:
+        break;
       }
 
-      this.vars[name] = this.vars[name].toString("ucs2");
-    });
-  });
-};
+      this.push(data);
+    }
+  }
+
+  *mcstring16() {
+    var length = yield this.uint16be();
+
+    var data = yield this.buffer(length * 2);
+
+    for (var i = 0; i < (data.length / 2); ++i) {
+      var t = data[i*2];
+      data[i*2] = data[i*2+1];
+      data[i*2+1] = t;
+    }
+
+    return data;
+  }
+}
 
 var parser = new Parser();
 
 parser.on("readable", function() {
   var e;
   while (e = parser.read()) {
-    console.log(e);
+    //console.log(e);
   }
 });
 
-parser.write(new Buffer([0x00, 0x00, 0x00, 0x00, 0x01]));
-parser.write(new Buffer([0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x61, 0x00, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00]));
-parser.write(new Buffer([0x02, 0x01, 0x00, 0x02, 0x00, 0x61, 0x00, 0x62, 0x00, 0x02, 0x00, 0x63, 0x00, 0x64, 0x00, 0x00, 0x00, 0x05]));
-parser.write(new Buffer([0x03, 0x00, 0x02, 0x00, 0x65, 0x00, 0x66]));
-parser.write(new Buffer([0x04, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01]));
+for (var i = 0; i < 50000; i++) {
+  parser.write(new Buffer([0x00, 0x00, 0x00, 0x00, 0x01]));
+  parser.write(new Buffer([0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x61, 0x00, 0x62, 0x00, 0x00, 0x00, 0x00, 0x00]));
+  parser.write(new Buffer([0x02, 0x01, 0x00, 0x02, 0x00, 0x61, 0x00, 0x62, 0x00, 0x02, 0x00, 0x63, 0x00, 0x64, 0x00, 0x00, 0x00, 0x05]));
+  parser.write(new Buffer([0x03, 0x00, 0x02, 0x00, 0x65, 0x00, 0x66]));
+  parser.write(new Buffer([0x04, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01]));
+}
diff --git a/example-loop.js b/example-loop.js
index b77b39d..53be4ad 100755
--- a/example-loop.js
+++ b/example-loop.js
@@ -2,28 +2,31 @@
 
 var Dissolve = require("./index");
 
-var parser = Dissolve().tap(function() {
-  var data_i = 0;
+var parser = Dissolve()
+parser.parser = function*() {
+  var data_count;
+  var data, elements, i, j;
 
-  this.uint8("data_count").loop("data", function(end) {
-    if (data_i++ === this.vars.data_count) {
-      return end(true);
-    }
+  while (true) {
+    data = [];
+    data_count = yield this.uint8();
 
-    var elements_i = 0;
+    for (i = 0; i < data_count; i++) {
+      elements = []
+      element_count = yield this.uint8();
 
-    this.uint8("element_count").loop("elements", function(end) {
-      if (elements_i++ === this.vars.element_count) {
-        return end(true);
+      for (j = 0; j < element_count; j++) {
+        elements.push({ element: yield this.uint8() });
       }
 
-      this.uint8("element");
+      data.push({ elements: elements });
+    }
+
+    this.push({
+      data: data
     });
-  }).tap(function() {
-    this.push(this.vars);
-    this.vars = Object.create(null);
-  });
-});
+  }
+};
 
 parser.on("readable", function() {
   var e;
diff --git a/example.js b/example.js
index 63e71f9..efbaf4e 100755
--- a/example.js
+++ b/example.js
@@ -2,22 +2,38 @@
 
 var Dissolve = require("./index");
 
-var parser = Dissolve().loop(function(end) {
-  this.uint8("id").tap("payload", function() {
-    this.tap("asdf", function() {
-      if (this.vars.id === 0x01) {
-        this.uint16be("a").uint16be("b");
-      } else if (this.vars.id === 0x02) {
-        this.uint32be("x").uint32be("y");
-      } else if (this.vars.id === 0x03) {
-        this.floatbe("l").doublebe("m");
+var parser = new Dissolve();
+parser.parser = function*() {
+  var id, payload;
+
+  while (true) {
+    id = yield this.uint8();
+
+    if (id === 0x01) {
+      payload = {
+        "a": yield this.uint16be(),
+        "b": yield this.uint16be()
+      };
+    } else if (id === 0x02) {
+      payload = {
+        "x": yield this.uint32be(),
+        "y": yield this.uint32be()
+      };
+    } else if (id === 0x03) {
+      payload = {
+        "l": yield this.floatbe(),
+        "m": yield this.doublebe()
+      };
+    }
+
+    this.push({
+      id: id,
+      payload: {
+        asdf: payload
       }
     });
-  }).tap(function() {
-    this.push(this.vars);
-    this.vars = Object.create(null);
-  });
-});
+  }
+};
 
 parser.on("readable", function() {
   var e;
diff --git a/index.js b/index.js
index 04ba4d1..e970bcc 100644
--- a/index.js
+++ b/index.js
@@ -1,120 +1,28 @@
-var BufferList = require("bl"),
-    stream = require("readable-stream");
+"use strict";
 
-var Dissolve = module.exports = function Dissolve(options) {
+var BufferList = require("bl");
+var stream = require("readable-stream");
+var util = require("util");
+
+function Dissolve(options) {
   if (!(this instanceof Dissolve)) { return new Dissolve(options); }
 
-  if (!options) {
-    options = {};
-  }
+  options = options || {};
 
-  if (!options.hasOwnProperty('objectMode')) {
+  if (options.objectMode === undefined) {
     options.objectMode = true;
   }
 
   stream.Transform.call(this, options);
 
-  this.jobs = [];
-  this.vars = Object.create(null);
-  this.vars_list = [];
-
   this._buffer = new BufferList();
-};
-Dissolve.prototype = Object.create(stream.Transform.prototype, {constructor: {value: Dissolve}});
+}
 
-Dissolve.prototype._job_down = function _job_down(job) {
-  var tmp = this.vars;
-  this.vars_list.push(tmp);
-  this.vars = tmp[job.into] = Object.create(tmp);
-};
+module.exports = Dissolve;
+util.inherits(Dissolve, stream.Transform);
 
-Dissolve.prototype._job_up = function _job_up() {
-  this.vars.__proto__ = null;
-  this.vars = this.vars_list.pop();
-};
-
-Dissolve.prototype._exec_down = function _exec_down(job) {
-  this.jobs.shift();
-  this._job_down(job);
-};
-
-Dissolve.prototype._exec_up = function _exec_up(job) {
-  this.jobs.shift();
-  this._job_up();
-};
-
-Dissolve.prototype._exec_tap = function _exec_tap(job) {
-  this.jobs.shift();
-
-  var jobs = this.jobs;
-
-  this.jobs = [];
-
-  if (job.name) {
-    this.jobs.push({type: "down", into: job.name});
-    this.jobs.push({type: "tap", args: job.args, fn: job.fn});
-    this.jobs.push({type: "up"});
-  } else {
-    job.fn.apply(this, job.args || []);
-  }
-
-  Array.prototype.push.apply(this.jobs, jobs);
-};
-
-Dissolve.prototype._exec_loop = function _exec_loop(job) {
-  if (job.finished) {
-    this.jobs.shift();
-    return;
-  }
-
-  var jobs = this.jobs;
-  this.jobs = [];
-
-  if (job.name) {
-    if (typeof this.vars[job.name] === "undefined") {
-      this.vars[job.name] = [];
-    }
-
-    // private scope so _job doesn't get redefined later
-    (function() {
-      var _job = job;
-
-      this.jobs.push({
-        type: "tap",
-        name: "__loop_temp",
-        args: [job.finish],
-        fn: job.fn,
-      });
-
-      this.jobs.push({
-        type: "tap",
-        fn: function() {
-          if (!_job.cancelled) {
-            this.vars[_job.name].push(this.vars.__loop_temp);
-          }
-
-          delete this.vars.__loop_temp;
-        },
-      });
-    }).call(this);
-  } else {
-    this.jobs.push({
-      type: "tap",
-      args: [job.finish],
-      fn: job.fn,
-    });
-  }
-  Array.prototype.push.apply(this.jobs, jobs);
-};
-
-Dissolve.prototype._exec_string = function _exec_string(job, offset, length) {
-  this.vars[job.name] = this._buffer.toString("utf8", offset, offset + length);
-  this.jobs.shift();
-};
-
-Dissolve.prototype._exec_buffer = function _exec_buffer(job, offset, length) {
-  this.vars[job.name] = this._buffer.slice(offset, offset+length);
-  this.jobs.shift();
+Dissolve.prototype.parser = function parser() {
+  throw new Error("Not implemented");
 };
 
 Dissolve.prototype._transform = function _transform(input, encoding, done) {
@@ -122,110 +30,90 @@ Dissolve.prototype._transform = function _transform(input, encoding, done) {
 
   this._buffer.append(input);
 
-  while (this.jobs.length) {
-    var job = this.jobs[0];
-
-    if (job.type === "down") {
-      this._exec_down(job);
-      continue;
-    }
-
-    if (job.type === "up") {
-      this._exec_up(job);
-      continue;
-    }
-
-    if (job.type === "tap") {
-      this._exec_tap(job);
-      continue;
-    }
-
-    if (job.type === "loop") {
-      this._exec_loop(job);
-      continue;
-    }
+  if (!this._generator) {
+    this._generator = this.parser();
+    this.currentStep = this._generator.next();
+  }
 
-    var length;
-    if (typeof job.length === "string") {
-      length = this.vars[job.length];
-    } else {
-      length = job.length;
-    }
+  while (!this.currentStep.done) {
+    var job = this.currentStep.value;
+    var result, length = job.length;
 
     if (this._buffer.length - offset < length) {
       break;
     }
 
-    if (job.type === "buffer") {
-      this._exec_buffer(job, offset, length);
-      offset += length;
-      continue;
-    }
-
-    if (job.type === "string") {
-      this._exec_string(job, offset, length);
-      offset += length;
-      continue;
-    }
-
-    if (job.type === "skip") {
-      this.jobs.shift();
-      offset += length;
-      continue;
-    }
-
     switch (job.type) {
-      case "int8le":  { this.vars[job.name] = this._buffer.readInt8(offset);  break; }
-      case "uint8le": { this.vars[job.name] = this._buffer.readUInt8(offset); break; }
-      case "int8be":  { this.vars[job.name] = this._buffer.readInt8(offset);  break; }
-      case "uint8be": { this.vars[job.name] = this._buffer.readUInt8(offset); break; }
-      case "int16le":  { this.vars[job.name] = this._buffer.readInt16LE(offset);  break; }
-      case "uint16le": { this.vars[job.name] = this._buffer.readUInt16LE(offset); break; }
-      case "int16be":  { this.vars[job.name] = this._buffer.readInt16BE(offset);  break; }
-      case "uint16be": { this.vars[job.name] = this._buffer.readUInt16BE(offset); break; }
-      case "int32le":  { this.vars[job.name] = this._buffer.readInt32LE(offset);  break; }
-      case "uint32le": { this.vars[job.name] = this._buffer.readUInt32LE(offset); break; }
-      case "int32be":  { this.vars[job.name] = this._buffer.readInt32BE(offset);  break; }
-      case "uint32be": { this.vars[job.name] = this._buffer.readUInt32BE(offset); break; }
-      case "int64le":  { this.vars[job.name] = (Math.pow(2, 32) * this._buffer.readInt32LE(offset + 4)) + ((this._buffer[offset + 4] & 0x80 === 0x80 ? 1 : -1) * this._buffer.readUInt32LE(offset)); break; }
-      case "uint64le": { this.vars[job.name] = (Math.pow(2, 32) * this._buffer.readUInt32LE(offset + 4)) + this._buffer.readUInt32LE(offset); break; }
-      case "int64be":  { this.vars[job.name] = (Math.pow(2, 32) * this._buffer.readInt32BE(offset)) + ((this._buffer[offset] & 0x80 === 0x80 ? 1 : -1) * this._buffer.readUInt32BE(offset + 4)); break; }
-      case "uint64be": { this.vars[job.name] = (Math.pow(2, 32) * this._buffer.readUInt32BE(offset)) + this._buffer.readUInt32BE(offset + 4); break; }
-      case "floatle":  { this.vars[job.name] = this._buffer.readFloatLE(offset);  break; }
-      case "floatbe":  { this.vars[job.name] = this._buffer.readFloatBE(offset);  break; }
-      case "doublele": { this.vars[job.name] = this._buffer.readDoubleLE(offset); break; }
-      case "doublebe": { this.vars[job.name] = this._buffer.readDoubleBE(offset); break; }
+      case "skip": { break; }
+      case "string": { result = this._buffer.toString("utf8", offset, offset + length); break; }
+      case "buffer": { result = this._buffer.slice(offset, offset + length); break; }
+      case "int8le":  { result = this._buffer.readInt8(offset);  break; }
+      case "uint8le": { result = this._buffer.readUInt8(offset); break; }
+      case "int8be":  { result = this._buffer.readInt8(offset);  break; }
+      case "uint8be": { result = this._buffer.readUInt8(offset); break; }
+      case "int16le":  { result = this._buffer.readInt16LE(offset);  break; }
+      case "uint16le": { result = this._buffer.readUInt16LE(offset); break; }
+      case "int16be":  { result = this._buffer.readInt16BE(offset);  break; }
+      case "uint16be": { result = this._buffer.readUInt16BE(offset); break; }
+      case "int32le":  { result = this._buffer.readInt32LE(offset);  break; }
+      case "uint32le": { result = this._buffer.readUInt32LE(offset); break; }
+      case "int32be":  { result = this._buffer.readInt32BE(offset);  break; }
+      case "uint32be": { result = this._buffer.readUInt32BE(offset); break; }
+      case "int64le":  { result = (Math.pow(2, 32) * this._buffer.readInt32LE(offset + 4)) + ((this._buffer[offset + 4] & 0x80 === 0x80 ? 1 : -1) * this._buffer.readUInt32LE(offset)); break; }
+      case "uint64le": { result = (Math.pow(2, 32) * this._buffer.readUInt32LE(offset + 4)) + this._buffer.readUInt32LE(offset); break; }
+      case "int64be":  { result = (Math.pow(2, 32) * this._buffer.readInt32BE(offset)) + ((this._buffer[offset] & 0x80 === 0x80 ? 1 : -1) * this._buffer.readUInt32BE(offset + 4)); break; }
+      case "uint64be": { result = (Math.pow(2, 32) * this._buffer.readUInt32BE(offset)) + this._buffer.readUInt32BE(offset + 4); break; }
+      case "floatle":  { result = this._buffer.readFloatLE(offset);  break; }
+      case "floatbe":  { result = this._buffer.readFloatBE(offset);  break; }
+      case "doublele": { result = this._buffer.readDoubleLE(offset); break; }
+      case "doublebe": { result = this._buffer.readDoubleBE(offset); break; }
       default: { return done(new Error("invalid job type")); }
     }
 
-    this.jobs.shift();
-
     offset += length;
+
+    this.currentStep = this._generator.next(result);
   }
 
   this._buffer.consume(offset);
 
-  if (this.jobs.length === 0) {
+  if (this.currentStep.done) {
     this.push(null);
   }
 
   return done();
 };
 
+Dissolve.prototype.buffer = function buffer(length) {
+  return {
+    type: "buffer",
+    length: length
+  };
+};
+
+Dissolve.prototype.string = function string(length, encoding) {
+  return {
+    type: "string",
+    length: length,
+    encoding: encoding
+  };
+};
+
+Dissolve.prototype.skip = function skip(length) {
+  return { type: "skip" };
+};
+
 [["float", 4], ["double", 8]].forEach(function(t) {
   ["", "le", "be"].forEach(function(e) {
     var id = [t[0], e].join(""),
         type = [t[0], e || "le"].join(""),
         length = t[1];
 
-    Dissolve.prototype[id] = function(name) {
-      this.jobs.push({
+    Dissolve.prototype[id] = function () {
+      return {
         type: type,
-        length: length,
-        name: name,
-      });
-
-      return this;
+        length: length
+      };
     };
   });
 });
@@ -237,64 +125,12 @@ Dissolve.prototype._transform = function _transform(input, encoding, done) {
           type = [s, "int", b, e || "le"].join(""),
           length = b / 8;
 
-      Dissolve.prototype[id] = function(name) {
-        this.jobs.push({
+      Dissolve.prototype[id] = function () {
+        return {
           type: type,
-          length: length,
-          name: name,
-        });
-
-        return this;
+          length: length
+        };
       };
     });
   });
 });
-
-["tap", "loop"].forEach(function(e) {
-  Dissolve.prototype[e] = function(name, fn) {
-    if (typeof name === "function") {
-      fn = name;
-      name = null;
-    }
-
-    var job = {
-      type: e,
-      name: name,
-      fn: fn,
-    };
-
-    if (e === "loop") {
-      job.finish = function(cancel) {
-        job.finished = true;
-        job.cancelled = !!cancel;
-      };
-    }
-
-    this.jobs.push(job);
-
-    return this;
-  };
-});
-
-["buffer", "string"].forEach(function(e) {
-  Dissolve.prototype[e] = function(name, length) {
-    this.jobs.push({
-      type: e,
-      name: name,
-      length: length,
-    });
-
-    return this;
-  };
-});
-
-["skip"].forEach(function(e) {
-  Dissolve.prototype[e] = function(length) {
-    this.jobs.push({
-      type: e,
-      length: length,
-    });
-
-    return this;
-  };
-});
diff --git a/test/integer.js b/test/integer.js
index 7fb209a..22ee56f 100644
--- a/test/integer.js
+++ b/test/integer.js
@@ -2,9 +2,10 @@ var Dissolve = require("../index");
 
 describe("integers", function() {
   it("00 through uint8 should result in 0", function(done) {
-    var reader = Dissolve().uint8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -20,9 +21,10 @@ describe("integers", function() {
   });
 
   it("01 through uint8 should result in 1", function(done) {
-    var reader = Dissolve().uint8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -38,9 +40,10 @@ describe("integers", function() {
   });
 
   it("7f through uint8 should result in 127", function(done) {
-    var reader = Dissolve().uint8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -56,9 +59,10 @@ describe("integers", function() {
   });
 
   it("ff through uint8 should result in 255", function(done) {
-    var reader = Dissolve().uint8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -74,9 +78,10 @@ describe("integers", function() {
   });
 
   it("00 through int8 should result in 0", function(done) {
-    var reader = Dissolve().int8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -92,9 +97,10 @@ describe("integers", function() {
   });
 
   it("01 through int8 should result in 1", function(done) {
-    var reader = Dissolve().int8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -110,9 +116,10 @@ describe("integers", function() {
   });
 
   it("7f through int8 should result in 127", function(done) {
-    var reader = Dissolve().int8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -128,9 +135,10 @@ describe("integers", function() {
   });
 
   it("ff through int8 should result in -1", function(done) {
-    var reader = Dissolve().int8("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int8());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -146,9 +154,10 @@ describe("integers", function() {
   });
 
   it("0000 through uint16be should result in 0", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -164,9 +173,10 @@ describe("integers", function() {
   });
 
   it("0001 through uint16be should result in 1", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -182,9 +192,10 @@ describe("integers", function() {
   });
 
   it("007f through uint16be should result in 127", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -200,9 +211,10 @@ describe("integers", function() {
   });
 
   it("00ff through uint16be should result in 255", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -218,9 +230,10 @@ describe("integers", function() {
   });
 
   it("0000 through int16be should result in 0", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -236,9 +249,10 @@ describe("integers", function() {
   });
 
   it("0001 through int16be should result in 1", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -254,9 +268,10 @@ describe("integers", function() {
   });
 
   it("007f through int16be should result in 127", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -272,9 +287,10 @@ describe("integers", function() {
   });
 
   it("00ff through int16be should result in 255", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -290,9 +306,10 @@ describe("integers", function() {
   });
 
   it("7f00 through uint16be should result in 32512", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -308,9 +325,10 @@ describe("integers", function() {
   });
 
   it("7f01 through uint16be should result in 32513", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -326,9 +344,10 @@ describe("integers", function() {
   });
 
   it("7f7f through uint16be should result in 32639", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -344,9 +363,10 @@ describe("integers", function() {
   });
 
   it("7fff through uint16be should result in 32767", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -362,9 +382,10 @@ describe("integers", function() {
   });
 
   it("7f00 through int16be should result in 32512", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -380,9 +401,10 @@ describe("integers", function() {
   });
 
   it("7f01 through int16be should result in 32513", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -398,9 +420,10 @@ describe("integers", function() {
   });
 
   it("7f7f through int16be should result in 32639", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -416,9 +439,10 @@ describe("integers", function() {
   });
 
   it("7fff through int16be should result in 32767", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -434,9 +458,10 @@ describe("integers", function() {
   });
 
   it("ff00 through uint16be should result in 65280", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -452,9 +477,10 @@ describe("integers", function() {
   });
 
   it("ff01 through uint16be should result in 65281", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -470,9 +496,10 @@ describe("integers", function() {
   });
 
   it("ff7f through uint16be should result in 65407", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -488,9 +515,10 @@ describe("integers", function() {
   });
 
   it("ffff through uint16be should result in 65535", function(done) {
-    var reader = Dissolve().uint16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -506,9 +534,10 @@ describe("integers", function() {
   });
 
   it("ff00 through int16be should result in -256", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -524,9 +553,10 @@ describe("integers", function() {
   });
 
   it("ff01 through int16be should result in -255", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -542,9 +572,10 @@ describe("integers", function() {
   });
 
   it("ff7f through int16be should result in -129", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -560,9 +591,10 @@ describe("integers", function() {
   });
 
   it("ffff through int16be should result in -1", function(done) {
-    var reader = Dissolve().int16be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -578,9 +610,10 @@ describe("integers", function() {
   });
 
   it("0000 through uint16le should result in 0", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -596,9 +629,10 @@ describe("integers", function() {
   });
 
   it("0100 through uint16le should result in 1", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -614,9 +648,10 @@ describe("integers", function() {
   });
 
   it("7f00 through uint16le should result in 127", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -632,9 +667,10 @@ describe("integers", function() {
   });
 
   it("ff00 through uint16le should result in 255", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -650,9 +686,10 @@ describe("integers", function() {
   });
 
   it("0000 through int16le should result in 0", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -668,9 +705,10 @@ describe("integers", function() {
   });
 
   it("0100 through int16le should result in 1", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -686,9 +724,10 @@ describe("integers", function() {
   });
 
   it("7f00 through int16le should result in 127", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -704,9 +743,10 @@ describe("integers", function() {
   });
 
   it("ff00 through int16le should result in 255", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -722,9 +762,10 @@ describe("integers", function() {
   });
 
   it("007f through uint16le should result in 32512", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -740,9 +781,10 @@ describe("integers", function() {
   });
 
   it("017f through uint16le should result in 32513", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -758,9 +800,10 @@ describe("integers", function() {
   });
 
   it("7f7f through uint16le should result in 32639", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -776,9 +819,10 @@ describe("integers", function() {
   });
 
   it("ff7f through uint16le should result in 32767", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -794,9 +838,10 @@ describe("integers", function() {
   });
 
   it("007f through int16le should result in 32512", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -812,9 +857,10 @@ describe("integers", function() {
   });
 
   it("017f through int16le should result in 32513", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -830,9 +876,10 @@ describe("integers", function() {
   });
 
   it("7f7f through int16le should result in 32639", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -848,9 +895,10 @@ describe("integers", function() {
   });
 
   it("ff7f through int16le should result in 32767", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -866,9 +914,10 @@ describe("integers", function() {
   });
 
   it("00ff through uint16le should result in 65280", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -884,9 +933,10 @@ describe("integers", function() {
   });
 
   it("01ff through uint16le should result in 65281", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -902,9 +952,10 @@ describe("integers", function() {
   });
 
   it("7fff through uint16le should result in 65407", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -920,9 +971,10 @@ describe("integers", function() {
   });
 
   it("ffff through uint16le should result in 65535", function(done) {
-    var reader = Dissolve().uint16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -938,9 +990,10 @@ describe("integers", function() {
   });
 
   it("00ff through int16le should result in -256", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -956,9 +1009,10 @@ describe("integers", function() {
   });
 
   it("01ff through int16le should result in -255", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -974,9 +1028,10 @@ describe("integers", function() {
   });
 
   it("7fff through int16le should result in -129", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -992,9 +1047,10 @@ describe("integers", function() {
   });
 
   it("ffff through int16le should result in -1", function(done) {
-    var reader = Dissolve().int16le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int16le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1010,9 +1066,10 @@ describe("integers", function() {
   });
 
   it("00000000 through uint32be should result in 0", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1028,9 +1085,10 @@ describe("integers", function() {
   });
 
   it("00000001 through uint32be should result in 1", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1046,9 +1104,10 @@ describe("integers", function() {
   });
 
   it("0000007f through uint32be should result in 127", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1064,9 +1123,10 @@ describe("integers", function() {
   });
 
   it("000000ff through uint32be should result in 255", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1082,9 +1142,10 @@ describe("integers", function() {
   });
 
   it("00000000 through int32be should result in 0", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1100,9 +1161,10 @@ describe("integers", function() {
   });
 
   it("00000001 through int32be should result in 1", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1118,9 +1180,10 @@ describe("integers", function() {
   });
 
   it("0000007f through int32be should result in 127", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1136,9 +1199,10 @@ describe("integers", function() {
   });
 
   it("000000ff through int32be should result in 255", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1154,9 +1218,10 @@ describe("integers", function() {
   });
 
   it("7f000000 through uint32be should result in 2130706432", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1172,9 +1237,10 @@ describe("integers", function() {
   });
 
   it("7f000001 through uint32be should result in 2130706433", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1190,9 +1256,10 @@ describe("integers", function() {
   });
 
   it("7f00007f through uint32be should result in 2130706559", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1208,9 +1275,10 @@ describe("integers", function() {
   });
 
   it("7f0000ff through uint32be should result in 2130706687", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1226,9 +1294,10 @@ describe("integers", function() {
   });
 
   it("7f000000 through int32be should result in 2130706432", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1244,9 +1313,10 @@ describe("integers", function() {
   });
 
   it("7f000001 through int32be should result in 2130706433", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1262,9 +1332,10 @@ describe("integers", function() {
   });
 
   it("7f00007f through int32be should result in 2130706559", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1280,9 +1351,10 @@ describe("integers", function() {
   });
 
   it("7f0000ff through int32be should result in 2130706687", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1298,9 +1370,10 @@ describe("integers", function() {
   });
 
   it("ff000000 through uint32be should result in 4278190080", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1316,9 +1389,10 @@ describe("integers", function() {
   });
 
   it("ff000001 through uint32be should result in 4278190081", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1334,9 +1408,10 @@ describe("integers", function() {
   });
 
   it("ff00007f through uint32be should result in 4278190207", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1352,9 +1427,10 @@ describe("integers", function() {
   });
 
   it("ff0000ff through uint32be should result in 4278190335", function(done) {
-    var reader = Dissolve().uint32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1370,9 +1446,10 @@ describe("integers", function() {
   });
 
   it("ffffff00 through int32be should result in -256", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1388,9 +1465,10 @@ describe("integers", function() {
   });
 
   it("ffffff01 through int32be should result in -255", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1406,9 +1484,10 @@ describe("integers", function() {
   });
 
   it("ffffff7f through int32be should result in -129", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1424,9 +1503,10 @@ describe("integers", function() {
   });
 
   it("ffffffff through int32be should result in -1", function(done) {
-    var reader = Dissolve().int32be("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32be());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1442,9 +1522,10 @@ describe("integers", function() {
   });
 
   it("00000000 through uint32le should result in 0", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1460,9 +1541,10 @@ describe("integers", function() {
   });
 
   it("01000000 through uint32le should result in 1", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1478,9 +1560,10 @@ describe("integers", function() {
   });
 
   it("7f000000 through uint32le should result in 127", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1496,9 +1579,10 @@ describe("integers", function() {
   });
 
   it("ff000000 through uint32le should result in 255", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1514,9 +1598,10 @@ describe("integers", function() {
   });
 
   it("00000000 through int32le should result in 0", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1532,9 +1617,10 @@ describe("integers", function() {
   });
 
   it("01000000 through int32le should result in 1", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1550,9 +1636,10 @@ describe("integers", function() {
   });
 
   it("7f000000 through int32le should result in 127", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1568,9 +1655,10 @@ describe("integers", function() {
   });
 
   it("ff000000 through int32le should result in 255", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1586,9 +1674,10 @@ describe("integers", function() {
   });
 
   it("0000007f through uint32le should result in 2130706432", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1604,9 +1693,10 @@ describe("integers", function() {
   });
 
   it("0100007f through uint32le should result in 2130706433", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1622,9 +1712,10 @@ describe("integers", function() {
   });
 
   it("7f00007f through uint32le should result in 2130706559", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1640,9 +1731,10 @@ describe("integers", function() {
   });
 
   it("ff00007f through uint32le should result in 2130706687", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1658,9 +1750,10 @@ describe("integers", function() {
   });
 
   it("0000007f through int32le should result in 2130706432", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1676,9 +1769,10 @@ describe("integers", function() {
   });
 
   it("0100007f through int32le should result in 2130706433", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1694,9 +1788,10 @@ describe("integers", function() {
   });
 
   it("7f00007f through int32le should result in 2130706559", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1712,9 +1807,10 @@ describe("integers", function() {
   });
 
   it("ff00007f through int32le should result in 2130706687", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1730,9 +1826,10 @@ describe("integers", function() {
   });
 
   it("000000ff through uint32le should result in 4278190080", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1748,9 +1845,10 @@ describe("integers", function() {
   });
 
   it("010000ff through uint32le should result in 4278190081", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1766,9 +1864,10 @@ describe("integers", function() {
   });
 
   it("7f0000ff through uint32le should result in 4278190207", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1784,9 +1883,10 @@ describe("integers", function() {
   });
 
   it("ff0000ff through uint32le should result in 4278190335", function(done) {
-    var reader = Dissolve().uint32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.uint32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1802,9 +1902,10 @@ describe("integers", function() {
   });
 
   it("00ffffff through int32le should result in -256", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1820,9 +1921,10 @@ describe("integers", function() {
   });
 
   it("01ffffff through int32le should result in -255", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1838,9 +1940,10 @@ describe("integers", function() {
   });
 
   it("7fffffff through int32le should result in -129", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
@@ -1856,9 +1959,10 @@ describe("integers", function() {
   });
 
   it("ffffffff through int32le should result in -1", function(done) {
-    var reader = Dissolve().int32le("i").tap(function() {
-      this.push(this.vars.i);
-    });
+    var reader = Dissolve();
+    reader.parser = function*() {
+      this.push(yield this.int32le());
+    };
 
     reader.once("readable", function() {
       var data = reader.read();
diff --git a/test/loop.js b/test/loop.js
index d1fc5d8..0d7ba70 100644
--- a/test/loop.js
+++ b/test/loop.js
@@ -1,16 +1,14 @@
 var Dissolve = require("../index");
 
-describe("loop", function() {
-  it("should emit data 3 times then end", function(done) {
-    var reader = Dissolve().loop(function(end) {
-      this.uint8("x").tap(function() {
-        if (this.vars.x === 0) {
-          return end(true);
-        } else {
-          this.push(this.vars);
-        }
-      });
-    });
+describe("Dissolve looping", function() {
+  it("should support simple looping constructs", function(done) {
+    var reader = Dissolve();
+    reader.parser = function*() {
+      var x;
+      while ((x = yield this.uint8()) !== 0) {
+        this.push({ x: x });
+      }
+    };
 
     var counter = 0;
 
@@ -32,62 +30,27 @@ describe("loop", function() {
     reader.write(Buffer([0x01, 0x01, 0x01, 0x00, 0x02]));
   });
 
-  it("should populate an array correctly", function(done) {
-    var reader = Dissolve().loop("things", function(end) {
-      this.uint8("x").tap(function() {
-        if (this.vars.x === 0) {
-          return end(true);
-        }
-      });
-    }).tap(function() {
-      this.push(this.vars);
-    });
-
-    reader.on("readable", function() {
-      var e;
-      while (e = reader.read()) {
-        if (typeof e !== "object" || e === null) {
-          return done(Error("invalid payload for data event"));
-        }
+  it("should work with complex, nested loop operations", function(done) {
+    var reader = Dissolve();
+    reader.parser = function*() {
+      var data = [];
+      var data_count = yield this.uint8();
 
-        if (!Array.isArray(e.things)) {
-          return done(Error("array property not set or not correct type"));
-        }
+      for (var i = 0; i < data_count; i++) {
+        var elements = []
+        var element_count = yield this.uint8();
 
-        if (e.things.length !== 3) {
-          return done(Error("invalid number of entries"));
+        for (var j = 0; j < element_count; j++) {
+          elements.push({ element: yield this.uint8() });
         }
 
-        return done();
+        data.push({ elements: elements });
       }
-    });
-
-    reader.write(Buffer([0x01, 0x01, 0x01, 0x00]));
-  });
 
-  it("should work with nested, cancelled loop operations", function(done) {
-    var reader = Dissolve().tap(function() {
-      var data_i = 0;
-
-      this.uint8("data_count").loop("data", function(end) {
-        if (data_i++ === this.vars.data_count) {
-          return end(true);
-        }
-
-        var elements_i = 0;
-
-        this.uint8("element_count").loop("elements", function(end) {
-          if (elements_i++ === this.vars.element_count) {
-            return end(true);
-          }
-
-          this.uint8("element");
-        });
-      }).tap(function() {
-        this.push(this.vars);
-        this.vars = Object.create(null);
+      this.push({
+        data: data
       });
-    });
+    };
 
     reader.on("readable", function() {
       var e;
diff --git a/test/tap.js b/test/tap.js
deleted file mode 100644
index 50fd686..0000000
--- a/test/tap.js
+++ /dev/null
@@ -1,63 +0,0 @@
-var assert = require("chai").assert;
-var Dissolve = require("../index");
-
-describe("tap", function() {
-  it("should emit data 2 times then end", function(done) {
-    var reader = Dissolve().uint8("x").tap(function() {
-      this.push(this.vars.x);
-
-      this.uint8("y").tap(function() {
-        this.push(this.vars.y);
-
-        this.tap(function() {
-          this.push(null);
-        });
-      });
-    });
-
-    var counter = 0;
-
-    reader.on("readable", function() {
-      var data;
-      while (data = reader.read()) {
-        counter++;
-      }
-    });
-
-    reader.on("end", function() {
-      if (counter !== 2) {
-        return done(Error("invalid counter value"));
-      } else {
-        return done();
-      }
-    });
-
-    reader.write(Buffer([0x01, 0x01]));
-  });
-
-  it("should populate child objects correctly", function(done) {
-    var reader = Dissolve().tap("a", function() {
-      this.uint8("x").tap("b", function() {
-        this.uint8("y").tap(function() {
-          this.push(this.vars);
-        });
-      });
-    });
-
-    reader.once("readable", function() {
-      var e = reader.read();
-
-      assert.isObject(e);
-      assert.isObject(e.a);
-      assert.isObject(e.a.b);
-      assert.strictEqual(e.a.x, 1);
-      assert.strictEqual(e.a.b.y, 1);
-
-      assert.isNull(reader.read());
-
-      done();
-    });
-
-    reader.write(Buffer([0x01, 0x01]));
-  });
-});