diff --git a/aeson-better-errors.cabal b/aeson-better-errors.cabal
--- a/aeson-better-errors.cabal
+++ b/aeson-better-errors.cabal
@@ -1,5 +1,5 @@
 name:                aeson-better-errors
-version:             0.9.0
+version:             0.9.0.1
 synopsis:            Better error messages when decoding JSON values.
 license:             MIT
 license-file:        LICENSE
@@ -34,7 +34,7 @@
                    , scientific
                    , vector
                    , transformers
-                   , transformers-compat >= 0.3
+                   , transformers-compat >= 0.4
                    , mtl
                    , void
 
diff --git a/src/Data/Aeson/BetterErrors.hs b/src/Data/Aeson/BetterErrors.hs
--- a/src/Data/Aeson/BetterErrors.hs
+++ b/src/Data/Aeson/BetterErrors.hs
@@ -20,6 +20,7 @@
   , (.!)
 
   -- * Basic parsers
+  , asValue
   , asText
   , asString
   , asScientific
@@ -42,10 +43,12 @@
   , nthMay
 
   , eachInArray
+  , forEachInObject
   , eachInObject
   , eachInObjectWithKey
 
   -- * Custom validations
+  , withValue
   , withText
   , withString
   , withScientific
@@ -57,6 +60,7 @@
   , throwCustomError
 
   -- ** Monadic validators
+  , withValueM
   , withTextM
   , withStringM
   , withScientificM
diff --git a/src/Data/Aeson/BetterErrors/Internal.hs b/src/Data/Aeson/BetterErrors/Internal.hs
--- a/src/Data/Aeson/BetterErrors/Internal.hs
+++ b/src/Data/Aeson/BetterErrors/Internal.hs
@@ -2,10 +2,15 @@
 {-# LANGUAGE DeriveFunctor #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TupleSections #-}
+{-# LANGUAGE CPP #-}
 
 module Data.Aeson.BetterErrors.Internal where
 
-import Control.Applicative
+#if !MIN_VERSION_base(4,8,0)
+import Control.Applicative (Applicative, pure, (<$>), (<*>))
+import Data.Foldable (foldMap)
+#endif
+
 import Control.Arrow (left)
 import Control.Monad.Identity
 import Control.Monad.Reader
@@ -13,7 +18,6 @@
 import Control.Monad.Error.Class (MonadError(..))
 
 import Data.Void
-import Data.Foldable (foldMap)
 import Data.Monoid
 import Data.DList (DList)
 import qualified Data.DList as DList
@@ -296,6 +300,13 @@
 as pat ty = liftParse $ \v ->
   maybe (Left (WrongType ty v)) Right (pat v)
 
+-- | Return the current JSON 'A.Value' as is.  This does no error checking and
+-- thus always succeeds. You probably don't want this parser unless the JSON
+-- at the current part of your structure is truly arbitrary. You should prefer
+-- to use more specific parsers, like 'asText' or 'asIntegral', where possible.
+asValue :: (Functor m, Monad m) => ParseT err m A.Value
+asValue = asks rdrValue
+
 -- | Parse a single JSON string as 'Text'.
 asText :: (Functor m, Monad m) => ParseT err m Text
 asText = as patString TyString
@@ -413,27 +424,34 @@
   forM xs $ \(i, x) ->
     local (appendPath (ArrayIndex i) . setValue x) p
 
+-- | Parse each property in an object with the given parser, given the key as
+-- an argument, and collect the results.
+forEachInObject :: (Functor m, Monad m) => (Text -> ParseT err m a) -> ParseT err m [a]
+forEachInObject p = do
+  xs <- HashMap.toList <$> asObject
+  forM xs $ \(k, x) ->
+    local (appendPath (ObjectKey k) . setValue x) (p k)
+
 -- | Attempt to parse each property value in the object with the given parser,
 -- and collect the results.
 eachInObject :: (Functor m, Monad m) => ParseT err m a -> ParseT err m [(Text, a)]
-eachInObject p = do
-  xs <- HashMap.toList <$> asObject
-  forM xs $ \(k, x) ->
-    (k,) <$> local (appendPath (ObjectKey k) . setValue x) p
+eachInObject = eachInObjectWithKey Right
 
 -- | Attempt to parse each property in the object: parse the key with the
 -- given validation function, parse the value with the given parser, and
 -- collect the results.
 eachInObjectWithKey :: (Functor m, Monad m) => (Text -> Either err k) -> ParseT err m a -> ParseT err m [(k, a)]
-eachInObjectWithKey parseKey parseVal =
-  eachInObject parseVal
-      >>= mapM ((\(k,v) -> liftEither ((,) <$> parseKey k <*> pure v)))
+eachInObjectWithKey parseKey parseVal = forEachInObject $ \k ->
+  (,) <$> liftEither (parseKey k) <*> parseVal
 
 -- | Lifts a function attempting to validate an arbitrary JSON value into a
 -- parser. You should only use this if absolutely necessary; the other
 -- functions in this module will generally give better error reporting.
 withValue :: (Functor m, Monad m) => (A.Value -> Either err a) -> ParseT err m a
 withValue f = liftParse (left CustomError . f)
+
+withValueM :: (Functor m, Monad m) => (A.Value -> m (Either err a)) -> ParseT err m a
+withValueM f = liftParseM (fmap (left CustomError) . f)
 
 liftEither :: (Functor m, Monad m) => Either err a -> ParseT err m a
 liftEither = withValue . const