add asyncForEach

README.md

@@ -44,6 +44,7 @@ Or use the compiled version 'dist/avl.js'.
 * `tree.at(index:Number):Node|Null` - Return node by its index in sorted order of keys
 * `tree.contains(key):Boolean` - Whether a node with the given key is in the tree
 * `tree.forEach(function(node) {...}):Tree` In-order traversal
+* `tree.asyncForEach(async function(node) {...}):Tree` In-order traversal for async callbacks
 * `tree.range(lo, high, function(node) {} [, context]):Tree` - Walks the range of keys in order. Stops, if the visitor function returns a non-zero value.
 * `tree.keys():Array<key>` - Returns the array of keys in order
 * `tree.values():Array<*>` - Returns the array of data fields in order

bench/benchmark.js

@@ -95,3 +95,16 @@ new Benchmark.Suite(`Bulk-load (x${M})`, options)
     t.load(data, []);
   })
   .run();
+
+new Benchmark.Suite(`Traverse (x${N})`, options)
+  .add('AVL (forEach)', () => {
+    let count = 0;
+    prefilledAVL.forEach(node => count += node.key);
+  })
+  .add('AVL (asyncForEach)', (deferred) => {
+    let count = 0;
+    const promise = prefilledAVL.asyncForEach(node => count += node.key)
+    promise.then(() => deferred.resolve());
+  }, {'defer': true})
+  .run();
+

src/index.js

@@ -1,4 +1,4 @@
-import { print, isBalanced, loadRecursive, markBalance, sort } from './utils';
+import { print, isBalanced, loadRecursive, markBalance, sort, whilst } from './utils';
 
 
 // function createNode (parent, left, right, height, key, data) {
@@ -270,6 +270,17 @@ export default class AVLTree {
     return this;
   }
 
+  /**
+   * @param  {forEachCallback} callback
+   * @return {Promise}
+   */
+  asyncForEach (callback) {
+    const minNode = this.minNode();
+    let node;
+    const next = this.next.bind(this);
+    const iterate = () => { node = node ? next(node) : minNode; return node; };
+    return whilst(iterate, callback);
+  }
 
   /**
    * Walk key range from `low` to `high`. Stops if `fn` returns a value.

src/utils.js

@@ -113,3 +113,12 @@ export function sort(keys, values, left, right, compare) {
   sort(keys, values,  left,     j, compare);
   sort(keys, values, j + 1, right, compare);
 }
+
+export async function whilst (next, iteratee) {
+  let i = 0, n;
+  // eslint-disable-next-line no-cond-assign
+  while ((n = next()) !== undefined) {
+    // eslint-disable-next-line no-await-in-loop
+    await iteratee(n, i++);
+  }
+}

tests/async.test.js

@@ -0,0 +1,16 @@
+import { describe, it } from 'mocha';
+import { assert }       from 'chai';
+
+import Tree from '../src/index';
+
+describe('async check', () => {
+  it ('should traverse the tree in order', async () => {
+    const tree = new Tree();
+    tree.insert(2);
+    tree.insert(0);
+    tree.insert(3);
+    tree.insert(1);
+
+    await tree.asyncForEach(async (n, i) => assert.equal(n.key, i));
+  });
+});