Index by need

Every way the vocabulary puts a need in plain words, alphabetically, with the tag that answers it and the question it answers.

You need	Tag
O(1) clear	constant_clear (How is it cleared?)
adjacency lists	multi (Values per key?)
append only	monotone (Does it change after building?)
append only until cleared	monotone_until_clear (Does it change after building?)
arbitrary keys	sparse (Which keys?)
as a span	contiguous (One array?)
best first	by_priority (How are elements taken out?)
bit packed	bit (Elements stored whole, or in fewer bits?)
breadth first	fifo (How are elements taken out?)
built once	frozen (Does it change after building?)
by position	positional (Reached by position?)
cache friendly	contiguous (One array?)
canonical	canonical (Same contents, same bytes?)
cheap clear	proportional_clear (How is it cleared?)
cleared often	proportional_clear (How is it cleared?)
cleared per search	constant_clear (How is it cleared?)
cleared, never erased	monotone_until_clear (Does it change after building?)
column widths	by_column_widths (Elements stored whole, or in fewer bits?)
columns in given bits	by_column_widths (Elements stored whole, or in fewer bits?)
comparator	order_by (What compares the elements?)
contiguous	contiguous (One array?)
deduplicated rows	handles (Reached by handle?)
depth first	lifo (How are elements taken out?)
dijkstra	monotone_priority (How do priorities move?)
disjoint sets	partition (Groups of keys?)
distinct	unique (Duplicates allowed?)
each at most once	unique (Duplicates allowed?)
equivalence classes	partition (Groups of keys?)
event simulation	monotone_priority (How do priorities move?)
falls through to a parent	layered (Layered over a parent?)
few bits per element	bit (Elements stored whole, or in fewer bits?)
few elements	small (How many elements?)
few keys in a large range	sparse (Which keys?)
fifo	fifo (How are elements taken out?)
first come first listed	insertion_ordered (In which order is it iterated?)
fixed rows	fixed_shape (Rows of a fixed shape?)
flat records	flat (Records packed flat?)
free lists per key	keyed (Freed slots kept by a key?)
frees memory	reclaims (What happens to freed memory?)
gives memory back	reclaims (What happens to freed memory?)
handles	handles (Reached by handle?)
hash consing	handles (Reached by handle?)
hashable by contents	canonical (Same contents, same bytes?)
heap	by_priority (How are elements taken out?)
ids	dense (Which keys?)
immutable after building	frozen (Does it change after building?)
in order	sorted (In which order is it iterated?)
indices	dense (Which keys?)
insertion order	insertion_ordered (In which order is it iterated?)
interner	positional (Reached by position?)
interning	handles (Reached by handle?)
inverse map	bidirectional (Looked up both ways?)
keeps capacity	retains (What happens to freed memory?)
keeps the order added	insertion_ordered (In which order is it iterated?)
lifo	lifo (How are elements taken out?)
many values per key	multi (Values per key?)
matrix	fixed_shape (Rows of a fixed shape?)
multimap	multi (Values per key?)
nested scopes	scoped (Nested scopes?)
never empty	nonempty (Can it be empty?)
never erased	monotone (Does it change after building?)
no duplicates	unique (Duplicates allowed?)
no reallocation when refilled	retains (What happens to freed memory?)
non-negative lengths	monotone_priority (How do priorities move?)
nonempty	nonempty (Can it be empty?)
numbered as inserted	positional (Reached by position?)
one array	contiguous (One array?)
one block per record	flat (Records packed flat?)
only grows	monotone (Does it change after building?)
open list	by_priority (How are elements taken out?)
order by	order_by (What compares the elements?)
ordered by key	sorted (In which order is it iterated?)
overlay	layered (Layered over a parent?)
packed integers	bit (Elements stored whole, or in fewer bits?)
parallel inserts	concurrent (Shared between threads?)
persistent	structural_sharing (Rows share structure?)
phase over phase	layered (Layered over a parent?)
pointers stay valid	stable_refs (Do references stay valid?)
pooled by shape	keyed (Freed slots kept by a key?)
preallocate	reservable (Is room made ahead?)
predecessors	bidirectional (Looked up both ways?)
priority function	order_by (What compares the elements?)
priority queue	by_priority (How are elements taken out?)
queue	fifo (How are elements taken out?)
range queries	sorted (In which order is it iterated?)
read only	frozen (Does it change after building?)
references survive inserts	stable_refs (Do references stay valid?)
refilled after clear	monotone_until_clear (Does it change after building?)
reserve	reservable (Is room made ahead?)
reset every round	constant_clear (How is it cleared?)
reuse by key	keyed (Freed slots kept by a key?)
reuse memory	retains (What happens to freed memory?)
reverse edges	bidirectional (Looked up both ways?)
rows differing in a few places	structural_sharing (Rows share structure?)
same contents same bytes	canonical (Same contents, same bytes?)
scattered keys	sparse (Which keys?)
serialized	flat (Records packed flat?)
shared between threads	concurrent (Shared between threads?)
shared structure	structural_sharing (Rows share structure?)
shrinks	reclaims (What happens to freed memory?)
size known ahead	reservable (Is room made ahead?)
small	small (How many elements?)
small key range	dense (Which keys?)
sorted	sorted (In which order is it iterated?)
stable addresses	stable_refs (Do references stay valid?)
stack	lifo (How are elements taken out?)
symbol table	scoped (Nested scopes?)
table of known shape	fixed_shape (Rows of a fixed shape?)
thread safe	concurrent (Shared between threads?)
tiny	small (How many elements?)
undo on backtrack	scoped (Nested scopes?)
union find	partition (Groups of keys?)
unsigned columns	by_column_widths (Elements stored whole, or in fewer bits?)
vertices numbered 0..n-1	dense (Which keys?)
worklist	fifo (How are elements taken out?)