diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -6,12 +6,12 @@
 Why use this library?
 ---------------------
 
-Runtime-checking for properties of data is the poor mans parsing. Nonetheless, sometimes it has do be done, and most of the time is not really pretty.
+Runtime-checking for properties of data is the poor man's parsing. Nonetheless, sometimes it has do be done, and most of the time is not really pretty.
 
 Most validation libraries define validations to be a type like `a -> Either Text a`, which makes sense as it captures the essence of validations: Put something in, and you either get it back and know your data is alright, or you have an error to work with. But the type `a -> Either Text a` does not behave nicely:
 * On the type level it does not distinguish between unvalidated and validated values.
-* Validations are not combinable: There is not canonical monoid instance
-* Validations are not reusable:   It is invariant in that is neither co- nor contravarian.
+* Validations are not combinable: There is no canonical monoid instance
+* Validations are not reusable:   It is invariant; so it is neither co- nor contravariant.
 * Validations are not composable: There is no canonical way to combine a pair of validations `(a -> Either Text a, b -> Either Text b)` to a validation `(a, b) -> Either Text (a, b)`
 
 This library attempts to fix these issues.
@@ -21,7 +21,7 @@
 
 
 
-A `Check` is a function that takes an `Unvalidated` value and returns the result, possibly with a context: If the inpu has `Passed` the check or `Failed` it with a number of possible errors.
+A `Check` is a function that takes an `Unvalidated` value and returns the result, possibly with a context: If the input has `Passed` the check or `Failed` it with a number of possible errors.
 ```haskell
 newtype Unvalidated a = Unvalidated { unsafeValidate :: a } 
 
@@ -84,7 +84,7 @@
 Composition
 -----------
 
-The `Check` type is contravariant in the parameter to be checked (in fact, the whole library is merely a big wrapper around the instancess for the type classes from the package [contravariant](https://www.stackage.org/package/contravariant)). This tells us that we can "pull back" checks to other types:
+The `Check` type is contravariant in the parameter to be checked (in fact, the whole library is merely a big wrapper around the instances for the type classes from the package [contravariant](https://www.stackage.org/package/contravariant)). This tells us that we can "pull back" checks to other types:
 
 ```haskell
 checkOdd = contramap (+1) checkEven
@@ -102,9 +102,9 @@
 	checkNil = mempty
 	checkCons = divide id checkA (checkListBy checkA)
 ```	
-To check a `[a]` we have to distinguish two cases (`split`); either it is empty (`Left ()`), then we apply the trivial check `checkNil` or it is a cons, then we apply the check to the head and check the rest of the list.
+To check a list `[a]` we have to distinguish two cases (`split`); either it is empty (`Left ()`), then we apply the trivial check `checkNil` or it is a cons, then we apply the check to the head and check the rest of the list.
 
-To summarize, from _contravariant_ we use (with Types specialized to `Check`):
+To summarize, we can use (with Types specialized to `Check`):
 * `contramap` (≡ `>$<`): `(b -> a) -> Check e m a -> Check e m b`
 * `divide :: (a -> (b, c)) -> Check e m b -> Check e m c -> Check e m a`
 * `choose :: (a -> Either b c) -> Check e m b -> Check e m c -> Check e m a`
@@ -128,10 +128,10 @@
 Additional Context
 ------------------
 
-Sometimes you need to check properties, but the check itself has a sideeffict e.g. making a HTTP request or reading from a database. This is no problem, as 
+Sometimes you need to check properties, but the check itself has a sideeffect e.g. making a HTTP request or reading from a database. This is no problem, as 
 1. `Check`s may have a context (remember that `Check' e a ≡ Check e Identity a`, a `Check` with a trivial context).
