extra-map.min

A map is a collection of key-value pairs, with unique keys.
:package: NPM, :smiley_cat: GitHub, :running: RunKit, :vhs: Asciinema, :moon: Minified, :scroll: Files, :newspaper: JSDoc, :blue_book: Wiki.

All functions except from*() take Map as 1st parameter. Some names are borrowed from Haskell, Python, Java, Processing.

Methods look like:

• swap(): doesn't modify the map itself (pure).
• swap$(): modifies the map itself (update).

Methods as separate packages:

• @extra-map/swap: use rollup to bundle this es module.
• @extra-map/swap.min: use in browser (browserify, uglify-js).

Stability: Experimental.

This is browserified, minified version of extra-map.
It is exported as global variable map.
CDN: unpkg, jsDelivr.

const map = require("extra-map");
// import * as map from "extra-map";
// import * as map from "https://unpkg.com/extra-map@2.1.0/index.mjs"; (deno)

var x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
map.swap(x, "a", "b");
// Map(4) { "a" => 2, "b" => 1, "c" => 3, "d" => 4 }

var x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
var y = new Map([["b", 20], ["c", 30], ["e", 50]]);
map.intersection(x, y);
// Map(2) { "b" => 2, "c" => 3 }

var x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", -2]]);
map.searchAll(x, v => Math.abs(v) === 2);
// [ "b", "d" ]              ^                   ^

var x = new Map([["a", 1], ["b", 2], ["c", 3]]);
[...map.subsets(x)];
// [
//   Map(0) {},
//   Map(1) { "a" => 1 },
//   Map(1) { "b" => 2 },
//   Map(2) { "a" => 1, "b" => 2 },
//   Map(1) { "c" => 3 },
//   Map(2) { "a" => 1, "c" => 3 },
//   Map(2) { "b" => 2, "c" => 3 },
//   Map(3) { "a" => 1, "b" => 2, "c" => 3 }
// ]

Index

Method	Action
is	Checks if value is map.
get	Gets value at key.
set	Sets value at key.
remove	Deletes an entry.
swap	Exchanges two values.
size	Gets size of map.
head	Gets first entry.
take	Keeps first n entries only.
shift	Removes first entry.
from	Creates map from entries.
concat	Appends entries from maps, preferring last.
flat	Flattens nested map to given depth.
chunk	Breaks map into chunks of given size.
filterAt	Gets map with given keys.
map	Updates values based on map function.
filter	Keeps entries which pass a test.
reduce	Reduces values to a single value.
range	Finds smallest and largest entries.
count	Counts values which satisfy a test.
partition	Segregates values by test result.
cartesianProduct	Lists cartesian product of maps.
some	Checks if any value satisfies a test.
zip	Combines matching entries from maps.
union	Gives entries present in any map.
intersection	Gives entries present in both maps.
difference	Gives entries of map not present in another.
symmetricDifference	Gives entries not present in both maps.
isDisjoint	Checks if maps have no common keys.
key	Picks an arbitrary key.
value	Picks an arbitrary value.
entry	Picks an arbitrary entry.
subset	Picks an arbitrary subset.
isEmpty	Checks if map is empty.
isEqual	Checks if two maps are equal.
compare	Compares two maps.
find	Finds a value passing a test.
search	Finds key of an entry passing a test.
scanWhile	Finds key of first entry not passing a test.