(std orderedmap)

Reference

Overview

Persistent sorted map implemented as a B-tree in key order, with builder and transient.

(import (std orderedmap))

(def m (list->orderedmap (list (Tuple "pear" 3) (Tuple "apple" 1) (Tuple "fig" 2))))
(orderedmap-ref m "fig")                ; 2
(->list (orderedmap-keys m))             ; ("apple" "fig" "pear")
(orderedmap-min m)                      ; (Some (Tuple "apple" 1))
(orderedmap-successor m "banana")       ; (Some (Tuple "fig" 2))
(orderedmap-ref (orderedmap-set m "fig" 20) "fig")   ; 20
(orderedmap-ref m "fig")                ; 2, m is unchanged

An (OrderedMap k v) is an immutable, persistent sorted map. Updates return a new map sharing untouched nodes with the original. Implemented as a B-tree (OrderedMap.OrderedMap in the runtime). Lookup, insertion, and deletion operations run in O(log n) time.

Key ordering. Constructors (orderedmap-empty, seq->orderedmap, list->orderedmap, vec->orderedmap, map->orderedmap, orderedmapbuilder-empty, transientorderedmap-empty, and the ordered-mapping collector) require an Ord instance for key type %k. Entries are ordered according to compare. Keys considered equal by compare overwrite existing entries. Derived maps retain the source map’s ordering comparer.

Order guarantees. All traversals, conversions, and callbacks visit entries in ascending key order. Provides efficient range and boundary operations: orderedmap-min, orderedmap-max, orderedmap-successor, orderedmap-predecessor, and range slices (orderedmap-range, orderedmap-from, orderedmap-until). If key ordering is not required, use Map, which requires only Eq.

Entry representations. Callbacks for orderedmap-fold, orderedmap-filter, and orderedmap-for-each receive keys and values as separate arguments. Functions returning single entries represent them as (Tuple k v) pairs (e.g. in orderedmap->list, orderedmap->seq, orderedmap-min, and Iterable loops).

Batch mutations and construction. An OrderedMapBuilder collects entries, sorts them, and constructs the tree in a single pass. A TransientOrderedMap mutates tree nodes in place and converts to a persistent map in O(1) time. Both outperform repeated calls to orderedmap-set for bulk updates.

Traits. Implements Iterable, Collection, Refable, Settable, Addable, Eq, Written and Displayed. Two maps are = if they contain identical keys with equal values. Calling add on a map takes a (Tuple k v) and overwrites any existing association for key k.

Patterns. The prelude’s (Has key p) pattern matches an ordered map containing key, matching pattern p against its value, because the map is Refable.

See also: OrderedMap, orderedmap-empty, orderedmap-ref, orderedmap-set, orderedmap-min, orderedmap-range, OrderedMapBuilder, TransientOrderedMap

Reference

Types

Functions

Types

OrderedMap

type alias ↑ Types

Persistent map sorted by key.

%k
The key type. Requires an Ord instance.
%v
The value type.
(def m (orderedmap-set (orderedmap-set (orderedmap-empty) 2 "two") 1 "one"))
(->list (orderedmap-keys m))   ; (1 2)
(ref m 2)                         ; "two"

See also: orderedmap-empty, orderedmap-ref, orderedmap-set, orderedmap-remove, OrderedMapBuilder, TransientOrderedMap, OrderedMapping

OrderedMapBuilder

type alias ↑ Types

Mutable buffer for constructing an ordered map in a single pass.

%k
The key type.
%v
The value type.
(def b (orderedmapbuilder-empty))
(orderedmapbuilder-add! b "b" 1)
(orderedmapbuilder-add! b "a" 2)
(orderedmapbuilder-add! b "b" 3)
(orderedmapbuilder-length b)          ; 3
(orderedmapbuilder->orderedmap b)     ; #map((a 2) (b 3))

Appends entries to a flat buffer. Calling orderedmapbuilder->orderedmap sorts entries and constructs the B-tree in a single pass. If entries arrive in sorted order, sorting is skipped. Duplicate keys retain the last value added. Builders do not support lookups or removals; use TransientOrderedMap for mutable map operations. Implements Addable! with a pair.

See also: orderedmapbuilder-empty, orderedmapbuilder-add!, orderedmapbuilder->orderedmap, TransientOrderedMap

TransientOrderedMap

type alias ↑ Types

Mutable transient ordered map for batch in-place updates.

