-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Efficient relational queries on Haskell sets.
--   
--   This Haskell package provides a data structure of sets that are
--   indexed by potentially multiple indices.
--   
--   Sets can be created, modified, and queried in various ways.
--   
--   The package is a variant of the ixset package. The ixset
--   package makes use of run-time type information to find a suitable
--   index on a query, resulting in possible run-time errors when no
--   suitable index exists. In ixset-typed, the types of all indices
--   available or tracked in the type system. Thus, ixset-typed should be
--   safer to use than ixset, but in turn requires more GHC extensions.
--   
--   At the moment, the two packages are relatively compatible. As a
--   consequence of the more precise types, a few manual tweaks are
--   necessary when switching from one to the other, but the interface is
--   mostly the same.
@package ixset-typed
@version 0.5.1.0

-- | This module defines Typeable indexes and convenience
--   functions. Should probably be considered private to
--   Data.IxSet.Typed.
module Data.IxSet.Typed.Ix

-- | Ix is a Map from some key (of type ix) to a
--   Set of values (of type a) for that key.
data Ix ix a
[Ix] :: forall ix a. !Map ix (Set a) -> (a -> [ix]) -> Ix ix a

-- | Convenience function for inserting into Maps of Sets as
--   in the case of an Ix. If they key did not already exist in the
--   Map, then a new Set is added transparently.
insert :: (Ord a, Ord k) => k -> a -> Map k (Set a) -> Map k (Set a)

-- | Convenience function for deleting from Maps of Sets. If
--   the resulting Set is empty, then the entry is removed from the
--   Map.
delete :: (Ord a, Ord k) => k -> a -> Map k (Set a) -> Map k (Set a)

-- | Helper function to create a new index from a list.
fromList :: (Ord a, Ord k) => [(k, a)] -> Map k (Set a)

-- | Helper function to insert a list of elements into a set.
insertList :: (Ord a, Ord k) => [(k, a)] -> Map k (Set a) -> Map k (Set a)

-- | Helper function to delete a list of elements from a set.
deleteList :: (Ord a, Ord k) => [(k, a)] -> Map k (Set a) -> Map k (Set a)

-- | Takes the union of two sets.
union :: (Ord a, Ord k) => Map k (Set a) -> Map k (Set a) -> Map k (Set a)

-- | Takes the intersection of two sets.
intersection :: (Ord a, Ord k) => Map k (Set a) -> Map k (Set a) -> Map k (Set a)
instance (Control.DeepSeq.NFData ix, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Data.IxSet.Typed.Ix.Ix ix a)

-- | An efficient implementation of queryable sets.
--   
--   Assume you have a family of types such as:
--   
--   
--   data Entry      = Entry Author [Author] Updated Id Content
--     deriving (Show, Eq, Ord, Data, Typeable)
--   newtype Updated = Updated UTCTime
--     deriving (Show, Eq, Ord, Data, Typeable)
--   newtype Id      = Id Int64
--     deriving (Show, Eq, Ord, Data, Typeable)
--   newtype Content = Content String
--     deriving (Show, Eq, Ord, Data, Typeable)
--   newtype Author  = Author Email
--     deriving (Show, Eq, Ord, Data, Typeable)
--   type Email      = String
--   data Test = Test
--     deriving (Show, Eq, Ord, Data, Typeable)
--   
--   
--   
--   
- Decide what parts of your type you want indexed and make your type
--   an instance of Indexable. Use ixFun and ixGen to
--   build indices:
type EntryIxs = '[Author, Id, Updated, Test] type
--   IxEntry = IxSet EntryIxs Entry instance Indexable EntryIxs Entry where
--   indices = ixList (ixGen (Proxy :: Proxy Author)) -- out of order
--   (ixGen (Proxy :: Proxy Id)) (ixGen (Proxy :: Proxy Updated)) (ixGen
--   (Proxy :: Proxy Test)) -- bogus index
The use of ixGen
--   requires the Data and Typeable instances above. You can
--   build indices manually using ixFun. You can also use the
--   Template Haskell function inferIxSet to generate an
--   Indexable instance automatically.
--   
- Use insert, insertList, delete,
--   updateIx, deleteIx and empty to build up an
--   IxSet collection:
entries = insertList [e1, e2, e3, e4]
--   (empty :: IxEntry) entries1 = foldr delete entries [e1, e3] entries2 =
--   updateIx (Id 4) e5 entries

