An indexed map is a map from integer indexes to values, with a reverse map from values to indexes.

An index into the map.

Get the raw value of an index.

An empty indexed map.

>>> lookup @String 1 empty
Nothing

Create an indexed map with a single element

>>> lookup @String 1 (singleton "hello")
Just "hello"
>>> lookup @String 2 (singleton "hello")
Nothing

Lookup a value in the map by its index.

>>> lookup @String 1 (singleton "hello")
Just "hello"

Lookup a value in the map, returning its index if it exists.

>>> lookupIndex @String "hello" (singleton "hello")
Just 1
>>> lookupIndex @String "hello" (singleton "world")
Nothing
>>> lookupIndex @String "hello" (singleton "world" <> singleton "hello")
Just 2

Find the index of the first element that satisfies the predicate, if any.

>>> lookupIndexWhere (== "hello") (singleton "hello")
Just 1
>>> lookupIndexWhere (== "hello") (singleton "world")
Nothing

Check if the map is empty

>>> isEmpty empty
True
>>> isEmpty (singleton "hello")
False

Insert a value into the map without checking if it already exists. In other words, this will insert a duplicate value if it already exists in the map, and return a new index for it.

>>> insert "hello" empty
(Index 1,fromList [(1,"hello")])

>>> insert "world" (singleton "hello")
(Index 2,fromList [(1,"hello"),(2,"world")])
>>> insert "hello" (singleton "hello")
(Index 2,fromList [(1,"hello"),(2,"hello")])

Lookup a value in the map, or insert it if it doesn't exist. If the value already exists, this will return the existing index and the original map.

>>> lookupOrInsert "hello" (singleton "hello")
(Index 1,fromList [(1,"hello")])
>>> lookupOrInsert "world" (singleton "hello")
(Index 2,fromList [(1,"hello"),(2,"world")])

A monadic version of lookupOrInsert that can be used in a state monad.

A more general version of lookupOrInsertM that allows you to specify which lens to use for the state. This is useful if you have an IndexedMap within a larger state, and you want to avoid having to manually get and put the IndexedMap every time you want to lookup or insert a value.

\(O(n)\) conversion to a Vector. Duplicates are not removed, and the order of the vector is the order of the indexes in the map. This relies on the fact that IndexedMap is strictly increasing in the key, so we can just generate a vector of the appropriate length and fill it with the values from the map.

>>> toVector (singleton @Int 1)
[1]

>>> toVector (singleton @Int 1 <> singleton 2)
[1,2]

>>> toVector (singleton @Int 1 <> singleton 2 <> singleton 1)
[1,2]