%k
The key type.
%v
The value type.
(def t (orderedmap->transientorderedmap m))
(transientorderedmap-set! t "c" 3)
(transientorderedmap-remove! t "a")
(transientorderedmap->orderedmap t)

Provides in-place mutators mirroring persistent orderedmap- functions. Mutates owned tree nodes in place without copying. Calling transientorderedmap->orderedmap yields a persistent map in O(1) time. The transient remains usable afterward; subsequent writes perform copy-on-write on shared nodes. Implements Addable! with a pair, and Refable.

See also: orderedmap->transientorderedmap, transientorderedmap->orderedmap, transientorderedmap-set!, OrderedMapBuilder

OrderedMapCursor

type alias ↑ Types

Cursor for iterating over an ordered map.

%k
The key type of the map.
%v
The value type of the map.

Used by the Iterable implementation of OrderedMap to iterate in ascending key order. Immutable cursor value: advancing produces a new cursor without mutating the previous one.

See also: OrderedMap

OrderedMapping

union ↑ Types

Collector for gathering entries into an ordered map via loop.

%k
The key type. Requires an Ord instance.
%v
The value type.
ordered-mapping
The collector constructor, accepting (Tuple k v) pairs.
(loop (:for (k v) pairs)
      (:acc m (ordered-mapping (Tuple k (* v 2)))))

Collects entries through an OrderedMapBuilder. Duplicate keys retain the last value collected.

See also: list->orderedmap, OrderedMapBuilder

Functions

orderedmap-empty

function ↑ Functions

(: orderedmap-empty (-> (OrderedMap %k %v)))
(orderedmap-empty)

Creates an empty ordered map.

returns
An empty map ordered by the key type's Ord instance.

See also: orderedmap-clear, seq->orderedmap, list->orderedmap

orderedmap-ref

function ↑ Functions

(: orderedmap-ref (-> (OrderedMap %k %v) %k %v))

Returns the value associated with a key, raising KeyNotFoundException if missing.

m
The map.
k
The key to look up.
returns
The value associated with k.
raises System.Collections.Generic.KeyNotFoundException
When k is not in the map.

See also: orderedmap-ref-or, orderedmap-try-ref, ref

orderedmap-ref-or

function ↑ Functions

(: orderedmap-ref-or (-> (OrderedMap %k %v) %k %v %v))

Returns the value for a key, or a default fallback if absent.

m
The map.
k
The key to look up.
default
Fallback value returned if k is absent.
returns
The value associated with k, or default.

See also: orderedmap-ref, orderedmap-try-ref

orderedmap-try-ref

function ↑ Functions

(: orderedmap-try-ref (-> (OrderedMap %k %v) %k (out %v) (Option %v)))

Returns (Some value) for a key, or None if absent.

m
The map.
k
The key to look up.
returns
(Some v) if k is present, otherwise None.

See also: orderedmap-ref, orderedmap-ref-or, try-ref, Has

orderedmap-set

function ↑ Functions

(: orderedmap-set (-> (OrderedMap %k %v) %k %v (OrderedMap %k %v)))

Returns a new map associating a key with a value.

m
The source map (unmodified).
k
The key.
v
The value.
returns
A new map with k mapped to v.

See also: orderedmap-set-all, orderedmap-remove, ref-set

orderedmap-set-all

function ↑ Functions

(: orderedmap-set-all (-> (OrderedMap %k %v) (Seq (Tuple %k %v)) (OrderedMap %k %v)))

Returns a new map with all entries of a sequence added.

m
The source map (unmodified).
kvs
Sequence of (Tuple key value) pairs. Duplicate keys keep the last value.
returns
A new map containing all pairs.

Executes through a transient, copying tree nodes once rather than once per entry.

See also: orderedmap-set, orderedmap-merge, transientorderedmap-set-all!

orderedmap-remove

function ↑ Functions

(: orderedmap-remove (-> (OrderedMap %k %v) %k (OrderedMap %k %v)))

Returns a new map with a key removed.

m
The source map (unmodified).
k
The key to remove.
returns
A new map without k. If k was absent, returns m directly.

See also: orderedmap-remove-all, orderedmap-filter

orderedmap-remove-all

function ↑ Functions

(: orderedmap-remove-all (-> (OrderedMap %k %v) (Seq %k) (OrderedMap %k %v)))

Returns a new map with all specified keys removed.