-2. We can easily convert our checks between context as `Check`s are an instance of `MFunctor` from the package [mmorph](https://www.stackage.org/package/mmorph).
-3. We are all good as long as the context is an `Applicative` as then the monoid instance of `CheckResult e` lifts to `m CheckResult e`.
+2. we can easily convert our checks between context as `Check`s are an instance of `MFunctor` from the package [mmorph](https://www.stackage.org/package/mmorph).
+3. we are all good as long as the context is an `Applicative` as then the monoid instance of `CheckResult e` lifts to `m CheckResult e`.
 
 Let's give an example. Say you let users store URLs in a database, but for their convience you do not accept broken links.
 
@@ -158,7 +158,7 @@
      else  failsWith stat
 ```
 
-But now you allow your users to store several links, Facbook LinkedIn, Twitter and whatnot. With `foldWithCheck`/`traverseWithCheck` you can lift checks to arbitary instances of `Foldable` or `Traversable`:
+But now you allow your users to store several links, Facbook, LinkedIn, Twitter and whatnot. With `foldWithCheck`/`traverseWithCheck` you can lift checks to arbitary instances of `Foldable` or `Traversable`:
 foldWithCheck :: (Foldable f, Applicative m) => Check e m a -> Check e m (f a)
 traverseWithCheck :: (Traversable t, Applicative m) => Check e m a -> Check e m (t a)
 
@@ -169,7 +169,7 @@
 ```
 Thats all there is. Since it is that easy to generalize, `Check`s for foldables/traversable are ommited.
 
-Well, its not really performant, as the `Url`s are checked in sequence; so to check 10 `Url`s you need about 10 seconds. We can fix that by giving `IO` a "parallel" `Applicative` instance that performs all chained `(<*>)` in parallel:
+Well, its not really performant, as the `Url`s are checked in sequence. We can fix that by giving `IO` a "parallel" `Applicative` instance that performs all chained `(<*>)` in concurrently:
 ```haskell
 newtype ParIO a = ParIO { runParIO :: IO a } deriving Functor
 
@@ -177,7 +177,7 @@
     pure = ParIO . pure
     ParIO iof <*> ParIO iox = ParIO $ (\(f, x) -> f x) <$> concurrently iof iox
 ```
-As we do not want to change the implementation of `checkUrlNo4xx` since it is fine, we can use `hoist`  to lift the check to a context that is executed in parallel:
+As we do not want to change the implementation of `checkUrlNo4xx` as it is fine on its own, but we can use `hoist`  to lift the check to a context that is executed concurrently:
 ```haskell 
 -- hoist :: Monad m => (forall a. m a -> n a) -> Check e m a -> Check e n a
 -- ParIO :: forall a. IO a -> ParIO a
diff --git a/contracheck-applicative.cabal b/contracheck-applicative.cabal
--- a/contracheck-applicative.cabal
+++ b/contracheck-applicative.cabal
@@ -4,12 +4,12 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 40a504900d2d86420b905563905e389930e4d321161a55c7ebb2d9c0d6d1c933
+-- hash: 44c9537d1ff6d399e254d9f95bcfffe456f3583dff7a3cccf9d85b7227db32cd
 
 name:           contracheck-applicative
-version:        0.1.0.0
+version:        0.1.0.1
 synopsis:       Validation types/typeclass based on the contravariance.
-description:    This package provides types and a typeclass that allow for effectful validation and easy composition. For documentation see the (README)[https://gitlab.com/Birkmann/validation-check/-/blob/master/README.md]. If there are any issues, contact me at 99fabianb@sis.gl.
+description:    This package provides types and a typeclass that allow for effectful validation and easy composition. For documentation see the [README](https://gitlab.com/Birkmann/validation-check/-/blob/master/README.md). If there are any issues, contact me at 99fabianb@sis.gl.
 category:       Validation
 author:         Fabian Birkmann
 maintainer:     99fabianb@sis.gl
diff --git a/src/Control/Validation/Class.hs b/src/Control/Validation/Class.hs
--- a/src/Control/Validation/Class.hs
+++ b/src/Control/Validation/Class.hs
@@ -82,15 +82,18 @@
 infixr 5 +?+ -- so it behaves like list concatenation
 
 {-# INLINE emptyChain #-}
+-- | The checkchain that contains no checks
 emptyChain :: CheckChain e m a
 emptyChain = mempty
 
-{-# INLINE singleChain #-}             
+
+{-# INLINE singleChain #-}
+-- | Constructs a chain with only one check.
 singleChain :: Check e m a -> CheckChain e m a
 singleChain x = CheckChain [ x ]
     
 
--- These are the functions that make use of the typeclass:
+-- | These are the functions used to validate data. Return either a validated result or a sequence of all validation errors that occured.
 {-# INLINABLE validate' #-}
 validate' :: Validatable e Identity a => Unvalidated a -> Either (Seq e) a
 validate' u@(Unvalidated x) =