Assume you have a type like:

data Entry = Entry Author [Author] Updated Id Content
  newtype Updated = Updated EpochTime
  newtype Id = Id Int64
  newtype Content = Content String
  newtype Author = Author Email
  type Email = String

1. Decide what parts of your type you want indexed and make your type an instance of Indexable

instance Indexable Entry () where
    empty = ixSet 
                [ Ix (Map.empty::Map Author (Set Entry)) -- out of order
                , Ix (Map.empty::Map Id (Set Entry))
                , Ix (Map.empty::Map Updated (Set Entry))
                , Ix (Map.empty::Map Test (Set Entry))   -- bogus index
                , Ix (Map.empty::Map Word (Set Entry))   -- text index
                ]
    calcs entry = () -- words for text indexing purposes

3. Use insert, delete, updateIx, deleteIx and empty to build up an IxSet collection

entries = foldr insert empty [e1,e2,e3,e4] entries' = foldr delete entries [e1,e3] entries'' = update e4 e5 entries

4. Use the query functions below to grab data from it. e.g.

entries @< (Updated t1) @= (Author "john@doe.com")

will find all items in entries updated earlier than t1 by john@doe.com.

5. Text Index

If you want to do add a text index extract the words in entry and pass them in the calc method of the Indexable class. Then if you want all entries with either word1 or word2, you change the instance to

getWords entry = let Just (Content s) =
                           gGet entry in map Word $ words s

instance Indexable Entry [Word] where
    ....
    calcs entry = getWords entry

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"]

6. Find only the first author

If an Entry has multiple authors and you want to be able to query on the first author, define a FirstAuthor datatype and add it to the result of calc. calc e = (toWords e, getFirstAuthor e) and now you can do

newtype FirstAuthor = FirstAuthor Email

getFirstAuthor = let Just (Author a) = 
                          gGet Entry in FirstAuthor a

instance Indexable Entry ([Word],FirstAuthor)
    ...
    empty = ....
             Ix (Map.empty::Map FirstAuthor (Set Entry))]
    calcs entry = (getWords Entry,getFirstAuthor entry)

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

Template Haskell helper function for automatically building an Indexable instance from a data type, e.g.

data Foo = Foo Int String

and

$(inferIxSet "FooDB" ''Foo 'noCalcs [''Int,''String])

will build a type synonym

type FooDB = IxSet Foo

with Int and String as indices.

WARNING: The type specified as the first index must be a type which appears in all values in the IxSet or toList and toSet will not function properly. You will be warned not to do this by runtime error. You can always use the element type itself. For example:

$(inferIxSet "FooDB" ''Foo 'noCalcs [''Foo, ''Int, ''String])