m
The source map (unmodified).
ks
Sequence of keys to remove.
returns
A new map without those keys.

Executes through a transient, copying tree nodes once rather than once per key.

See also: orderedmap-remove, transientorderedmap-remove-all!

orderedmap-contains?

function ↑ Functions

(: orderedmap-contains? (-> (OrderedMap %k %v) %k bool))

Tests if a key exists in the map.

m
The map.
k
The key to locate.
returns
#t if k is present, otherwise #f.

See also: orderedmap-has-key?, orderedmap-try-ref

orderedmap-has-key?

function ↑ Functions

(: orderedmap-has-key? (-> (OrderedMap %k %v) %k bool))
(orderedmap-has-key? m key)

Tests if a key exists in the map.

m
The map.
key
The key to locate.
returns
#t if key is present, otherwise #f.

Alias for orderedmap-contains?.

See also: orderedmap-contains?

orderedmap-length

function ↑ Functions

(: orderedmap-length (-> (OrderedMap %k %v) int))

Returns the number of entries in the map.

m
The map.
returns
The count of key-value pairs.

See also: orderedmap-empty?, length

orderedmap-empty?

function ↑ Functions

(: orderedmap-empty? (-> (OrderedMap %k %v) bool))

Tests if the map contains no entries.

m
The map.
returns
#t if empty, otherwise #f.

See also: orderedmap-length, empty?

orderedmap-clear

function ↑ Functions

(: orderedmap-clear (-> (OrderedMap %k %v) (OrderedMap %k %v)))

Returns an empty map retaining the key comparer of the source map.

m
The map whose order is preserved.
returns
An empty persistent map.

See also: orderedmap-empty, orderedmap-remove-all

orderedmap-keys

function ↑ Functions

(: orderedmap-keys (-> (OrderedMap %k %v) (Seq %k)))

Returns a sequence of all keys in ascending order.

m
The map.
returns
A sequence of keys in ascending order.

See also: orderedmap-values, orderedmap->seq

orderedmap-values

function ↑ Functions

(: orderedmap-values (-> (OrderedMap %k %v) (Seq %v)))

Returns a sequence of all values in ascending key order.

m
The map.
returns
A sequence of values ordered by their corresponding keys.

See also: orderedmap-keys, orderedmap->seq

orderedmap-merge

function ↑ Functions

(: orderedmap-merge (-> (OrderedMap %k %v) (OrderedMap %k %v) (OrderedMap %k %v)))

Merges two maps, with the second map’s values winning on collision.

m
Base map.
other
Map overlaid onto base map.
returns
A new map containing entries from both maps.

Entries from other are inserted into m using a transient. If either map is empty, the other map is returned directly.

See also: orderedmap-merge-with, orderedmap-set-all

orderedmap-merge-with

function ↑ Functions

(: orderedmap-merge-with (-> (-> %k %v %v %v) (OrderedMap %k %v) (OrderedMap %k %v) (OrderedMap %k %v)))

Merges two maps using a resolving function for colliding keys.

f
Resolution function called as (f key left right), returning resolved value.
m
Left map.
other
Right map.
returns
A new map containing entries from both maps.
(orderedmap-merge-with (fun (k a b) (+ a b))
                       (list->orderedmap (list (Tuple "x" 1) (Tuple "y" 2)))
                       (list->orderedmap (list (Tuple "y" 10))))   ; x 1, y 12

Retains the key ordering of m.

See also: orderedmap-merge

orderedmap-min

function ↑ Functions

(: orderedmap-min (-> (OrderedMap %k %v) (out %k) (out %v) (Option (Tuple %k %v))))

Returns the entry with the minimum key, or None if empty.

m
The map.
returns
(Some (Tuple key value)) for the minimum entry, or None if empty.

See also: orderedmap-max, orderedmap-successor

orderedmap-max

function ↑ Functions

(: orderedmap-max (-> (OrderedMap %k %v) (out %k) (out %v) (Option (Tuple %k %v))))

Returns the entry with the maximum key, or None if empty.

m
The map.
returns
(Some (Tuple key value)) for the maximum entry, or None if empty.

See also: orderedmap-min, orderedmap-predecessor

orderedmap-successor

function ↑ Functions

(: orderedmap-successor (-> (OrderedMap %k %v) %k (out %k) (out %v) (Option (Tuple %k %v))))

Returns the entry with the smallest key strictly greater than k, or None.

