Iterative .entries & co (replacing recursive)

1.3× performance improvement, which is much more modest than all the
previous, but we take those.

Author: anko

benchmark/entries.js

@@ -0,0 +1,15 @@
+const benchmark = require('benchmark')
+const AKM = require('../main.js')
+
+const letters = 'abcdefghijklmnopqrstuvwxyz'.split('')
+
+const lettersMap = new AKM()
+for (const x of letters) lettersMap.set(Array(100).fill(x), true)
+
+new benchmark.Suite()
+  .add('100-item iterator', () => {
+    const entriesGenerator = lettersMap.entries()
+    while (!entriesGenerator.next().done) { continue }
+  })
+  .on('cycle', ev => console.log(String(ev.target)))
+  .run()

main.js

@@ -82,15 +82,15 @@ class ArrayKeyedMap {
 
   get [Symbol.toStringTag] () { return 'ArrayKeyedMap' }
 
-  * [Symbol.iterator] () { yield * entries([], this._root) }
+  * [Symbol.iterator] () { yield * entries.call(this) }
 
-  * entries () { yield * entries([], this._root) }
+  * entries () { yield * entries.call(this) }
 
-  * keys () { yield * keys(this._root) }
+  * keys () { yield * keys.call(this) }
 
-  * values () { yield * values(this._root) }
+  * values () { yield * values.call(this) }
 
-  forEach (callback, thisArg) { forEach(this._root, callback, thisArg, this) }
+  forEach (callback, thisArg) { forEach.call(this, callback, thisArg) }
 }
 
 module.exports = ArrayKeyedMap
@@ -184,23 +184,25 @@ function hasPrefix (path) {
   return true
 }
 
-const entries = function * (path, store) {
-  for (const [key, value] of store) {
-    if (key === dataSymbol) yield [path, value]
-    else {
-      yield * entries(path.concat([key]), value)
+function * entries () {
+  const stack = [{ path: [], map: this._root }]
+  while (stack.length > 0) {
+    const { path, map } = stack.pop()
+    for (const [k, v] of map.entries()) {
+      if (k === dataSymbol) yield [path, v]
+      else stack.push({ path: path.concat([k]), map: v })
     }
   }
 }
 
-const keys = function * (store) {
-  for (const [k] of entries([], store)) yield k
+function * keys () {
+  for (const [k] of this.entries()) yield k
 }
 
-const values = function * (store) {
-  for (const [, v] of entries([], store)) yield v
+function * values () {
+  for (const [, v] of this.entries()) yield v
 }
 
-const forEach = (store, callback, thisArg, main) => {
-  for (const [k, v] of entries([], store)) callback.call(thisArg, v, k, main)
+function forEach (callback, thisArg) {
+  for (const [k, v] of this.entries()) callback.call(thisArg, v, k, this)
 }

test.js

@@ -1,5 +1,6 @@
 const test = require('tape')
 const AKM = require('./main.js')
+const assert = require('assert')
 
 test('empty', (t) => {
   const p = new AKM()
@@ -244,41 +245,60 @@ test('iterators', (t) => {
   const value4 = 'ba'
   p.set(key4, value4)
 
-  // Note that entries 3 and 4 come in the opposite order in every iterator.
-  // This is OK, because this module doesn't guarantee iteration order.
+  // We don't guarantee any particular order in which entries are emitted by
+  // iterators.  So to make this test work even if the implementation changes,
+  // we specifically disregard order when checking them.
+  function containsAllOf (t, array, expectedItems) {
+    t.same(
+      array.length,
+      expectedItems.length,
+      'Iterator has right number of elements')
+
+    expectedItems.forEach(expectedItem => {
+      const wasFound = array.some(actualItem => {
+        try {
+          assert.deepStrictEqual(actualItem, expectedItem)
+        } catch (e) {
+          if (e instanceof assert.AssertionError) return false
+          else throw e
+        }
+        return true
+      })
+      t.ok(wasFound, `Iterator contains ${JSON.stringify(expectedItem)}`)
+    })
+  }
+
   test('entries', (t) => {
-    const iterator = p.entries()
-    t.same(iterator.next().value, [key1, value1])
-    t.same(iterator.next().value, [key2, value2])
-    t.same(iterator.next().value, [key4, value4])
-    t.same(iterator.next().value, [key3, value3])
+    containsAllOf(t, [...p.entries()], [
+      [key1, value1],
+      [key2, value2],
+      [key3, value3],
+      [key4, value4]
+    ])
     t.end()
   })
 
   test('@@iterator', (t) => {
-    const a = Array.from(p)
-    t.same(a[0], [key1, value1])
-    t.same(a[1], [key2, value2])
-    t.same(a[2], [key4, value4])
-    t.same(a[3], [key3, value3])
+    containsAllOf(t, Array.from(p), [
+      [key1, value1],
+      [key2, value2],
+      [key3, value3],
+      [key4, value4]
+    ])
     t.end()
   })
 
   test('keys', (t) => {
-    const iterator = p.keys()
-    t.same(iterator.next().value, key1)
-    t.same(iterator.next().value, key2)
-    t.same(iterator.next().value, key4)
-    t.same(iterator.next().value, key3)
+    containsAllOf(t, [...p.keys()], [
+      key1, key2, key3, key4
+    ])
     t.end()
   })
 
   test('values', (t) => {
-    const iterator = p.values()
-    t.same(iterator.next().value, value1)
-    t.same(iterator.next().value, value2)
-    t.same(iterator.next().value, value4)
-    t.same(iterator.next().value, value3)
+    containsAllOf(t, [...p.values()], [
+      value1, value2, value3, value4
+    ])
     t.end()
   })
 
@@ -291,7 +311,7 @@ test('iterators', (t) => {
       },
       thisValue)
     t.same(forEachReturnValue, undefined)
-    t.same(kvs, [
+    containsAllOf(t, kvs, [
       { thisValue: thisValue, args: [value1, key1, p] },
       { thisValue: thisValue, args: [value2, key2, p] },
       { thisValue: thisValue, args: [value4, key4, p] },