úÎççÜK‘      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ Safe-Inferred‘The expression (insertUnique k v old)  returns (Just (Data.Map.insert k v old) ) if the map old did not contain  anything under the key k, otherwise returns Nothing. ‘‘‘ Safe-Inferred’$Monadic fold over the elements of a “, 5 associating to the right, i.e. from right to left. ”+Strict monadic fold over the elements of a “, 5 associating to the right, i.e. from right to left. •$Monadic fold over the elements of a “, 4 associating to the left, i.e. from left to right. –$Monadic fold over the elements of a “, 4 associating to the left, i.e. from left to right. ’”•–’”•–’”•–None.Data type for creating tuples, it is used to: I Create type-level tuples of relation tags for relation specification of % the key and the index of the store.   M :. O :. O :. M E 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"] EThe store data type has four type arguments that define what and how  things are stored. The krs" (key relation specification) and irs (index relation G specification) define the relations between the dimensions of the key ' and the elements. To that end, we use 6 and  7 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. g One-many: Every element is indexed under exactly one key dimension value. One key dimension value can  correspond to many elements. t 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. t 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 ts1 (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, D tags and rating. We would like our store to have these properties:  Content3 has one ID, only one content can have a given ID.  Content7 has one name, only one content can have a given name.  Content8 has one body, many contents can have the same content.  Content5 has many tags, many contents can have tte same tag.  Content9 has one rating, many contents can have the same rating. So in our case, we define:  E type ContentStoreKRS = O :. O :. O :. M :. O E type ContentStoreIRS = O :. O :. M :. M :. M J type ContentStoreTS = ContentID :. String :. String :. String :. Double R type ContentStore = Store ContentStoreKRS ContentStoreIRS ContentStoreTS Content  See also:  6  7  'Data.Store.Internal.Type.(:.)'   #The pupose of the # type family is  to derive a type of a "raw key") that is easier to pattern match against  than   .  Example: Œ RawKey (O :. O :. O :. M :. O) (ContentID :. String :. String :. String :. Double) ~ (ContentID :. String :. String :. [String] :. Double) 2"Type-level successor of a number. 4Type-level zero. 6OThis is type-level tag for tagging dimensions of key and the index of a store.  You can think of 6 as an abbreviation for  one.  When  dimension is tagged with  6,, it means that a single element is indexed 1 under exactly one key dimension value. Example: Content" (element) has exactly one title.  When  dimension is tagged with  6+, it means that at most one element can be 5 indexed under one key dimension value. Example: One  ContentID corresponds  to at most one Content (element).  See also:  7     7OThis is type-level tag for tagging dimensions of key and the index of a store.  You can think of 7 as an abbreviation for  many.  When  dimension is tagged with  7(, it means that a single element can be 7 indexed under multiple key dimension values. Example: Content (element) has  many tags.  When  dimension is tagged with  7+, it means that a multiple elements can be S indexed under a single key dimension values. Example: One rating can be shared by  many Contents (elements).  See also:  6     ‚  !"#$%&'()*+,-./0123456789:;<=>?@ABC—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔD  !"#$%&'()*+,-./0123456789:;<=>?@ABCD876452310/.-,+*)('9:;<=>?@ABC&%$#" ! m    !"#$%&'()*+,-./0123456789:;<=>?@ABC—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔNoneN3Inserts the given element identifier into the store's index under the given  internal key. In case of collisions: returns   . O3Inserts the given element identifier into the store's index under the given  internal key. %In case of collisions: deletes them. P;UNSAFE. Inserts the given element identifier into the store's index under the given  internal key. %In case of collisions: ignores them. RDeletes EID fron an index. DEFGHIJKLMNOPQRDEFGHIJKLMNOPQRDEFGHIJKLMNOPQRDEFGHIJKLMNOPQRNoneÕTYPE VThe expression (not' sel*) is a selection that includes all values ' except those that match the selection sel. WESelection that matches the intersection of all the selections in the * list or everything if the list is empty. XThe expression (X d ss) is equivalent to (  $ map ($ d) ss). Y>Selection that matches the union of all the selections in the ' list or nothing if the list is empty. ZThe expression (Z d ss) is equivalent to ( $ map ($ d) ss). [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 T:  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 T:  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 T:  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 T:  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 T: 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 T: O(log n) aThe expression (s1 .&& s2#) is a selection that includes the  intersection of the selections s1 and s2. Complexity of T: O(c(s1) + c(s2) + s(s1) + s(s2) bThe expression ( s1 .|| s2#) is a selection that includes the  union of the selections s1 and s2. Complexity of T: O(c(s1) + c(s2) + s(s1) + s(s2) STÖ×UØÙÚÛÕÜİVWXYZ[\]^_`abŞßàSTUVWXYZ[\]^_`ab[\]^_`abVWXYZSTUSTÖ×UÛÚÙØÕÜİVWXYZ[\]^_`abŞßàNonecThe name of this module. dGFunction for creating an auto-increment dimension. Can be used instead  of (dimO x$) if the type is an instance of the    type-class. e3Function for creating dimensions with the relation  "one- anything". f3Function for creating dimensions with the relation  "many- anything". g;Function for connecting one dimension and rest of the key. hDFunction for connecting one dimensions with another (most often the  last dimension of the key). iThe expression (i k v) is store that contains  only the (k, v) as a key-element pair. jThe expression (j 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 new3 is store containing the same key-element pairs as old plus  (k, e).  Examples: 4let content = Content "name" "body" ["t1", "t2"] 0.5)insert (contentKey content) content storeF> Just (1 :. "name" :. "body" :. ["t1", "t2"] :. 0.5, <updated_store>) See also:  k  *    *  kThe expression (k 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:  j  *    *  l-UNSAFE! This function can corrupt the store. The expression (l 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:  j  * k  *    *  mThe expression (m tr old") is store where every element of  old$ was transformed using the function tr. nThe expression ( sel store) is ; list of (raw key)-element pairs that match the selection.  Complexity: O(c + s * min(n, W)) oThe expression (o store) is the number of elements  in store. pThe expression (p 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'). EIf 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:  q qThe expression (q 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:  p rThe expression (r tr sel s) is equivalent  to ( tr' sel s) where  (tr' = (_ v -> tr v) = const tr).  Complexity: "O(c + s * (min(n, W) + q * log n)) sThe expression (s tr sel s) is equivalent  to ( tr' sel s) where  (tr' = (_ v -> tr v) = const tr).  Complexity: &O(c + d * s * (min(n, W) + q * log n)) tThe expression (t tr sel s) is equivalent  to ( tr' sel s) where  (tr' = (maybe Nothing (v -> Just (v, Nothing)) . tr)).  Complexity: O(c + s * min(n, W)) uThe expression ( sel old) is  equivalent to  ( $  (const Nothing) sel old).  Complexity: !O(c + s * (min(n, W) + q * log n) vThe expression (v f z s) folds the store - using the given right-associative operator. wThe expression (w f z s) folds the store 4 using the given right-associative binary operator. xThe expression (x f z s) folds the store , using the given left-associative operator. yThe expression (y f z s) folds the store 3 using the given left-associative binary operator. zThe expression (z store4) is a list of key-element pairs that are stored in store. {The expression ({ store) is a list of elements that  are stored in store. |The expression (| store) is a list of pairs raw  keys that are stored in store. }The expression (} kvs ) is either  a) ( Just store) where store) is a store containing exactly the given  key-element pairs or;  b) Nothing1 if inserting any of the key-element pairs would  cause a collision.  See also:  ~ ~The expression (~ kvs) is store L containing the given key-element pairs (colliding pairs are not included).  See also:  } -UNSAFE! This function can corrupt the store. The expression (~ kvs) is store U containing the given key-element pairs (colliding pairs cause UNDEFINED BEHAVIOUR).  See also:  }  * } !cdefghijklmnopqrstuvwxyz{|}~€áâL"#'()*+,-./01234679:;<=>?@ABCUV[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€L#76"ijklpqrstumwvyxz{|}~onUV[\]^_`abdefgh23410/.-,+*)('9:;<=>?@ABC€c!cdefghijklmnopqrstuvwxyz{|}~€áâNone ‚DThis type-class facilitates the common use case where the key under D which given values is to be indexed can be derived from the value.  Example: The Storable type-class instance for our Content data type would look  like this: ! instance Storable Content where K type StoreKRS Content = O :. O :. O :. M :. O J type StoreIRS Content = O :. O :. M :. M :. M O type StoreTS Content = ContentID :. String :. String :. String :. Double  # key (Content cn cb cts cr) = F S.dimA .: S.dimO cn .: S.dimO cb .: S.dimM cts .:. S.dimO cr ‡See . ˆSee . ‰See . ŠSee . ‹See . ŒSee . See . See . ‚ƒ„…†‡ˆ‰Š‹Œ ‚ƒ„…†‡ˆ‰Š‹Œ ‚ƒ„…†‡ˆ‹Œ‰Š ‚ƒ„…†‡ˆ‰Š‹ŒNoneããä !"#$%&'()*+,-./0123 4567789:;<=>?@ABCDEFGHIIJJKLMNOPQRSTUVWXMYZ[\]^_`abcdefghijklmnopqrstuvMwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‘’“”•–—˜™š›œŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏĞÑÒÓÔÕÖ×ØÙÙÚÛÜİØMŞßàáâãädata-store-0.3.0.1Data.Store.Internal.TypeData.Store.Internal.FunctionData.Store.Selection Data.StoreData.Store.StorableData.Store.LensData.Map.ExtraData.IntSet.ExtraData.Store.InternalKey Data.MaybeNothingall'any'AutoRawKeylookup updateWithKeyupdateWithKey'updatedeletefromJustinsertinsert'update'fromList fromList':. EmptyProxy emptyProxyEmptyemptyEmptyProxyIsSpecialFFTT GetDimension getDimensionIndexDimensionIndexDimensionMIndexDimensionO IKeyDimensionIKeyDimensionMIKeyDimensionO KeyDimension KeyDimensionA KeyDimensionM KeyDimensionOIndexI1INIKey GenericKeyK1KNStorestoreVstoreIstoreNIDRawDimensionType DimensionTypeDimensionRelationN10N9N8N7N6N5N4N3N2N1N0SZOM moduleNamen0n1n2n3n4n5n6n7n8n9n10 genericSubset genericLookupgenericUpdateWithKey mergeKeyskeyInternalToRawkeyFromInternal keyToInternalnextKey genericInsert indexInsertIDindexInsertID'indexInsertID''findCollisions indexDeleteID IsSelectionresolve Selectionnotallall1Danyany1D.<.<=.>.>=./=.==.&&.||dimAdimOdimM.:.:. singleton unsafeInsertmapsizeupdateElements foldrWithKeyfoldr foldlWithKeyfoldltoListelementskeysunsafeFromList showIndex printIndexStorableStoreKRSStoreIRSStoreTSkeyWithwith insertUniquefoldrMcontainers-0.5.0.0Data.IntSet.BaseIntSetfoldrM'foldlMfoldlM' $fNFData:.$fNFDataGenericKey$fNFDataGenericKey0$fNFDataGenericKey1$fNFDataIKeyDimension $fNFDataIndex$fNFDataIndex0$fNFDataIndex1$fNFDataIndexDimension $fNFDataStore $fEmptyStore $fEmptyIndex $fEmptyIndex0 $fEmptyIndex1 $fEmptyIndex2$fGetDimensionSIndex$fGetDimensionZIndex$fGetDimensionZIndex0$fGetDimensionZIndex1$fShowIndexDimension$fSafeCopyIndexDimension$fSafeCopyIndexDimension0$fSerializeIndexDimension$fSerializeIndexDimension0$fShowIKeyDimension$fSafeCopyIKeyDimension$fSafeCopyIKeyDimension0$fSerializeIKeyDimension$fSerializeIKeyDimension0$fEqIKeyDimension$fShowKeyDimension $fShowIndex $fShowIndex0 $fShowIndex1$fTypeable2Index$fSafeCopyIndex$fSafeCopyIndex0$fSafeCopyIndex1$fSafeCopyIndex2$fSerializeIndex$fSerializeIndex0$fSerializeIndex1$fSerializeIndex2$fShowGenericKey$fShowGenericKey0$fShowGenericKey1$fShowGenericKey2$fShowGenericKey3$fShowGenericKey4$fTypeable2GenericKey$fSafeCopyGenericKey$fSafeCopyGenericKey0$fSafeCopyGenericKey1$fSerializeGenericKey$fSerializeGenericKey0$fSerializeGenericKey1$fEqGenericKey $fShowStore$fSafeCopyStore$fSerializeStore$fShow:.$fAutokSelectionDimension Condition SelectionNot SelectionO SelectionA SelectionType resolveSD$fIsSelectionSelectionDimension$fIsSelectionSelection $fMonoidStore$fFunctorStore $fWithsel