m
The map.
k
Search key (need not exist in map).
returns
(Some (Tuple key value)) for the next greater key, or None.
(def m (list->orderedmap (list (Tuple 10 "a") (Tuple 20 "b"))))
(orderedmap-successor m 10)   ; (Some (Tuple 20 "b"))
(orderedmap-successor m 15)   ; (Some (Tuple 20 "b"))
(orderedmap-successor m 20)   ; None

See also: orderedmap-predecessor, orderedmap-from

orderedmap-predecessor

function ↑ Functions

(: orderedmap-predecessor (-> (OrderedMap %k %v) %k (out %k) (out %v) (Option (Tuple %k %v))))

Returns the entry with the largest key strictly less than k, or None.

m
The map.
k
Search key (need not exist in map).
returns
(Some (Tuple key value)) for the next smaller key, or None.

See also: orderedmap-successor, orderedmap-until

orderedmap-range

function ↑ Functions

(: orderedmap-range (-> (OrderedMap %k %v) %k %k (Seq (Tuple %k %v))))

Returns a sequence of entries with keys in [lo, hi] in ascending order.

m
The map.
lo
Lower bound key (inclusive). Need not exist in map.
hi
Upper bound key (inclusive). Need not exist in map.
returns
A lazy sequence of (Tuple key value) pairs in ascending key order.
(orderedmap-range log start-time end-time)   ; entries in a time window

Lazy: descends the B-tree to lo once and advances sequentially, so slicing a subset runs in time proportional to the range slice size.

See also: orderedmap-from, orderedmap-until

orderedmap-from

function ↑ Functions

(: orderedmap-from (-> (OrderedMap %k %v) %k (Seq (Tuple %k %v))))

Returns a sequence of entries with keys >= lo in ascending order.

m
The map.
lo
Lower bound key (inclusive). Need not exist in map.
returns
A lazy sequence of (Tuple key value) pairs for keys >= lo.

Lazy, matching orderedmap-range.

See also: orderedmap-range, orderedmap-until, orderedmap-successor

orderedmap-until

function ↑ Functions

(: orderedmap-until (-> (OrderedMap %k %v) %k (Seq (Tuple %k %v))))

Returns a sequence of entries with keys <= hi in ascending order.

m
The map.
hi
Upper bound key (inclusive). Need not exist in map.
returns
A lazy sequence of (Tuple key value) pairs for keys <= hi.

Lazy, matching orderedmap-range.

See also: orderedmap-range, orderedmap-from, orderedmap-predecessor

orderedmap-map

function ↑ Functions

(: orderedmap-map (-> (-?-> %k %v %w) (OrderedMap %k %v) (OrderedMap %k %w)))
(orderedmap-map f m)

Transforms every entry value using a function of key and value.

f
Transformation function called as (f key value), returning new value.
m
The map.
returns
A new ordered map with identical keys and transformed values.

Keys are preserved in place; f cannot modify key values or relative order.

See also: orderedmap-map-values, orderedmap-filter

orderedmap-map-values

function ↑ Functions

(: orderedmap-map-values (-> (-?-> %v %w) (OrderedMap %k %v) (OrderedMap %k %w)))
(orderedmap-map-values f m)

Transforms every entry value using a function of value alone.

f
Transformation function called as (f value), returning new value.
m
The map.
returns
A new ordered map with identical keys and transformed values.

See also: orderedmap-map

orderedmap-filter

function ↑ Functions

(: orderedmap-filter (-> (-?-> %k %v bool) (OrderedMap %k %v) (OrderedMap %k %v)))
(orderedmap-filter keep? m)

Returns a new map containing only entries satisfying a predicate.

keep?
Predicate function called as (keep? key value); #t keeps entry.
m
The map.
returns
A new map of retained entries in ascending key order.

See also: orderedmap-remove-all, transientorderedmap-filter!, orderedmap-find

orderedmap-fold

function ↑ Functions

(: orderedmap-fold (-> (-?-> %k %v %s %s) %s (OrderedMap %k %v) %s))
(orderedmap-fold f init m)

Folds over all entries in ascending key order.

f
Accumulator function called as (f key value acc), returning next acc.
init
Initial accumulator value.
m
The map to fold.
returns
The final accumulator value, or init if empty.
(orderedmap-fold (fun (k v acc) (+ acc v)) 0 m)   ; sum of all values

See also: orderedmap-for-each, fold

orderedmap-for-each

