diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,16 +1,16 @@
 quickcheck-property-comb
 --------
-This is collection of combinators built on the Reader and Writer
-Monads to allow for fast and painless Quickcheck property/invariant construction.
+These are combinators, based on the Reader and Writer Monads, to allow for fast
+and painless Quickcheck property/invariant construction.
 
 Why?
 ----
 [Quickcheck](http://hackage.haskell.org/package/QuickCheck) is a tool used to
-test cases based on constructed Properties,or essentially functions taking a
+test cases based on constructed Properties, or essentially functions taking a
 data structure and returning a boolean True or False. 
 
 However when running tests, the only way to document their failing case
-is through is through labeling them after binding, e.g.: 
+is through labeling them after binding, e.g.: 
 
 ```haskell
 inv1, inv2, inv3 :: Foo -> Bool 
@@ -25,8 +25,7 @@
 
 This gets unwieldy fast as the complexity of the data-structure increases, so
 quickcheck-property-comb provides the following:
-  - A clean separation of composition of invariants and the creation 
-    and documenting of those invariants for determining cause of failure.
+  - Monadically unifies composition of invariants and the documenting of those invariants for determining cause of failure.
   - Effective diagnostics for invariants with changing post-conditions,
     leading to <b>faster cause-of-failure diagnosis</b>.
 
diff --git a/Test/QuickCheck/Property/Comb.hs b/Test/QuickCheck/Property/Comb.hs
--- a/Test/QuickCheck/Property/Comb.hs
+++ b/Test/QuickCheck/Property/Comb.hs
@@ -1,41 +1,43 @@
 -- TODO in some cases it may be useful to indent  messages
--- based on an invariant category above them
+-- based on a documented "context" above them
 
 {-# LANGUAGE TupleSections,  ScopedTypeVariables, GeneralizedNewtypeDeriving #-}
-module Test.QuickCheck.Property.Comb where
+module Test.QuickCheck.Property.Comb (
+  cause, Inv, Invariants, doc, sat, satcomp, runInv, runInvariants
+  ) where
 import Test.QuickCheck
 import Control.Monad.Writer
 import Control.Monad.Reader
 
---A Monad which collects related invariants on the input
-type InvM i r = ReaderT i (Writer String) r
-type Inv i = InvM i Bool
+-- A Monad which collects related invariants on the input
+type InvM c r = ReaderT c (Writer String) r
+type Inv c = InvM c Bool
 
-cause :: (Monad m) => ReaderT i m i
+cause :: (Monad m) => ReaderT c m c
 cause = ask
 
---A Monad which collects distinct invariants on the input
-type Invariants i = ReaderT i (Writer [Inv i]) ()
+-- A Monad which collects invariants on the input
+type Invariants c = ReaderT c (Writer [Inv c]) ()
 
 doc :: String -> InvM r ()
 doc = lift . tell
 
-sat :: Inv i -> Invariants i
-sat p = lift . tell $ (p:[])
+sat :: Inv c -> Invariants c
+sat p = lift . tell $ [p]
 
-satcomp :: forall i i'. (i' -> i) -> Invariants i -> Invariants i'
+satcomp :: forall c c'. (c' -> c) -> Invariants c -> Invariants c'
 satcomp f = mapReaderT toWriter . withReaderT f where
-  toWriter :: Writer [Inv i] () -> Writer [Inv i'] ()
-  toWriter orig = mapWriter (((),) . map toPredicate . snd) orig
-  toPredicate :: Inv i -> Inv i'
-  toPredicate orig = withReaderT f orig
+  toWriter :: Writer [Inv c] () -> Writer [Inv c'] ()
+  toWriter = mapWriter (((),) . map toPredicate . snd)
+  toPredicate :: Inv c -> Inv c'
+  toPredicate = withReaderT f
 
-runInv :: (Show i) => i -> Inv i -> Property
-runInv cause' rdr =
-  let (effect, msg) = runWriter . (runReaderT rdr) $ cause' in
-    printTestCase ("inv: " ++ if null msg then "unknown" else msg)
+runInv :: (Show c) => c -> Inv c -> Property
+runInv checked rdr =
+  let (effect, msg) = runWriter . runReaderT rdr $ checked in
+    printTestCase ("invariant: " ++ if null msg then "unknown" else msg)
       . property $ effect
 
-runInvariants :: forall i. (Show i) => i -> Invariants i -> Property
-runInvariants cause' preds =
-  conjoin . map (runInv cause') . execWriter . runReaderT preds $ cause'
+runInvariants :: (Show c) => c -> Invariants c -> Property
+runInvariants checked preds =
+  conjoin . map (runInv checked) . execWriter . runReaderT preds $ checked
diff --git a/quickcheck-property-comb.cabal b/quickcheck-property-comb.cabal
--- a/quickcheck-property-comb.cabal
+++ b/quickcheck-property-comb.cabal
@@ -2,13 +2,65 @@
 -- further documentation, see http://haskell.org/cabal/users-guide/
 
 name:                quickcheck-property-comb
-version:             0.1.0.0
-synopsis:            Combinators for Quickcheck Property construction and Property diagnostics
-description:         This project aims to reduce the pain of composing
-                     invariants/properties, and the documenting of those invariants for determining the cause
-                     of failure. Additionally, it intends to provide effective diagnostics for
-                     invariants with changing post-conditions, leading to faster cause-of-failure
-                     diagnosis.
+version:             0.1.0.1
+synopsis:            Combinators for Quickcheck Property construction and diagnostics
+description:         
+  These are simple monads that aim to reduce the pain of composing
+  invariants/properties, and the documenting of those
+  invariants for determining the cause of failure.
+  Specifically, they provide a tool for effective diagnostic
+  for invariants with changing post-conditions, leading to a
+  faster cause-of-failure diagnosis.
+  .
+  Example case for invariants on a data structure "Consumers".
+  .
+  > data (Ord l) => Consumers l =
+  >   Consumers {
+  >     introduced :: S.Set l,
+  >     met :: M.Map (S.Set l) Bool,
+  >     disjoints :: Disjoints l
+  >   }
+  >
+  > introduced_in_disjoint :: Inv (Consumers l)
+  > introduced_in_disjoint = do
+  >   doc "all at quantity are a singleton subset in disjoints"
+  >   subsets       <- (map S.singleton) . S.toList . introduced <$> cause
+  >   disjoint_sets <- disjoints <$> cause
+  >   return . and . map ((flip S.member) disjoint_sets) $ subsets
+  > 
+  > disjoint_sizes ::  Inv (Disjoints l)
+  > disjoint_sizes = do
+  >  doc . unlines $
+  >    [ "the intersection of introduced and disjoints are the only allowed",
+  >     "singleton sets in disjoints"
+  >      ]
+  >  disjoints' <- cause 
+  >  -- Do the checking
+  >  return False
+  >
+  > disjoints_eq :: Inv (Disjoints l)
+  > disjoints_eq = do
+  >   doc "disjoint sets are equal in size"
+  >   -- ..
+  >   return True
+  >
+  > disjoints_inv :: Invariants (Disjoints l)
+  > disjoints_inv= do
+  >   sat disjoints_eq
+  >   sat disjoints_sizes
+  > 
+  > inv_consumers :: Invariants (Consumers l)
+  > inv_consumers = do
+  >   satcomp disjoints disjoints_inv
+  >   satcomp met met_inv
+  >   sat introduced_in_disjoint
+  . 
+  And to run the Consumer invariant on generated cases: 
+  .
+  > prop_testedFunction :: Arg -> Property
+  > prop_testedFunction arg = 
+  >  let consumers = testedFunction arg in
+  >    runInvariants consumers inv_consumers
 
 homepage:            http://www.github.com/jfeltz/quickcheck-property-comb
 license:             PublicDomain
@@ -23,6 +75,6 @@
   exposed-modules:     Test.QuickCheck.Property.Comb
   -- other-modules:       
   other-extensions:    TupleSections, ScopedTypeVariables, GeneralizedNewtypeDeriving
-  build-depends:       base >=4.5 && <4.6, QuickCheck >=2.5 && <2.6, mtl >=2.1 && <2.2
+  build-depends:       base >=4.5 && <4.6, QuickCheck >=2.5 && <=2.6, mtl >=2.1 && <2.2
   hs-source-dirs:      ./ 
   default-language:    Haskell2010