--   
- Use the query functions below to grab data from it:
entries @=
--   Author "john@doe.com" @< Updated t1
Statement above will find
--   all items in entries updated earlier than t1 by
--   john@doe.com.
--   
- Text indexIf you want to do add a text index create a calculated
--   index. Then if you want all entries with either word1 or
--   word2, you change the instance to:
newtype Word = Word
--   String deriving (Show, Eq, Ord) getWords (Entry _ _ _ _ (Content s)) =
--   map Word $ words s type EntryIxs = '[..., Word] instance Indexable
--   EntryIxs Entry where indices = ixList ... (ixFun getWords)
Now
--   you can do this query to find entries with any of the
--   words:
entries @+ [Word "word1", Word "word2"]
And if you
--   want all entries with both:
entries @* [Word "word1", Word
--   "word2"]

--   
- Find only the first authorIf an Entry has multiple
--   authors and you want to be able to query on the first author only,
--   define a FirstAuthor datatype and create an index with this
--   type. Now you can do:
newtype FirstAuthor = FirstAuthor Email
--   deriving (Show, Eq, Ord) getFirstAuthor (Entry author _ _ _ _) =
--   [FirstAuthor author] type EntryIxs = '[..., FirstAuthor] instance
--   Indexable EntryIxs Entry where indices = ixList ... (ixFun
--   getFirstAuthor)

entries @= (FirstAuthor "john@doe.com") --
--   guess what this does

--   
module Data.IxSet.Typed

-- | Set with associated indices.
--   
--   The type-level list ixs contains all types that are valid
--   index keys. The type a is the type of elements in the indexed
--   set.
--   
--   On strictness: An IxSet is "mostly" spine-strict. It is
--   generally spine-strict in the set itself. All operations on
--   IxSet with the exception of queries are spine-strict in the
--   indices as well. Query operations, however, are lazy in the indices,
--   so querying a number of times and subsequently selecting the result
--   will not unnecessarily rebuild all indices.
data IxSet (ixs :: [Type]) a
data IxList (ixs :: [Type]) a

-- | Associate indices with a given type. The constraint
--   Indexable ixs a says that we know how to build index
--   sets of type IxSet ixs a.
--   
--   In order to use an IxSet on a particular type, you have to make
--   it an instance of Indexable yourself. There are no predefined
--   instances of IxSet.
class (All Ord ixs, Ord a) => Indexable (ixs :: [Type]) a

-- | Define how the indices for this particular type should look like.
--   
--   Use the ixList function to construct the list of indices, and
--   use ixFun (or ixGen) for individual indices.
indices :: Indexable ixs a => IxList ixs a

-- | Constraint for membership in the type-level list. Says that
--   ix is contained in the index list ixs.
class Ord ix => IsIndexOf ix (ixs :: [Type])

-- | The constraint All c xs says the c has to hold for
--   all elements in the type-level list xs.
--   
--   Example:
--   
--   
--   All Ord '[Int, Char, Bool]
--   
--   
--   is equivalent to
--   
--   
--   (Ord Int, Ord Char, Ord Bool)
--   
type family All (c :: Type -> Constraint) (xs :: [Type])

-- | Ix is a Map from some key (of type ix) to a
--   Set of values (of type a) for that key.
data Ix ix a

-- | Create an (empty) IxList from a number of indices. Useful in
--   the Indexable indices method. Use ixFun and
--   ixGen for the individual indices.
--   
--   Note that this function takes a variable number of arguments. Here are
--   some example types at which the function can be used:
--   
--   
--   ixList :: Ix ix1 a -> IxList '[ix1] a
--   ixList :: Ix ix1 a -> Ix ix2 a -> IxList '[ix1, ix2] a
--   ixList :: Ix ix1 a -> Ix ix2 a -> Ix ix3 a -> IxList '[ix1, ix2, ix3] a
--   ixList :: ...
--   
--   
--   Concrete example use:
--   
--   
--   instance Indexable '[..., Index1Type, Index2Type] Type where
--       indices = ixList
--                   ...
--                   (ixFun getIndex1)
--                   (ixGen (Proxy :: Proxy Index2Type))
--   
ixList :: forall (ixs :: [Type]) a r. MkIxList ixs ixs a r => r