function ↑ Functions

(: orderedmap-for-each (-> (-?-> %k %v void) (OrderedMap %k %v) void))
(orderedmap-for-each f m)

Applies a function to each entry in ascending key order.

f
Callback function called as (f key value).
m
The map.

See also: orderedmap-iter, orderedmap-fold

orderedmap-iter

function ↑ Functions

(: orderedmap-iter (-> (-?-> %k %v bool) (OrderedMap %k %v) bool))
(orderedmap-iter f m)

Iterates over entries in ascending key order until f returns #f.

f
Callback function called as (f key value); #f stops iteration.
m
The map.
returns
#t if all entries were visited; #f if stopped early by f.

See also: orderedmap-for-each, orderedmap-any?, orderedmap-find

orderedmap-any?

function ↑ Functions

(: orderedmap-any? (-> (-> %k %v bool) (OrderedMap %k %v) bool))

Tests if any entry satisfies a predicate.

pred
Predicate function called as (pred key value).
m
The map.
returns
#t on the first entry satisfying pred; #f if none match.

See also: orderedmap-find, orderedmap-iter

orderedmap-find

function ↑ Functions

(: orderedmap-find (-> (-> %k %v bool) (OrderedMap %k %v) (out %k) (out %v) (Option (Tuple %k %v))))

Returns the first entry satisfying a predicate in ascending key order.

pred
Predicate function called as (pred key value).
m
The map.
returns
(Some (Tuple key value)) for the first match, or None.

See also: orderedmap-any?, orderedmap-filter

list->orderedmap

function ↑ Functions

(: list->orderedmap (-> (List (Tuple %k %v)) (OrderedMap %k %v)))
(list->orderedmap xs)

Constructs an ordered map from a list of key-value pairs.

xs
List of (Tuple key value) pairs. Duplicate keys keep the last value.
returns
A new ordered map sorted by key.

Constructed through a builder in a single pass.

See also: orderedmap->list, vec->orderedmap, seq->orderedmap, OrderedMapping

orderedmap->list

function ↑ Functions

(: orderedmap->list (-> (OrderedMap %k %v) (List (Tuple %k %v))))
(orderedmap->list m)

Converts map entries to a list of (Tuple key value) pairs in ascending key order.

m
The map.
returns
A list of (Tuple key value) pairs in ascending key order.

See also: list->orderedmap, orderedmap->vec, orderedmap->seq

vec->orderedmap

function ↑ Functions

(: vec->orderedmap (-> (Vec (Tuple %k %v)) (OrderedMap %k %v)))
(vec->orderedmap v)

Constructs an ordered map from a vector of key-value pairs.

v
Vector of (Tuple key value) pairs. Duplicate keys keep the last value.
returns
A new ordered map sorted by key.

Constructed through a builder in a single pass.

See also: orderedmap->vec, list->orderedmap, seq->orderedmap

orderedmap->vec

function ↑ Functions

(: orderedmap->vec (-> (OrderedMap %k %v) (Vec (Tuple %k %v))))
(orderedmap->vec m)

Converts map entries to a vector of (Tuple key value) pairs in ascending key order.

m
The map.
returns
A vector of (Tuple key value) pairs in ascending key order.

See also: vec->orderedmap, orderedmap->list, orderedmap->seq

seq->orderedmap

function ↑ Functions

(: seq->orderedmap (-> (Seq (Tuple %k %v)) (OrderedMap %k %v)))
(seq->orderedmap xs)

Constructs an ordered map from a sequence of key-value pairs.

xs
Sequence of (Tuple key value) pairs. Duplicate keys keep the last value.
returns
A new ordered map sorted by key.

Constructed through a builder in a single pass.

See also: orderedmap->seq, list->orderedmap, vec->orderedmap

orderedmap->seq

function ↑ Functions

(: orderedmap->seq (-> (OrderedMap %k %v) (Seq (Tuple %k %v))))

Views map entries as a sequence in ascending key order.

m
The map.
returns
A sequence of (Tuple key value) pairs in ascending key order.

See also: seq->orderedmap, orderedmap-range, orderedmap-keys, orderedmap-values

map->orderedmap

function ↑ Functions

(: map->orderedmap (-> (Map %k %v) (OrderedMap %k %v)))
(map->orderedmap m)

Constructs an ordered map from an unordered hash map.

m
The source hash map.
returns
A new ordered map with identical entries sorted by key.

