mootable / hashmap Goto Github PK

typescript support ?

We want:
ES Module untranspiled
Common JS for Node, minimaly untranspiled
Support for 99.5% of browsers, heavily transpiled Universal Module (UMD)
Support for browsers < 2 years., partialy transpiled Universal Module (UMD)

one for 1.1

Hash_array_mapped_trie

Map, Set and Array use sameValueEquals and so should we
https://262.ecma-international.org/6.0/#sec-samevaluezero

It wasn't clear, neither from documentation nor from code and neither from automatic tests, what methods of access support the order-preserving iteration.
Consider also the explicit reordering, such as https://docs.rs/indexmap/1.6.1/indexmap/map/struct.IndexMap.html#method.sort_keys and https://docs.rs/indexmap/1.6.1/indexmap/map/struct.IndexMap.html#method.sort_by

The docs mention using HAMT and trie, but I couldn't verify it from a cursory look at the code. IMHO there should be a mapping between the high-level documentation, such as the mention of HAMT, and the relevant code. Imagine going to Google Maps, zooming in and seeing entirely different location. The lack of connection or mapping between the different layers of documentation is similarly disconcerting. In order to be reusable ( https://youtu.be/pW-SOdj4Kkk ) software needs to allow for gradual zooming in and our, from architectural overview to code and back, IMHO.

We are aiming for Hash array mapped trie, although we need a touch of rework to get there.

Test coverage, on original source, and transpiled artifacts.

Iterate over Buckets better so that we can support streaming/functional programming, without preloading arrays.

I prefer the language semantics in Rust for this use case, than the Javaish ones.

Worth adding an iterable.

To make it easier to unit test and provide some more control on exports

Having async access hashmap, with effective readwrite locks, might make it more performant.

use the overrides function to allow us to determine whether a key should also be overwritten, default false.
With push and unshift methods we may want to default this to true. To be thought through and decided.

Makes most sense for LinkedHashMaps, but will also work against HashMaps as they do have an order, just by hash,

Sort the map in place

I want to call map.filter(someFilterFunc).map(someMappingFunction).reduce(someReducer) etc.

Given a map (first),
When I call concat on it with another map (second)
Then I get a new map (third) back with the contents of both.
And if ordered, then the order of third is one and then second following.