A collection of functions for operating upon Entries.

Entries is a list of key-value pairs, with unique keys. This package
includes common functions related to querying **about** entries, **generating**
them, **comparing** one with another, finding their **size**, **adding** and
**removing** entries, obtaining its **properties**, getting a **part** of it,
getting a **subset** entries in it, **finding** an entry in it, performing
**functional** operations, **manipulating** it in various ways, **combining**
together entries or its sub-entries, of performing **set operations** upon it.

All functions except `fromLists()`

take entries as 1st parameter, and expect it
to be iterable. It does not need to be an array. **Entries** are returned
by `Array`

, `Object`

, `Set`

, `Map`

.

This package is available in *Node.js* and *Web* formats. The web format
is exposed as `extra_entries`

standalone variable and can be loaded from
jsDelivr CDN.

Stability: Experimental.

```
const entries = require('extra-entries');
// import * as entries from "extra-entries";
// import * as entries from "https://unpkg.com/extra-entries/index.mjs"; (deno)
var x = [['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]];
[...entries.filter(x, v => v % 2 === 1)];
// → [ [ 'a', 1 ], [ 'c', 3 ], [ 'e', 5 ] ]
var x = [['a', 1], ['b', 2], ['c', -3], ['d', -4]];
entries.some(x, v => v > 10);
// → false
var x = [['a', 1], ['b', 2], ['c', -3], ['d', -4]];
entries.min(x);
// → -4
var x = [['a', 1], ['b', 2], ['c', 3]];
[...entries.subsets(x)].map(a => [...a]);
// → [
// → [],
// → [ [ 'a', 1 ] ],
// → [ [ 'b', 2 ] ],
// → [ [ 'a', 1 ], [ 'b', 2 ] ],
// → [ [ 'c', 3 ] ],
// → [ [ 'a', 1 ], [ 'c', 3 ] ],
// → [ [ 'b', 2 ], [ 'c', 3 ] ],
// → [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ] ]
// → ]
```

## Index

Property | Description |
---|---|

is | Check if value is an iterable. |

keys | List all keys. |

values | List all values. |

fromLists | Convert lists to entries. |

compare | Compare two entries. |

isEqual | Check if two entries are equal. |

size | Find the length of an iterable. |

isEmpty | Check if an iterable is empty. |

get | Get value at key. |

getAll | Get values at keys. |

getPath | Get value at path in nested entries. |

hasPath | Check if nested entries has a path. |

set | Set value at key. |

swap | Exchange two values. |

remove | Remove value at key. |

count | Count values which satisfy a test. |

countAs | Count occurrences of values. |

min | Find smallest value. |

minEntry | Find smallest entry. |

max | Find largest value. |

maxEntry | Find largest entry. |

range | Find smallest and largest values. |

rangeEntries | Find smallest and largest entries. |

head | Get first value. |

tail | Get values except first. |

take | Keep first n values only. |

drop | Discard first n values only. |

subsets | List all possible subsets. |

randomKey | Pick an arbitrary key. |

randomEntry | Pick an arbitrary entry. |

randomSubset | Pick an arbitrary subset. |

has | Check if entries has a key. |

hasValue | Check if entries has a value. |

hasEntry | Check if entries has an entry. |

hasSubset | Check if entries has a subset. |

find | Find first value passing a test (default order). |

findAll | Find values passing a test. |

search | Finds key of an entry passing a test. |

searchAll | Find keys of entries passing a test. |

searchValue | Find a key with given value. |

searchValueAll | Finds keys with given value. |

forEach | Call a function for each value. |

some | Check if any value satisfies a test. |

every | Check if all values satisfy a test. |

map | Transform values of entries. |

reduce | Reduce values of entries to a single value. |

filter | Keep entries which pass a test. |

filterAt | Keep entries with given keys. |

reject | Discard entries which pass a test. |

rejectAt | Discard entries with given keys. |

flat | Flatten nested entries to given depth. |

flatMap | Flatten nested entries, based on map function. |

zip | Combine matching entries from all entries. |

partition | Segregate values by test result. |

partitionAs | Segregate entries by similarity. |

chunk | Break entries into chunks of given size. |

concat | Append entries from all entries, preferring last. |

join | Join entries together into a string. |

isDisjoint | Check if entries have no common keys. |

unionKeys | Obtain keys present in any entries. |

union | Obtain entries present in any entries. |

intersection | Obtain entries present in both entries. |

difference | Obtain entries not present in another entries. |

symmetricDifference | Obtain entries not present in both entries. |

randomValue | Pick an arbitrary value. |