Constructed through a builder in a single pass.

See also: orderedmap->map, Map

orderedmap->map

function ↑ Functions

(: orderedmap->map (-> (OrderedMap %k %v) (Map %k %v)))
(orderedmap->map m)

Converts an ordered map into an unordered persistent hash map.

m
The source ordered map.
returns
A new persistent hash map containing all entries.

Constructed through a map builder in a single pass.

See also: map->orderedmap, Map

orderedmap->str

function ↑ Functions

(: orderedmap->str (-> (OrderedMap %k %v) string))
(orderedmap->str m)

Deprecated: use displayed. Formats an ordered map as text in the form #map((k v) …).

m
The map to format.
returns
Formatted string with entries in ascending key order.
(displayed (list->orderedmap (list (Tuple 2 "b") (Tuple 1 "a"))))   ; #map((1 a) (2 b))

The same text as displayed gives for an ordered map. Formatted identically to prelude Map output. Note that the #map(...) reader literal constructs a hash map rather than an ordered map.

See also: orderedmap->list

orderedmapbuilder-empty

function ↑ Functions

(: orderedmapbuilder-empty (-> (OrderedMapBuilder %k %v)))
(orderedmapbuilder-empty)

Creates an empty ordered map builder.

returns
A new builder using the key type's Ord instance.

See also: orderedmap->orderedmapbuilder, orderedmapbuilder-add!, OrderedMapBuilder

orderedmap->orderedmapbuilder

function ↑ Functions

(: orderedmap->orderedmapbuilder (-> (OrderedMap %k %v) (OrderedMapBuilder %k %v)))

Creates an ordered map builder initialized with entries from a map.

m
The source map (unmodified).
returns
A new builder containing m's entries.

Traverses the map to populate the buffer in O(n) time. To mutate an existing map in place, use orderedmap->transientorderedmap in O(1).

See also: orderedmapbuilder-empty, orderedmap->transientorderedmap

orderedmapbuilder-add!

function ↑ Functions

(: orderedmapbuilder-add! (-> (OrderedMapBuilder %k %v) %k %v void))

Appends an entry to an ordered map builder buffer.

b
The builder.
k
The key.
v
The value. Duplicate keys keep the last value added.

See also: orderedmapbuilder-add-all!, orderedmapbuilder->orderedmap, add!

orderedmapbuilder-add-all!

function ↑ Functions

(: orderedmapbuilder-add-all! (-> (OrderedMapBuilder %k %v) (Seq (Tuple %k %v)) void))

Appends all entries from a sequence to an ordered map builder buffer.

b
The builder.
kvs
Sequence of (Tuple key value) pairs.

See also: orderedmapbuilder-add!

orderedmapbuilder-length

function ↑ Functions

(: orderedmapbuilder-length (-> (OrderedMapBuilder %k %v) int))

Returns the number of entries appended to the builder buffer.

b
The builder.
returns
The count of entries appended, including duplicates.

Duplicate keys are resolved when the map is built, so this represents an upper bound on final map size.

See also: orderedmapbuilder->orderedmap

orderedmapbuilder->orderedmap

function ↑ Functions

(: orderedmapbuilder->orderedmap (-> (OrderedMapBuilder %k %v) (OrderedMap %k %v)))

Constructs a persistent ordered map from the builder buffer.

b
The builder.
returns
A new persistent ordered map sorted by key.

See also: orderedmapbuilder-empty, OrderedMapBuilder

transientorderedmap-empty

function ↑ Functions

(: transientorderedmap-empty (-> (TransientOrderedMap %k %v)))
(transientorderedmap-empty)

Creates an empty transient ordered map.

returns
A new transient ordered map using the key type's Ord instance.

See also: orderedmap->transientorderedmap, TransientOrderedMap

orderedmap->transientorderedmap

function ↑ Functions

(: orderedmap->transientorderedmap (-> (OrderedMap %k %v) (TransientOrderedMap %k %v)))

Creates a transient ordered map from an existing persistent map.

m
The source map (unmodified).
returns
A mutable transient map that updates in place in O(1) time.

Shares nodes with m without copying. The transient performs copy-on-write on individual nodes as they are mutated.

See also: transientorderedmap->orderedmap, transientorderedmap-empty

transientorderedmap->orderedmap

function ↑ Functions

(: transientorderedmap->orderedmap (-> (TransientOrderedMap %k %v) (OrderedMap %k %v)))