-- | Class that allows a variable number of arguments to be passed to the
--   ixSet and mkEmpty functions. See the documentation
--   of these functions for more information.
class MkIxList (ixs :: [Type]) (ixs' :: [Type]) a r | r -> a ixs ixs'

-- | Create a functional index. Provided function should return a list of
--   indices where the value should be found.
--   
--   
--   getIndices :: Type -> [IndexType]
--   getIndices value = [...indices...]
--   
--   
--   
--   instance Indexable '[IndexType] Type where
--       indices = ixList (ixFun getIndices)
--   
--   
--   This is the recommended way to create indices.
ixFun :: Ord ix => (a -> [ix]) -> Ix ix a

-- | Create a generic index. Provided example is used only as type source
--   so you may use a Proxy. This uses flatten to traverse values
--   using their Data instances.
--   
--   
--   instance Indexable '[IndexType] Type where
--       indices = ixList (ixGen (Proxy :: Proxy Type))
--   
--   
--   In production systems consider using ixFun in place of
--   ixGen as the former one is much faster.
ixGen :: forall proxy a ix. (Ord ix, Data a, Typeable ix) => proxy ix -> Ix ix a

-- | Function to be used as third argument in inferIxSet when you
--   don't want any calculated values.
noCalcs :: t -> ()

-- | Template Haskell helper function for automatically building an
--   Indexable instance from a data type, e.g.
--   
--   
--   data Foo = Foo Int String
--     deriving (Eq, Ord, Data, Typeable)
--   
--   
--   and
--   
--   
--   inferIxSet "FooDB" ''Foo 'noCalcs [''Int, ''String]
--   
--   
--   will define:
--   
--   
--   type FooDB = IxSet '[Int, String] Foo
--   instance Indexable '[Int, String] Foo where
--     ...
--   
--   
--   with Int and String as indices defined via
--   
--   
--   ixFun (flattenWithCalcs noCalcs)
--   
--   
--   each.
--   
--   WARNING: This function uses flattenWithCalcs for index
--   generation, which in turn uses an SYB type-based traversal. It is
--   often more efficient (and sometimes more correct) to explicitly define
--   the indices using ixFun.
inferIxSet :: String -> Name -> Name -> [Name] -> Q [Dec]
type IndexOp = forall k a. (Ord k, Ord a) => k -> a -> Map k Set a -> Map k Set a
type SetOp = forall a. Ord a => a -> Set a -> Set a

-- | Higher order operator for modifying IxSets. Use this when your
--   final function should have the form a -> IxSet a ->
--   IxSet a, e.g. insert or delete.
change :: forall (ixs :: [Type]) a. Indexable ixs a => SetOp -> IndexOp -> a -> IxSet ixs a -> IxSet ixs a

-- | Inserts an item into the IxSet. If your data happens to have a
--   primary key this function might not be what you want. See
--   updateIx.
insert :: forall (ixs :: [Type]) a. Indexable ixs a => a -> IxSet ixs a -> IxSet ixs a
insertList :: forall (ixs :: [Type]) a. Indexable ixs a => [a] -> IxSet ixs a -> IxSet ixs a

-- | Removes an item from the IxSet.
delete :: forall (ixs :: [Type]) a. Indexable ixs a => a -> IxSet ixs a -> IxSet ixs a

-- | Will replace the item with the given index of type ix. Only
--   works if there is at most one item with that index in the
--   IxSet. Will not change IxSet if you have more than one
--   item with given index.
updateIx :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> a -> IxSet ixs a -> IxSet ixs a

-- | Will delete the item with the given index of type ix. Only
--   works if there is at most one item with that index in the
--   IxSet. Will not change IxSet if you have more than one
--   item with given index.
deleteIx :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> IxSet ixs a -> IxSet ixs a

-- | An empty IxSet.
empty :: forall (ixs :: [Type]) a. Indexable ixs a => IxSet ixs a

-- | Converts a Set to an IxSet.
fromSet :: forall (ixs :: [Type]) a. Indexable ixs a => Set a -> IxSet ixs a

-- | Converts a list to an IxSet.
fromList :: forall (ixs :: [Type]) a. Indexable ixs a => [a] -> IxSet ixs a

-- | Converts an IxSet to a Set of its elements.
toSet :: forall (ixs :: [Type]) a. IxSet ixs a -> Set a

-- | Converts an IxSet to its list of elements.
toList :: forall (ixs :: [Type]) a. IxSet ixs a -> [a]

-- | Converts an IxSet to its list of elements.
--   
--   List will be sorted in ascending order by the index ix.
--   
--   The list may contain duplicate entries if a single value produces
--   multiple keys.
toAscList :: forall proxy ix (ixs :: [Type]) a. IsIndexOf ix ixs => proxy ix -> IxSet ixs a -> [a]

-- | Converts an IxSet to its list of elements.
--   
--   List will be sorted in descending order by the index ix.
--   
--   The list may contain duplicate entries if a single value produces
--   multiple keys.
toDescList :: forall proxy ix (ixs :: [Type]) a. IsIndexOf ix ixs => proxy ix -> IxSet ixs a -> [a]

-- | If the IxSet is a singleton it will return the one item stored
--   in it. If IxSet is empty or has many elements this function
--   returns Nothing.
getOne :: forall a (ixs :: [Type]). Ord a => IxSet ixs a -> Maybe a

-- | Like getOne with a user-provided default.
getOneOr :: forall a (ixs :: [Type]). Ord a => a -> IxSet ixs a -> a

-- | Returns the number of unique items in the IxSet.
size :: forall (ixs :: [Type]) a. IxSet ixs a -> Int

-- | Return True if the IxSet is empty, False
--   otherwise.
null :: forall (ixs :: [Type]) a. IxSet ixs a -> Bool

-- | An infix intersection operation.
(&&&) :: forall (ixs :: [Type]) a. Indexable ixs a => IxSet ixs a -> IxSet ixs a -> IxSet ixs a
infixr 5 &&&

-- | An infix union operation.
(|||) :: forall (ixs :: [Type]) a. Indexable ixs a => IxSet ixs a -> IxSet ixs a -> IxSet ixs a
infixr 5 |||

-- | Takes the union of the two IxSets.
union :: forall (ixs :: [Type]) a. Indexable ixs a => IxSet ixs a -> IxSet ixs a -> IxSet ixs a

-- | Takes the intersection of the two IxSets.
intersection :: forall (ixs :: [Type]) a. Indexable ixs a => IxSet ixs a -> IxSet ixs a -> IxSet ixs a

-- | Infix version of getEQ.
(@=) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> ix -> IxSet ixs a

-- | Infix version of getLT.
(@<) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> ix -> IxSet ixs a

-- | Infix version of getGT.
(@>) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> ix -> IxSet ixs a

-- | Infix version of getLTE.
(@<=) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> ix -> IxSet ixs a

-- | Infix version of getGTE.
(@>=) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> ix -> IxSet ixs a

-- | Returns the subset with indices in the open interval (k,k).
(@><) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> (ix, ix) -> IxSet ixs a

-- | Returns the subset with indices in [k,k).
(@>=<) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> (ix, ix) -> IxSet ixs a

-- | Returns the subset with indices in (k,k].
(@><=) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> (ix, ix) -> IxSet ixs a

-- | Returns the subset with indices in [k,k].
(@>=<=) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> (ix, ix) -> IxSet ixs a

-- | Creates the subset that has an index in the provided list.
(@+) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> [ix] -> IxSet ixs a

-- | Creates the subset that matches all the provided indices.
(@*) :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => IxSet ixs a -> [ix] -> IxSet ixs a

-- | Returns the subset with an index equal to the provided key. The set
--   must be indexed over key type, doing otherwise results in runtime
--   error.
getEQ :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> IxSet ixs a -> IxSet ixs a

-- | Returns the subset with an index less than the provided key. The set
--   must be indexed over key type, doing otherwise results in runtime
--   error.
getLT :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> IxSet ixs a -> IxSet ixs a

-- | Returns the subset with an index greater than the provided key. The
--   set must be indexed over key type, doing otherwise results in runtime
--   error.
getGT :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> IxSet ixs a -> IxSet ixs a

-- | Returns the subset with an index less than or equal to the provided
--   key. The set must be indexed over key type, doing otherwise results in
--   runtime error.
getLTE :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> IxSet ixs a -> IxSet ixs a

-- | Returns the subset with an index greater than or equal to the provided
--   key. The set must be indexed over key type, doing otherwise results in
--   runtime error.
getGTE :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> IxSet ixs a -> IxSet ixs a

-- | Returns the subset with an index within the interval provided. The
--   bottom of the interval is closed and the top is open, i. e. [k1;k2).
--   The set must be indexed over key type, doing otherwise results in
--   runtime error.
getRange :: forall (ixs :: [Type]) a ix. (Indexable ixs a, IsIndexOf ix ixs) => ix -> ix -> IxSet ixs a -> IxSet ixs a

-- | Returns lists of elements paired with the indices determined by type
--   inference.
groupBy :: forall ix (ixs :: [Type]) a. IsIndexOf ix ixs => IxSet ixs a -> [(ix, [a])]

-- | Returns lists of elements paired with the indices determined by type
--   inference.
--   
--   The resulting list will be sorted in ascending order by ix.
--   The values in [a] will be sorted in ascending order as well.
groupAscBy :: forall ix (ixs :: [Type]) a. IsIndexOf ix ixs => IxSet ixs a -> [(ix, [a])]

-- | Returns lists of elements paired with the indices determined by type
--   inference.
--   
--   The resulting list will be sorted in descending order by ix.
--   
--   NOTE: The values in [a] are currently sorted in ascending
--   order. But this may change if someone bothers to add
--   toDescList. So do not rely on the sort order of the resulting
--   list.
groupDescBy :: forall ix (ixs :: [Type]) a. IsIndexOf ix ixs => IxSet ixs a -> [(ix, [a])]

-- | Returns the list of index keys being used for a particular index.
indexKeys :: forall ix (ixs :: [Type]) a. IsIndexOf ix ixs => IxSet ixs a -> [ix]

-- | Generically traverses the argument to find all occurences of values of
--   type b and returns them as a list.
--   
--   This function properly handles String as String not as
--   [Char].
flatten :: (Typeable a, Data a, Typeable b) => a -> [b]

-- | Generically traverses the argument and calculated values to find all
--   occurences of values of type b and returns them as a list.
--   Equivalent to:
--   
--   
--   flatten (x,calcs x)
--   
--   
--   This function properly handles String as String not as
--   [Char].
flattenWithCalcs :: (Data c, Typeable a, Data a, Typeable b) => (a -> c) -> a -> [b]

-- | Statistics about IxSet. This function returns quadruple
--   consisting of
--   
--   
--   
- total number of elements in the set
--   
- number of declared indices
--   
- number of keys in all indices
--   
- number of values in all keys in all indices.
--   
--   
--   This can aid you in debugging and optimisation.
stats :: forall (ixs :: [Type]) a. Indexable ixs a => IxSet ixs a -> (Int, Int, Int, Int)
instance Data.IxSet.Typed.Indexable ixs a => GHC.Classes.Eq (Data.IxSet.Typed.IxSet ixs a)
instance GHC.Internal.Data.Foldable.Foldable (Data.IxSet.Typed.IxSet ixs)
instance GHC.Classes.Ord ix => Data.IxSet.Typed.IsIndexOf ix (ix : ixs)
instance Data.IxSet.Typed.IsIndexOf ix ixs => Data.IxSet.Typed.IsIndexOf ix (ix' : ixs)
instance Data.IxSet.Typed.MkIxList ixs ixs' a r => Data.IxSet.Typed.MkIxList (ix : ixs) ixs' a (Data.IxSet.Typed.Ix.Ix ix a -> r)
instance Data.IxSet.Typed.MkIxList '[] ixs a (Data.IxSet.Typed.IxList ixs a)
instance Data.IxSet.Typed.Indexable ixs a => GHC.Internal.Base.Monoid (Data.IxSet.Typed.IxSet ixs a)
instance (Data.IxSet.Typed.All Control.DeepSeq.NFData ixs, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Data.IxSet.Typed.IxList ixs a)
instance (Data.IxSet.Typed.All Control.DeepSeq.NFData ixs, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Data.IxSet.Typed.IxSet ixs a)
instance Data.IxSet.Typed.Indexable ixs a => GHC.Classes.Ord (Data.IxSet.Typed.IxSet ixs a)
instance (Data.IxSet.Typed.Indexable ixs a, GHC.Internal.Read.Read a) => GHC.Internal.Read.Read (Data.IxSet.Typed.IxSet ixs a)
instance (Data.IxSet.Typed.Indexable ixs a, GHC.Internal.Data.Typeable.Internal.Typeable ixs, Data.SafeCopy.SafeCopy.SafeCopy a, GHC.Internal.Data.Typeable.Internal.Typeable a) => Data.SafeCopy.SafeCopy.SafeCopy (Data.IxSet.Typed.IxSet ixs a)
instance Data.IxSet.Typed.Indexable ixs a => GHC.Internal.Base.Semigroup (Data.IxSet.Typed.IxSet ixs a)
instance (Data.IxSet.Typed.Indexable ixs a, GHC.Internal.Show.Show a) => GHC.Internal.Show.Show (Data.IxSet.Typed.IxSet ixs a)
