maps

The map of pairs; a later pair for a key replaces an earlier one, as in a series of puts.

The map of pairs, combining the values of a repeated key with resolve(key, existing, incoming).

The map from each of keys to f(key).

The map from keys[i] to values[i]; extra keys or values are ignored, and a repeated key takes its last value.

The map from key(x) to x for each element; a later element with the same key wins.

The elements of xs grouped by key(x), each group in the order of xs.

The same entries as a HashMap.

The same entries as an ordered Map.

The value for k, or default when k is missing.

Whether m has no entries.

The smallest key whose value equals v.

The first entry, in key order, for which f(key, value) holds.

The keys, in order, whose value satisfies f.

Whether every key of ks is in m.

Whether some key of ks is in m.

The entry with the smallest value (the smallest key among equal values).

The entry with the largest value (the smallest key among equal values).

The entries of both maps; for a key in both, the value from b wins (like Python's a | b).

The entries of both maps; for a key in both, the value from a wins (lodash defaults).

The entries of both maps; for a key in both, the value is resolve(key, from_a, from_b).

The entries of all maps, later maps winning; the empty map for an empty list.

The entries of all maps, folding repeated keys from left to right with resolve(key, acc, next).

The entries of a whose key is also in b, with a's values.

The entries of a whose key is not in b.

The map from each value to its key. When several keys share a value the largest key wins, because entries are visited in key order and later ones replace earlier ones.

The map from each value to its key, combining keys that share a value with resolve(value, existing_key, next_key) (keys arrive in ascending order).

The map from each value to all keys that have it, in ascending key order.

The entries whose key satisfies f.

The entries whose value satisfies f.

The entries for which f(key, value) holds.

The entries that satisfy f(key, value) and the ones that don't.

Every value replaced by f(value).

Every value replaced by f(key, value).

Every key replaced by f(key). When two keys map to the same new key, the value of the larger original key wins; use map_keys_with to choose.

Every key replaced by f(key), combining colliding values with resolve(new_key, existing, incoming) in ascending order of the original keys.

Every entry replaced by the pair f(key, value); on a key collision the later entry, in the original key order, wins.

The entries for which f(key, value) gives some(w), with the value w.

Only the entries whose key is in ks.

The entries whose key is not in ks.

The map with the entry of from moved to the key to, replacing any entry already at to. Unchanged when from is missing or equal to to.

The value at k replaced by f(value); unchanged when k is missing.

The value at k replaced by f(value), or removed when f gives none; unchanged when k is missing.

f(value) at k when k is present, else init (Java's Map.merge).

The entry at k decided by f(current): some(v) stores v, none removes it (Haskell's alter, Java's compute).

The map with v at k only when k is missing (Python's setdefault, without the read).

How many times each element occurs.

The count at k raised by by (which may be negative); a missing key counts as 0, and a key whose count reaches 0 stays in the map.

The counts of both counters added key by key.

The counts of a minus those of b, keeping only keys whose result is positive (Python's Counter - Counter).

The n entries with the highest counts, highest first; equal counts are in key order. Fewer when the counter is smaller; n 0 gives [].

The n entries with the lowest counts, lowest first; equal counts are in key order.

The sum of all counts.

The multimap with v appended to the list at k.

The values at k, [] when missing.

The multimap with every occurrence of v removed from the list at k; the key goes when its list becomes empty.

The multimap of pairs, each key's values in the order given.

Every (key, value) pair of the multimap, in key order and then list order.

The number of values in the multimap, over all keys.

Whether both maps have exactly the same keys.

Whether both maps have the same keys and eq holds for the values at each key.

Whether every entry of a is also in b with an equal value.

The difference between two maps: entries only in the new map, entries only in the old one, and keys in both whose values differ, as (old, new).

What changed from old to new_map.

Whether a diff has no changes.

m with a diff applied: removed keys go, added and changed keys take their new values. So apply_diff(a, diff_maps(a, b)) == b. Keys of removed and changed are applied whatever their current value is.

A JSON value. Integers that fit Int are JInt; numbers with a fraction or an exponent are JNum; a number that fits neither (an integer beyond 64 bits, or a float that overflows) is JBig, which keeps its exact text. Object keys are kept sorted (a Map), so objects compare and print the same whatever order their keys were written in. The functions below recurse on nesting and are tested to 4096 levels in both tiers.

Where and why JSON text failed to parse: offset counts characters from 0, line and column count from 1.

One step of a path: an object key, or an array position.

A difference found by diff_values, at a path from the root.

The deepest nesting of arrays and objects parse_json accepts.

An object from key-value pairs; a repeated key takes its last value.

The kind of a value: "null", "boolean", "number" (JInt, JNum and JBig), "string", "array" or "object".

Whether the value is null.

The boolean, if the value is one.

The integer, if the value is a JInt, or a JNum with no fraction within the Int range.

The number as an F64, for any number; a JBig integer is rounded and an overflowing one is none.

The string, if the value is one.

The elements, if the value is an array.

The fields, if the value is an object.

The value of JSON text, strictly as RFC 8259 says: one value with optional whitespace around it, no comments, no trailing commas, no single quotes, no leading zeros or +, no NaN, and strings with valid escapes and no raw control characters; a \u escape of a lone surrogate is an error. A repeated object key keeps its last value. Nesting deeper than default_max_depth() is an error.

parse_json with a nesting limit: arrays and objects may nest max_depth deep (0 allows only scalars).

The error as one line: "line 1, column 5: expected ':' after an object key".

The value as compact JSON text: no spaces, object keys in sorted order, strings escaped as RFC 8259 requires (", \, and control characters; other characters are written as they are). A JNum that is not finite is written null; a JBig is written as its text.

The value as indented JSON text: one element or field per line, indent spaces per level, ": " after keys, and [] and {} for empty containers. indent 0 still breaks lines.

The string as a JSON string literal, with its quotes.

The steps of a dotted path such as a.b[0].c or users[2]["first name"]: names separated by dots, [n] for an array position, and ["..."] (with \" and \\ escapes) for a key that has dots, brackets or quotes in it. "" is the root (no steps). A name can't be empty (a..b is an error) and a position can't be negative or have a leading zero.

A path as text that parse_path reads back: plain names joined with dots, [n] for positions, and ["..."] for empty keys and keys with ., [, ] or ".

The steps of an RFC 6901 JSON Pointer such as /a/b/0: "" is the whole document, every other pointer starts with /, and ~1 and ~0 in a step stand for / and ~. Every step is a Key; on an array a key that is a position (0, 12, not 01) indexes it, and - means the end (for set_in).

A path as an RFC 6901 JSON Pointer, escaping ~ as ~0 and / as ~1.

The value at a path, or none when a step is missing. A Key step reads an object field, or an array element when the key is a position; an At step reads only array elements.

Whether there is a value at the path (a null there counts).

The value with x stored at a path, or why it can't be. Missing objects along the way are created (and a null is replaced by one), as an object for a Key step and an array for an At step. On an array the position must be at most its length (the length, or the key -, appends), so arrays never get holes. A step into a boolean, number or string, a key that is not a position on an array, or an At step on an object is an error that names the path.

The value without whatever is at a path: an object field is removed and an array element is taken out (later elements move down). Unchanged when the path is missing or segs is empty.

The value with the value at a path replaced by f(old); unchanged when the path is missing.

get_in with a dotted path; none also when the path doesn't parse.

has_in with a dotted path; false also when the path doesn't parse.

set_in with a dotted path; a path that doesn't parse is an error too.

delete_in with a dotted path; a path that doesn't parse is an error.

get_in with a JSON Pointer; none also when the pointer doesn't parse.

has_in with a JSON Pointer.

set_in with a JSON Pointer; - as an array step appends.

delete_in with a JSON Pointer.

b merged into a: where both are objects their fields merge recursively, anywhere else (arrays included) the value from b replaces the one from a.

target with an RFC 7386 JSON Merge Patch applied: an object patch sets each of its fields recursively and removes the fields it sets to null; any other patch replaces the target.

The RFC 7386 merge patch that turns source into target, so merge_patch(source, make_merge_patch(source, target)) == target whenever target has no null inside an object (merge patches can't set a field to null). Unchanged fields are left out; arrays are replaced whole.

The leaves of a value keyed by their path_text: scalars, and empty arrays and objects (so unflatten_value can restore them). A scalar or empty root is the single key "".

The value whose leaves are m, the inverse of flatten_value: each key is parsed with parse_path and set with set_in, in path order (an empty map gives an empty object). Errors when a key doesn't parse, when two keys conflict (a and a.b), or when array positions skip one.

The differences from a to b, in path order: fields and trailing array elements only in b are Added, only in a Removed, and other values that differ Replaced (a change of kind, or of a scalar). Arrays are compared position by position, so an insertion shows as replacements plus an addition. Equal values give [].

v with changes applied, as diff_values produces them: Replaced and Added in order, then Removed from the last to the first so array positions stay valid. So apply_changes(a, diff_values(a, b)) == ok(b). Errors when a path can't be set.