hamt.js.map

{"version":3,"sources":["hamt.js"],"names":["hamt","SIZE","BUCKET_SIZE","Math","pow","MASK","MAX_INDEX_NODE","MIN_ARRAY_NODE","defaultValBind","f","defaultValue","x","arguments","length","hash","type","str","i","len","c","charCodeAt","popcount","hashFragment","shift","h","toBitmap","fromBitmap","bitmap","bit","arrayUpdate","at","v","arr","out","Array","arraySpliceOut","g","arraySpliceIn","LEAF","COLLISION","INDEX","ARRAY","Leaf","key","value","_modify","Leaf__modify","Collision","children","Collision__modify","IndexedNode","mask","IndexedNode__modify","ArrayNode","size","ArrayNode__modify","isLeaf","node","expand","frag","child","subNodes","count","pack","removed","elements","elem","mergeLeaves","h1","n1","h2","n2","subH1","subH2","updateCollisionList","list","op","k","__hamt_delete_op","newValue","__hamt_set_op","undefined","currentValue","indx","exists","newChild","empty__modify","current","_","Map","root","prototype","__hamt_isMap","setTree","tryGetHash","alt","map","tryGet","getHash","get","nothing","hasHash","has","empty","isMap","isEmpty","modifyHash","newRoot","modify","modifyValueHash","modifyValue","setHash","set","del","removeHash","deleteHash","remove","delete","appk","lazyVisitChildren","lazyVisit","rest","DONE","done","MapIterator","next","v0","Symbol","iterator","visit","buildPairs","entries","buildKeys","keys","buildValues","values","fold","z","m","toVisit","forEach","module","exports","define","amd"],"mappings":"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","file":"hamt.js","sourcesContent":["/**\n    @fileOverview Hash Array Mapped Trie.\n\n    Code based on: https://github.com/exclipy/pdata\n*/\nconst hamt = {}; // export\n\n/* Configuration\n ******************************************************************************/\nconst SIZE = 5;\n\nconst BUCKET_SIZE = Math.pow(2, SIZE);\n\nconst MASK = BUCKET_SIZE - 1;\n\nconst MAX_INDEX_NODE = BUCKET_SIZE / 2;\n\nconst MIN_ARRAY_NODE = BUCKET_SIZE / 4;\n\n/*\n ******************************************************************************/\nconst defaultValBind = (f, defaultValue) =>\n    function(x) {\n        return f(arguments.length === 0 ? defaultValue : x);\n    };\n\n/**\n    Get 32 bit hash of string.\n\n    Based on:\n    http://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery\n*/\nconst hash = hamt.hash = str => {\n    const type = typeof str;\n    if (type === 'number')\n        return str;\n    if (type !== 'string')\n        str += '';\n\n    let hash = 0;\n    for (let i = 0, len = str.length; i < len; ++i) {\n        const c = str.charCodeAt(i);\n        hash = (((hash << 5) - hash) + c) | 0;\n    }\n    return hash;\n};\n\n/* Bit Ops\n ******************************************************************************/\n/**\n    Hamming weight.\n\n    Taken from: http://jsperf.com/hamming-weight\n*/\nconst popcount = (x) => {\n    x -= ((x >> 1) & 0x55555555);\n    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n    x = (x + (x >> 4)) & 0x0f0f0f0f;\n    x += (x >> 8);\n    x += (x >> 16);\n    return (x & 0x7f);\n};\n\nconst hashFragment = (shift, h) =>\n    (h >>> shift) & MASK;\n\nconst toBitmap = x =>\n    1 << x;\n\nconst fromBitmap = (bitmap, bit) =>\n    popcount(bitmap & (bit - 1));\n\n/* Array Ops\n ******************************************************************************/\n/**\n    Set a value in an array.\n\n    @param at Index to change.\n    @param v New value\n    @param arr Array.\n*/\nconst arrayUpdate = (at, v, arr) => {\n    const len = arr.length;\n    const out = new Array(len);\n    for (let i = 0; i < len; ++i)\n        out[i] = arr[i];\n    out[at] = v;\n    return out;\n};\n\n/**\n    Remove a value from an array.\n\n    @param at Index to remove.\n    @param arr Array.\n*/\nconst arraySpliceOut = (at, arr) => {\n    const len = arr.length;\n    const out = new Array(len - 1);\n    let i = 0, g = 0;\n    while (i < at)\n        out[g++] = arr[i++];\n    ++i;\n    while (i < len)\n        out[g++] = arr[i++];\n    return out;\n};\n\n/**\n    Insert a value into an array.\n\n    @param at Index to insert at.\n    @param v Value to insert,\n    @param arr Array.\n*/\nconst arraySpliceIn = (at, v, arr) => {\n    const len = arr.length;\n    const out = new Array(len + 1);\n    let i = 0, g = 0;\n    while (i < at)\n        out[g++] = arr[i++];\n    out[g++] = v;\n    while (i < len)\n        out[g++] = arr[i++];\n    return out;\n};\n\n/* Node Structures\n ******************************************************************************/\nconst LEAF = 1;\nconst COLLISION = 2;\nconst INDEX = 3;\nconst ARRAY = 4;\n\n/**\n    Leaf holding a value.\n\n    @member hash Hash of key.\n    @member key Key.\n    @member value Value stored.\n*/\nconst Leaf = (hash, key, value) => ({\n    type: LEAF,\n    hash,\n    key,\n    value,\n    _modify: Leaf__modify\n});\n\n/**\n    Leaf holding multiple values with the same hash but different keys.\n\n    @member hash Hash of key.\n    @member children Array of collision children node.\n*/\nconst Collision = (hash, children) => ({\n    type: COLLISION,\n    hash,\n    children,\n    _modify: Collision__modify\n});\n\n/**\n    Internal node with a sparse set of children.\n\n    Uses a bitmap and array to pack children.\n\n    @member mask Bitmap that encode the positions of children in the array.\n    @member children Array of child nodes.\n*/\nconst IndexedNode = (mask, children) => ({\n    type: INDEX,\n    mask,\n    children,\n    _modify: IndexedNode__modify\n});\n\n/**\n    Internal node with many children.\n\n    @member size Number of children.\n    @member children Array of child nodes.\n*/\nconst ArrayNode = (size, children) => ({\n    type: ARRAY,\n    size,\n    children,\n    _modify: ArrayNode__modify\n});\n\n/**\n    Is `node` a leaf node?\n*/\nconst isLeaf = node =>\n    (node.type === LEAF || node.type === COLLISION);\n\n/* Internal node operations.\n ******************************************************************************/\n/**\n    Expand an indexed node into an array node.\n\n    @param frag Index of added child.\n    @param child Added child.\n    @param mask Index node mask before child added.\n    @param subNodes Index node children before child added.\n*/\nconst expand = (frag, child, bitmap, subNodes) => {\n    const arr = [];\n    let bit = bitmap;\n    let count = 0;\n    for (let i = 0; bit; ++i) {\n        if (bit & 1)\n            arr[i] = subNodes[count++];\n        bit >>>= 1;\n    }\n    arr[frag] = child;\n    return ArrayNode(count + 1, arr);\n};\n\n/**\n    Collapse an array node into a indexed node.\n\n    @param count Number of elements in new array.\n    @param removed Index of removed element.\n    @param elements Array node children before remove.\n*/\nconst pack = (count, removed, elements) => {\n    const children = new Array(count - 1);\n    let g = 0;\n    let bitmap = 0;\n    for (let i = 0, len = elements.length; i < len; ++i) {\n        if (i !== removed) {\n            const elem = elements[i];\n            if (elem) {\n                children[g++] = elem;\n                bitmap |= 1 << i;\n            }\n        }\n    }\n    return IndexedNode(bitmap, children);\n};\n\n/**\n    Merge two leaf nodes.\n\n    @param shift Current shift.\n    @param h1 Node 1 hash.\n    @param n1 Node 1.\n    @param h2 Node 2 hash.\n    @param n2 Node 2.\n*/\nconst mergeLeaves = (shift, h1, n1, h2, n2) => {\n    if (h1 === h2)\n        return Collision(h1, [n2, n1]);\n\n    const subH1 = hashFragment(shift, h1);\n    const subH2 = hashFragment(shift, h2);\n    return IndexedNode(toBitmap(subH1) | toBitmap(subH2),\n        subH1 === subH2\n            ? [mergeLeaves(shift + SIZE, h1, n1, h2, n2)]\n            : subH1 < subH2 ? [n1, n2] : [n2, n1]);\n};\n\n/**\n    Update an entry in a collision list.\n\n    @param hash Hash of collision.\n    @param list Collision list.\n    @param op Update operation.\n    @param k Key to update.\n    @param size Size reference\n*/\nconst updateCollisionList = (h, list, op, k, size) => {\n    const len = list.length;\n    for (let i = 0; i < len; ++i) {\n        const child = list[i];\n        if (child.key === k) {\n            const value = child.value;\n            if (op.__hamt_delete_op) {\n                --size.value\n                return arraySpliceOut(i, list);\n            }\n            const newValue = op.__hamt_set_op ? op.value : op(value);\n            if (newValue === value)\n                return list;\n            return arrayUpdate(i, Leaf(h, k, newValue), list);\n        }\n    }\n\n    if (op.__hamt_delete_op)\n        return list;\n    const newValue = op.__hamt_set_op ? op.value : op();\n    ++size.value;\n    return arrayUpdate(len, Leaf(h, k, newValue), list);\n};\n\n/* Editing\n ******************************************************************************/\nconst Leaf__modify = function(shift, op, h, k, size) {\n    if (k === this.key) {\n        if (op.__hamt_delete_op) {\n            --size.value;\n            return undefined;\n        }\n        const currentValue = this.value;\n        const newValue = op.__hamt_set_op ? op.value : op(currentValue);\n        return newValue === currentValue ? this : Leaf(h, k, newValue);\n    }\n    if (op.__hamt_delete_op)\n        return this;\n    const newValue = op.__hamt_set_op ? op.value : op();\n    ++size.value;\n    return mergeLeaves(shift, this.hash, this, h, Leaf(h, k, newValue));\n};\n\nconst Collision__modify = function(shift, op, h, k, size) {\n    if (h === this.hash) {\n        const list = updateCollisionList(this.hash, this.children, op, k, size);\n        if (list === this.children)\n            return this;\n\n        return list.length > 1\n            ? Collision(this.hash, list)\n            : list[0]; // collapse single element collision list\n    }\n    if (op.__hamt_delete_op)\n        return this;\n    const newValue = op.__hamt_set_op ? op.value : op();\n    ++size.value;\n    return mergeLeaves(shift, this.hash, this, h, Leaf(h, k, newValue));\n};\n\nconst IndexedNode__modify = function(shift, op, h, k, size) {\n    const mask = this.mask;\n    const children = this.children;\n    const frag = hashFragment(shift, h);\n    const bit = toBitmap(frag);\n    const indx = fromBitmap(mask, bit);\n    const exists = mask & bit;\n    if (!exists) { // add\n        const newChild = empty__modify(shift + SIZE, op, h, k, size);\n        if (!newChild)\n            return this;\n        \n        return children.length >= MAX_INDEX_NODE\n            ? expand(frag, newChild, mask, children)\n            : IndexedNode(\n                mask | bit,\n                arraySpliceIn(indx, newChild, children));\n    }\n\n    const current = children[indx];\n    const newChild = current._modify(shift + SIZE, op, h, k, size);\n    if (current === newChild)\n        return this;\n\n    if (!newChild) { // remove\n        const bitmap = mask & ~bit;\n        if (!bitmap) \n            return undefined;\n        \n        return children.length === 2 && isLeaf(children[indx ^ 1])\n            ? children[indx ^ 1] // collapse\n            : IndexedNode(\n                bitmap,\n                arraySpliceOut(indx, children));\n    }\n\n    // modify\n    return op.__hamt_delete_op && children.length === 1 && isLeaf(newChild)\n        ? newChild // propagate collapse\n        : IndexedNode(\n            mask,\n            arrayUpdate(indx, newChild, children));\n};\n\nconst ArrayNode__modify = function(shift, op, h, k, size) {\n    const count = this.size;\n    const children = this.children;\n    const frag = hashFragment(shift, h);\n    const child = children[frag];\n    const newChild = child ? child._modify(shift + SIZE, op, h, k, size) : empty__modify(shift + SIZE, op, h, k, size);\n\n    if (child === newChild)\n        return this;\n\n    if (!child && newChild) { // add\n        return ArrayNode(\n            count + 1,\n            arrayUpdate(frag, newChild, children))\n    }\n    if (child && !newChild) { // remove\n        return count - 1 <= MIN_ARRAY_NODE\n            ? pack(count, frag, children)\n            : ArrayNode(\n                count - 1,\n                arrayUpdate(frag, undefined, children))\n    }\n\n    // modify\n    return ArrayNode(\n        count,\n        arrayUpdate(frag, newChild, children));\n};\n\nconst empty__modify = (_, op, h, k, size) => {\n    if (op.__hamt_delete_op)\n        return undefined;\n    const newValue = op.__hamt_set_op ? op.value : op();\n    ++size.value;\n    return Leaf(h, k, newValue);\n};\n\n/*\n ******************************************************************************/\nfunction Map(root, size) {\n    this.root = root;\n    this.size = size;\n};\n\nMap.prototype.__hamt_isMap = true;\n\nMap.prototype.setTree = function(root, size) {\n    return root === this.root ? this : new Map(root, size);\n};\n\n/* Queries\n ******************************************************************************/\n/**\n    Lookup the value for `key` in `map` using a custom `hash`.\n\n    Returns the value or `alt` if none.\n*/\nconst tryGetHash = hamt.tryGetHash = (alt, hash, key, map) => {\n    if (!map.root)\n        return alt;\n\n    let node = map.root;\n    let shift = 0;\n    while (true) switch (node.type) {\n        case LEAF:\n            {\n                return key === node.key ? node.value : alt;\n            }\n        case COLLISION:\n            {\n                if (hash === node.hash) {\n                    const children = node.children;\n                    for (let i = 0, len = children.length; i < len; ++i) {\n                        const child = children[i];\n                        if (key === child.key)\n                            return child.value;\n                    }\n                }\n                return alt;\n            }\n        case INDEX:\n            {\n                const frag = hashFragment(shift, hash);\n                const bit = toBitmap(frag);\n                if (node.mask & bit) {\n                    node = node.children[fromBitmap(node.mask, bit)];\n                    shift += SIZE;\n                    break;\n                }\n                return alt;\n            }\n        case ARRAY:\n            {\n                node = node.children[hashFragment(shift, hash)];\n                if (node) {\n                    shift += SIZE;\n                    break;\n                }\n                return alt;\n            }\n        default:\n            return alt;\n    }\n};\n\nMap.prototype.tryGetHash = function(alt, hash, key) {\n    return tryGetHash(alt, hash, key, this);\n};\n\n/**\n    Lookup the value for `key` in `map` using internal hash function.\n\n    @see `tryGetHash`\n*/\nconst tryGet = hamt.tryGet = (alt, key, map) =>\n    tryGetHash(alt, hash(key), key, map);\n\nMap.prototype.tryGet = function(alt, key) {\n    return tryGet(alt, key, this);\n};\n\n/**\n    Lookup the value for `key` in `map` using a custom `hash`.\n\n    Returns the value or `undefined` if none.\n*/\nconst getHash = hamt.getHash = (hash, key, map) =>\n    tryGetHash(undefined, hash, key, map);\n\nMap.prototype.getHash = function(hash, key) {\n    return getHash(hash, key, this);\n};\n\n/**\n    Lookup the value for `key` in `map` using internal hash function.\n\n    @see `get`\n*/\nconst get = hamt.get = (key, map) =>\n    tryGetHash(undefined, hash(key), key, map);\n\nMap.prototype.get = function(key, alt) {\n    return tryGet(alt, key, this);\n};\n\nconst nothing = ({});\n/**\n    Does an entry exist for `key` in `map`? Uses custom `hash`.\n*/\nconst hasHash = hamt.has = (hash, key, map) =>\n    tryGetHash(nothing, hash, key, map) !== nothing;\n\nMap.prototype.hasHash = function(hash, key) {\n    return hasHash(hash, key, this);\n};\n\n/**\n    Does an entry exist for `key` in `map`? Uses internal hash function.\n*/\nconst has = hamt.has = (key, map) =>\n    hasHash(hash(key), key, map);\n\nMap.prototype.has = function(key) {\n    return has(key, this);\n};\n\n/**\n    Empty node.\n*/\nhamt.empty = new Map(undefined, 0);\n\n/**\n    Is `value` a map?\n*/\nhamt.isMap = (value) =>\n    !!(value && value.__hamt_isMap);\n\n/**\n    Does `map` contain any elements?\n*/\nhamt.isEmpty = (map) =>\n    hamt.isMap(map) && !map.root;\n\nMap.prototype.isEmpty = function() {\n    return hamt.isEmpty(this);\n};\n\n\n/* Updates\n ******************************************************************************/\n/**\n    Alter the value stored for `key` in `map` using function `f` using\n    custom hash.\n\n    `f` is invoked with the current value for `k` if it exists,\n    or `defaultValue` if it is specified. Otherwise, `f` is invoked with no arguments\n    if no such value exists.\n\n    `modify` will always either update or insert a value into the map.\n\n    Returns a map with the modified value. Does not alter `map`.\n*/\nconst modifyHash = hamt.modifyHash = (f, hash, key, map) => {\n    const size = { value: map.size };\n    const newRoot = map.root ? map.root._modify(0, f, hash, key, size) : empty__modify(0, f, hash, key, size);\n    return map.setTree(newRoot, size.value);\n};\n\nMap.prototype.modifyHash = function(hash, key, f) {\n    return modifyHash(f, hash, key, this);\n};\n\n/**\n    Alter the value stored for `key` in `map` using function `f` using\n    internal hash function.\n\n    @see `modifyHash`\n*/\nconst modify = hamt.modify = (f, key, map) =>\n    modifyHash(f, hash(key), key, map);\n\nMap.prototype.modify = function(key, f) {\n    return modify(f, key, this);\n};\n\n/**\n    Same as `modifyHash`, but invokes `f` with `defaultValue` if no entry exists.\n\n    @see `modifyHash`\n*/\nconst modifyValueHash = hamt.modifyValueHash = (f, defaultValue, hash, key, map) =>\n    modifyHash(defaultValBind(f, defaultValue), hash, key, map);\n\nMap.prototype.modifyValueHash = function(hash, key, f, defaultValue) {\n    return modifyValueHash(f, defaultValue, hash, key, this);\n};\n\n/**\n    @see `modifyValueHash`\n*/\nconst modifyValue = hamt.modifyValue = (f, defaultValue, key, map) =>\n    modifyValueHash(f, defaultValue, hash(key), key, map);\n\nMap.prototype.modifyValue = function(key, f, defaultValue) {\n    return modifyValue(f, defaultValue, key, this);\n};\n\n/**\n    Store `value` for `key` in `map` using custom `hash`.\n\n    Returns a map with the modified value. Does not alter `map`.\n*/\nconst setHash = hamt.setHash = function(hash, key, value, map) {\n    return modifyHash({ __hamt_set_op: true, value: value }, hash, key, map);\n}\n\nMap.prototype.setHash = function(hash, key, value) {\n    return setHash(hash, key, value, this);\n};\n\n/**\n    Store `value` for `key` in `map` using internal hash function.\n\n    @see `setHash`\n*/\nconst set = hamt.set = (key, value, map) =>\n    setHash(hash(key), key, value, map);\n\nMap.prototype.set = function(key, value) {\n    return set(key, value, this);\n};\n\n/**\n    Remove the entry for `key` in `map`.\n\n    Returns a map with the value removed. Does not alter `map`.\n*/\nconst del = { __hamt_delete_op: true };\nconst removeHash = hamt.removeHash = (hash, key, map) =>\n    modifyHash(del, hash, key, map);\n\nMap.prototype.removeHash = Map.prototype.deleteHash = function(hash, key) {\n    return removeHash(hash, key, this);\n};\n\n/**\n    Remove the entry for `key` in `map` using internal hash function.\n\n    @see `removeHash`\n*/\nconst remove = hamt.remove = (key, map) =>\n    removeHash(hash(key), key, map);\n\nMap.prototype.remove = Map.prototype.delete = function(key) {\n    return remove(key, this);\n};\n\n/* Traversal\n ******************************************************************************/\n/**\n    Apply a continuation.\n*/\nconst appk = k =>\n    k && lazyVisitChildren(k.len, k.children, k.i, k.f, k.k);\n\n/**\n    Recursively visit all values stored in an array of nodes lazily.\n*/\nconst lazyVisitChildren = (len, children, i, f, k) => {\n    while (i < len) {\n        const child = children[i++];\n        if (child)\n            return lazyVisit(child, f, {len, children, i, f, k});\n    }\n    return appk(k);\n};\n\n/**\n    Recursively visit all values stored in `node` lazily.\n*/\nconst lazyVisit = (node, f, k) => {\n    if (node.type === LEAF) \n        return { value: f(node), rest: k };\n\n    const children = node.children;\n    return lazyVisitChildren(children.length, children, 0, f, k);\n};\n\nconst DONE = { done: true };\n\n/**\n    Javascript iterator over a map.\n*/\nfunction MapIterator(v) {\n    this.v = v;\n};\n\nMapIterator.prototype.next = function() {\n    if (!this.v)\n        return DONE;\n    const v0 = this.v;\n    this.v = appk(v0.rest);\n    return v0;\n};\n\nMapIterator.prototype[Symbol.iterator] = function() {\n    return this;\n};\n\n/**\n    Lazily visit each value in map with function `f`.\n*/\nconst visit = (map, f) =>\n    new MapIterator(map.root ? lazyVisit(map.root, f) : undefined);\n\n/**\n    Get a Javascript iterator of `map`.\n\n    Iterates over `[key, value]` arrays.\n*/\nconst buildPairs = (x) => [x.key, x.value];\nconst entries = hamt.entries = (map) =>\n    visit(map, buildPairs);\n\nMap.prototype.entries = Map.prototype[Symbol.iterator] = function() {\n    return entries(this);\n};\n\n/**\n    Get array of all keys in `map`.\n\n    Order is not guaranteed.\n*/\nconst buildKeys = (x) => x.key;\nconst keys = hamt.keys = (map) =>\n    visit(map, buildKeys);\n\nMap.prototype.keys = function() { return keys(this); }\n\n/**\n    Get array of all values in `map`.\n\n    Order is not guaranteed, duplicates are preserved.\n*/\nconst buildValues = x => x.value;\nconst values = hamt.values = Map.prototype.values = map =>\n    visit(map, buildValues);\n\nMap.prototype.values = function() {\n    return values(this);\n};\n\n/* Fold\n ******************************************************************************/\n/**\n    Visit every entry in the map, aggregating data.\n\n    Order of nodes is not guaranteed.\n\n    @param f Function mapping accumulated value, value, and key to new value.\n    @param z Starting value.\n    @param m HAMT\n*/\nconst fold = hamt.fold = (f, z, m) => {\n    const root = m.root;\n    if (!root)\n        return z;\n\n    if (root.type === LEAF)\n        return f(z, root.value, root.key);\n\n    for (let toVisit = root; toVisit; ) {\n        const children = toVisit.children;\n        toVisit = toVisit.next;\n        for (let i = 0, len = children.length; i < len;) {\n            const child = children[i++];\n            if (child) {\n                if (child.type === LEAF)\n                    z = f(z, child.value, child.key);\n                else\n                    toVisit = { children: child.children, next: toVisit } \n            }\n        }\n    }\n    return z;\n};\n\nMap.prototype.fold = function(f, z) {\n    return fold(f, z, this);\n};\n\n/**\n    Visit every entry in the map, aggregating data.\n\n    Order of nodes is not guaranteed.\n\n    @param f Function invoked with value and key\n    @param map HAMT\n*/\nconst forEach = hamt.forEach = (f, map) =>\n    fold((_, value, key) => f(value, key, map), null, map);\n\nMap.prototype.forEach = function(f) {\n    return forEach(f, this);\n};\n\n/* Aggregate\n ******************************************************************************/\n/**\n    Get the number of entries in `map`.\n*/\nconst count = hamt.count = (map) => map.size;\n\nMap.prototype.count = function() {\n    return count(this);\n};\n\n/* Export\n ******************************************************************************/\nif (typeof module !== 'undefined' && module.exports) {\n    module.exports = hamt;\n} else if (typeof define === 'function' && define.amd) {\n    define('hamt', [], () => hamt);\n} else {\n    this.hamt = hamt;\n}\n"]}