The store data type has four type arguments that define what and how things are stored.

The krs (key relation specification) and irs (index relation specification) define the relations between the dimensions of the key and the elements. To that end, we use O and M type-level tags and 'Data.Store.Type.Internal.(:.)' data type to create tuple of these tags (to describe all the dimensions).

The possible relations are as follows:

• One-one: Every intem is indexed under exactly one key dimension value. One key dimension value corresponds to at most one elements.
• One-many: Every element is indexed under exactly one key dimension value. One key dimension value can correspond to many elements.
• Many-one: Every element can be indexed under multiple (zero or more) key dimension values. One key dimension value corresponds to at most one elements.
• Many-many: Every element cab be indexed under multiple (zero or more) key dimension value. One key dimension value can correspond to many elements.

The ts (type specification) defines the type of the key's dimensions and finally v is the type of the elements stored.

In our example with Content, we have five dimensions: ID, name, body, tags and rating. We would like our store to have these properties:

• Content has one ID, only one content can have a given ID.
• Content has one name, only one content can have a given name.
• Content has one body, many contents can have the same content.
• Content has many tags, many contents can have tte same tag.
• Content has one rating, many contents can have the same rating.

So in our case, we define:

 type ContentStoreKRS = O         :. O      :. O      :. M      :. O
 type ContentStoreIRS = O         :. O      :. M      :. M      :. M
 type ContentStoreTS  = ContentID :. String :. String :. String :. Double
 type ContentStore = Store ContentStoreKRS ContentStoreIRS ContentStoreTS Content

See also:

• O
• M
• 'Data.Store.Internal.Type.(:.)'
• Key

The pupose of the RawKey type family is to derive a type of a "raw key" that is easier to pattern match against than Key.

Example:

 RawKey (O :. O :. O :. M :. O) (ContentID :. String :. String :. String :. Double) ~ (ContentID :. String :. String :. [String] :. Double)

This is type-level tag for tagging dimensions of key and the index of a store. You can think of M as an abbreviation for many.

• When Key dimension is tagged with M, it means that a single element can be indexed under multiple key dimension values. Example: Content (element) has many tags.
• When Index dimension is tagged with M, it means that a multiple elements can be indexed under a single key dimension values. Example: One rating can be shared by many Contents (elements).

See also:

• O
• Key
• Store

This is type-level tag for tagging dimensions of key and the index of a store. You can think of O as an abbreviation for one.

• When Key dimension is tagged with O, it means that a single element is indexed under exactly one key dimension value. Example: Content (element) has exactly one title.
• When Index dimension is tagged with O, it means that at most one element can be indexed under one key dimension value. Example: One ContentID corresponds to at most one Content (element).

See also:

• M
• Key
• Store

Data type for creating tuples, it is used to:

• Create type-level tuples of relation tags for relation specification of the key and the index of the store.

 M :. O :. O :. M

• Create type-level tuples of types for type specification of the key and index of the store.

 Int :. Double :. String :. String

• Create value-level tuples to return raw key (with resolved auto-increment dimensions).

 [1, 2, 3] :. 3.5 :. "Foo" :. ["Bar1", "Bar2"]

The expression (singleton k v) is store that contains only the (k, v) as a key-element pair.

The expression (insert k e old) is either Nothing if inserting the (k, e) key-element pair would cause a collision or (Just (rk, new)), where rk is the raw key of k and new is store containing the same key-element pairs as old plus (k, e).

Examples:

>>> let content = Content "name" "body" ["t1", "t2"] 0.5
>>> insert (contentKey content) content store
> Just (1 :. "name" :. "body" :. ["t1", "t2"] :. 0.5, <updated_store>)

See also:

• insert' * Key * RawKey

