std/collections

Modules

• std/collections/listThe ordered, indexable sequence: [List], its default implementation [ArrayList], and the trie-backed [TrieList].
• std/collections/mapKeys mapped to values: [Map], its default implementation [TrieMap], and the flat [HashMap].
• std/collections/queueFIFO: [Queue], with [ArrayQueue] as its only implementation.
• std/collections/setA collection without duplicates: [Set], its default implementation [TrieSet], and the flat [HashSet].
• std/collections/stackLIFO: [Stack], with [ArrayStack] as its only implementation.

Everything

• type ArrayListContiguous, growable buffer - the default.
• type ArrayQueueRing buffer on top of a List.
• type ArrayStackThe only implementation of [Stack]: a List used from the end.
• fn describedKeythe key "Alan": a key as the message of a missing one names it - what map[key] panics with.
• fn describedShownKeythe key "Alan" for the text a key shows as, with everything after its 60th character cut off as ....
• type HashMapFlat hash table: the fastest lookups and writes, but a write to a shared table copies all of it.
• type HashSetFlat hash table: the fastest lookups and writes, but a write to a shared table copies all of it.
• trait ListAn ordered sequence, addressable by index.
• extend List<Item> with From<Iterate<Item>>The factory picks the default implementation.
• extend List<Item> with Show[1, 2, 3], and [] when it is empty - the format of the literal.
• extend List<Item> with EqualsEqual when they have the same length and equal items in the same order.
• extend List<Item> with HashOrder-dependent, unlike [Set.hash] and [Map.hash]: two lists with the same items in a different order differ.
• trait MapMapping from keys to values.
• extend Map<Key, Value> with From<Iterate<(Key, Value)>>The factory picks the default implementation.
• extend Map<Key, Value> with Show["a": 1, "b": 2], and [:] when it is empty - the format of the literal.
• extend Map<Key, Value> with EqualsEqual when they hold the same entries, regardless of insertion order.
• extend Map<Key, Value> with HashOrder-independent, unlike [List.hash]: entries are combined with bitwiseExclusiveOr, so insertion order never changes the hash of equal maps.
• trait QueueFIFO queue.
• extend Queue<Item> with From<Iterate<Item>>The factory picks the default implementation: what Queue.of and a pipeline's to<Queue<Item>>() build.
• extend Queue<Item> with EqualsEqual when they hold the same items in the same order, which for a queue is the order of dequeue.
• extend Queue<Item> with HashOrder-dependent, like [List.hash] and unlike [Set.hash]: two queues with the same items in a different order are not equal, so they need not hash alike.
• trait SetCollection without duplicates.
• extend Set<Item> with From<Iterate<Item>>The factory picks the default implementation.
• extend Set<Item> with Show{a, b} - braces, so a set is never mistaken for a list.
• extend Set<Item> with EqualsEqual when they hold the same items, regardless of insertion order.
• extend Set<Item> with HashOrder-independent, unlike [List.hash]: entries are combined with bitwiseExclusiveOr, so insertion order never changes the hash of equal sets.
• trait StackLIFO stack.
• extend Stack<Item> with From<Iterate<Item>>The factory picks the default implementation: what Stack.of and a pipeline's to<Stack<Item>>() build.
• extend Stack<Item> with EqualsEqual when they hold the same items in the same order, which for a stack is from the top down - the order it iterates in, and the only order a reader of one can see.
• extend Stack<Item> with HashOrder-dependent, like [List.hash] and unlike [Set.hash]: two stacks with the same items in a different order are not equal, so they need not hash alike.
• type TrieListBit-partitioned trie.
• type TrieMapHash array mapped trie - the default.
• type TrieSetHash array mapped trie - the default.