Converts a transient ordered map into a persistent map in O(1) time.

t
The transient ordered map (remains usable).
returns
A new immutable persistent ordered map.

Relinquishes ownership of current nodes to the persistent map. Subsequent writes to t perform copy-on-write without affecting the returned map.

See also: orderedmap->transientorderedmap

transientorderedmap-set!

function ↑ Functions

(: transientorderedmap-set! (-> (TransientOrderedMap %k %v) %k %v void))

Sets a key to a value in a transient ordered map in place.

t
The transient map to modify.
k
The key.
v
The value, replacing any previous value.

See also: transientorderedmap-set-all!, orderedmap-set, add!

transientorderedmap-set-all!

function ↑ Functions

(: transientorderedmap-set-all! (-> (TransientOrderedMap %k %v) (Seq (Tuple %k %v)) void))

Sets all entries of a sequence in a transient ordered map in place.

t
The transient map to modify.
kvs
Sequence of (Tuple key value) pairs. Later pairs overwrite earlier.

See also: transientorderedmap-set!, orderedmap-set-all

transientorderedmap-remove!

function ↑ Functions

(: transientorderedmap-remove! (-> (TransientOrderedMap %k %v) %k void))

Removes a key from a transient ordered map in place.

t
The transient map to modify.
k
The key to remove.

See also: transientorderedmap-remove-all!, orderedmap-remove

transientorderedmap-remove-all!

function ↑ Functions

(: transientorderedmap-remove-all! (-> (TransientOrderedMap %k %v) (Seq %k) void))

Removes all specified keys from a transient ordered map in place.

t
The transient map to modify.
ks
Sequence of keys to remove.

See also: transientorderedmap-remove!, orderedmap-remove-all

transientorderedmap-filter!

function ↑ Functions

(: transientorderedmap-filter! (-> (-> %k %v bool) (TransientOrderedMap %k %v) void))

Removes entries rejected by a predicate from a transient ordered map in place.

keep?
Predicate function called as (keep? key value); #f removes entry.
t
The transient map to modify.

Identifies all keys to remove before performing deletions, ensuring keep? observes the complete transient map state.

See also: orderedmap-filter, transientorderedmap-remove-all!

transientorderedmap-contains?

function ↑ Functions

(: transientorderedmap-contains? (-> (TransientOrderedMap %k %v) %k bool))

Tests if a key exists in the transient ordered map.

t
The transient map.
k
The key to locate.
returns
#t if k is present, otherwise #f.

See also: transientorderedmap-try-ref, orderedmap-contains?

transientorderedmap-ref

function ↑ Functions

(: transientorderedmap-ref (-> (TransientOrderedMap %k %v) %k %v))

Returns the value for a key in a transient ordered map, raising if missing.

t
The transient map.
k
The key to look up.
returns
The value associated with k.
raises System.Collections.Generic.KeyNotFoundException
When k is not in the transient map.

See also: transientorderedmap-ref-or, transientorderedmap-try-ref, orderedmap-ref

transientorderedmap-ref-or

function ↑ Functions

(: transientorderedmap-ref-or (-> (TransientOrderedMap %k %v) %k %v %v))

Returns the value for a key in a transient ordered map, or a default fallback.

t
The transient map.
k
The key to look up.
default
Fallback value returned if k is absent.
returns
The value associated with k, or default.

See also: transientorderedmap-ref, transientorderedmap-try-ref

transientorderedmap-try-ref

function ↑ Functions

(: transientorderedmap-try-ref (-> (TransientOrderedMap %k %v) %k (out %v) (Option %v)))

Returns (Some value) for a key in a transient ordered map, or None.

t
The transient map.
k
The key to look up.
returns
(Some v) if k is present, otherwise None.

See also: transientorderedmap-ref, transientorderedmap-ref-or

transientorderedmap-length

function ↑ Functions

(: transientorderedmap-length (-> (TransientOrderedMap %k %v) int))

Returns the number of entries in the transient ordered map.

t
The transient map.
returns
Current count of keys.

See also: transientorderedmap-empty?, orderedmap-length

transientorderedmap-empty?

function ↑ Functions

(: transientorderedmap-empty? (-> (TransientOrderedMap %k %v) bool))

Tests if the transient ordered map contains no entries.

t
The transient map.
returns
#t if empty, otherwise #f.

See also: transientorderedmap-length, orderedmap-empty?