The expression (insert' k v old) is (rk, new), where rk is the raw key of k and new is a store that contains the same key-element pairs as old plus (k, e). Any key-value pairs from old colliding with (k, e) are not included in new.

See also:

• insert * Key * RawKey

UNSAFE! This function can corrupt the store.

The expression (unsafeInsert k v old) is (rk, new), where rk is the raw key of k and new is a store that contains the same key-element pairs as old plus (k, e). Any key-value pairs from old colliding with (k, e) will cause UNDEFINED BEHAVIOUR.

See also:

• insert * insert' * Key * RawKey

The expression (updateWithKey tr sel old) is (Just new) where new is a store containing the same key-element pairs as old except for any key-element pairs (k, e) that match the selection sel, those are updated as follows:

• If (tr k e) is Nothing the pair is not included in new. * If (tr k e) is (Just (e', Nothing)) the pair is replaced by pair (k, e'). * If (tr k e) is (Just (e', Just k')) the pair is replaced by pair (k', e').

If any of the updated key-element pairs would cause a collision, the result is Nothing.

Complexity: O(c + s * (min(n, W) + q * log n))

See also:

• updateWithKey'

The expression (updateWithKey' tr sel old) is new where new is a store containing the same key-element pairs as old except for any key-element pairs (k, e) that match the selection sel, those are updated as follows:

• If (tr k e) is Nothing the pair is not included in new. * If (tr k e) is (Just (e', Nothing)) the pair is replaced by pair (k, e'). * If (tr k e) is (Just (e', Just k')) the pair is replaced by pair (k', e').

Any pairs of the original store old that would, after the update, cause collisons are not included in new.

Complexity: O(c + d * s * (min(n, W) + q * log n))

See also:

• updateWithKey

The expression (update tr sel s) is equivalent to (updateWithKey tr' sel s) where (tr' = (_ v -> tr v) = const tr).

Complexity: O(c + s * (min(n, W) + q * log n))

The expression (update' tr sel s) is equivalent to (updateWithKey' tr' sel s) where (tr' = (_ v -> tr v) = const tr).

Complexity: O(c + d * s * (min(n, W) + q * log n))

The expression (updateElements tr sel s) is equivalent to (update tr' sel s) where (tr' = (maybe Nothing (v -> Just (v, Nothing)) . tr)).

Complexity: O(c + s * min(n, W))

The expression (delete sel old) is equivalent to (fromJust $ update (const Nothing) sel old).

Complexity: O(c + s * (min(n, W) + q * log n)

The expression (map tr old) is store where every element of old was transformed using the function tr.

The expression (foldr f z s) folds the store using the given right-associative binary operator.

The expression (foldrWithKey f z s) folds the store using the given right-associative operator.

The expression (foldl f z s) folds the store using the given left-associative binary operator.

The expression (foldlWithKey f z s) folds the store using the given left-associative operator.

The expression (toList store) is a list of key-element pairs that are stored in store.

The expression (elements store) is a list of elements that are stored in store.

The expression (keys store) is a list of pairs raw keys that are stored in store.

The expression (fromList kvs) is either a) (Just store) where store is a store containing exactly the given key-element pairs or; b) Nothing if inserting any of the key-element pairs would cause a collision.

See also:

• fromList'

The expression (fromList' kvs) is store containing the given key-element pairs (colliding pairs are not included).

See also:

• fromList

UNSAFE! This function can corrupt the store.

The expression (fromList' kvs) is store containing the given key-element pairs (colliding pairs cause UNDEFINED BEHAVIOUR).

See also:

• fromList * fromList

The expression (size store) is the number of elements in store.

The expression (lookup sel store) is list of (raw key)-element pairs that match the selection.

Complexity: O(c + s * min(n, W))

The expression (not' sel) is a selection that includes all values except those that match the selection sel.

The expression (sDim .< c) is a selection that includes value x if and only if it is indexed in the sDim dimension with a key k such that k < c.

Complexity of resolve: O(log n + k)

The expression (sDim .<= c) is a selection that includes value x if and only if it is indexed in the sDim dimension with a key k such that k <= c.

Complexity of resolve: O(log n + k)

The expression (sDim .> c) is a selection that includes value x if and only if it is indexed in the sDim dimension with a key k such that k > c.

Complexity of resolve: O(log n + k)

The expression (sDim .>= c) is a selection that includes value x if and only if it is indexed in the sDim dimension with a key k such that k >= c.

Complexity of resolve: O(log n + k)

The expression (sDim ./= c) is a selection that includes value x if and only if it is indexed in the sDim dimension with a key k such that k /= c.

Complexity of resolve: O(n)

The expression (sDim .== c) is a selection that includes value x if and only if it is indexed in the sDim dimension with a key k such that k == c.

Complexity of resolve: O(log n)

The expression (s1 .&& s2) is a selection that includes the intersection of the selections s1 and s2.

Complexity of resolve: O(c(s1) + c(s2) + s(s1) + s(s2)

The expression (s1 .|| s2) is a selection that includes the union of the selections s1 and s2.

Complexity of resolve: O(c(s1) + c(s2) + s(s1) + s(s2)

Function for creating an auto-increment dimension. Can be used instead of (dimO x) if the type is an instance of the Auto type-class.

Function for creating dimensions with the relation "one-anything".

Function for creating dimensions with the relation "many-anything".

Function for connecting one dimension and rest of the key.

Function for connecting one dimensions with another (most often the last dimension of the key).

Type-level successor of a number.

Type-level zero.

The name of this module.