diff --git a/bond-haskell.cabal b/bond-haskell.cabal
--- a/bond-haskell.cabal
+++ b/bond-haskell.cabal
@@ -1,5 +1,5 @@
 name:                bond-haskell
-version:             0.1.4.0
+version:             0.1.4.1
 synopsis:            Runtime support for BOND serialization
 description:         Bond is a cross-platform framework for handling schematized
                      data. It supports cross-language de/serialization and
diff --git a/src/Data/Bond/Internal/BinaryUtils.hs b/src/Data/Bond/Internal/BinaryUtils.hs
--- a/src/Data/Bond/Internal/BinaryUtils.hs
+++ b/src/Data/Bond/Internal/BinaryUtils.hs
@@ -15,10 +15,10 @@
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.Lazy as BL
 
--- XXX isolate is available in binary >= 0.7.2.0 (lts-3 and higher) only
-isolate :: ReaderM t ~ B.Get => Int -> BondGet t a -> BondGet t a
-isolate _ = Prelude.id
+--isolate :: ReaderM t ~ B.Get => Int -> BondGet t a -> BondGet t a
 --isolate n (BondGet g) = BondGet $ B.isolate n g
+isolate :: Int -> BondGet t a -> BondGet t a
+isolate _ = id
 
 lookAhead :: ReaderM t ~ B.Get => BondGet t a -> BondGet t a
 lookAhead (BondGet g) = BondGet $ B.lookAhead g
diff --git a/src/Data/Bond/Internal/CompactBinaryProto.hs b/src/Data/Bond/Internal/CompactBinaryProto.hs
--- a/src/Data/Bond/Internal/CompactBinaryProto.hs
+++ b/src/Data/Bond/Internal/CompactBinaryProto.hs
@@ -295,7 +295,7 @@
             Right v -> return v
         putLazyByteString (BL.drop 4 stream)
 
-getCompactFieldHeader :: (BondProto t, ReaderM t ~ B.Get) => BondGet t (BondDataType, Ordinal)
+getCompactFieldHeader :: (ReaderM t ~ B.Get) => BondGet t (BondDataType, Ordinal)
 getCompactFieldHeader = do
     tag <- getWord8
     case tag `shiftR` 5 of
@@ -307,7 +307,7 @@
             return (BondDataType $ fromIntegral $ tag .&. 31, Ordinal n)
         n -> return (BondDataType $ fromIntegral $ tag .&. 31, Ordinal (fromIntegral n))
 
-putCompactFieldHeader :: (BondProto t, WriterM t ~ ErrorT String B.PutM) => BondDataType -> Ordinal -> BondPut t
+putCompactFieldHeader :: (WriterM t ~ ErrorT String B.PutM) => BondDataType -> Ordinal -> BondPut t
 putCompactFieldHeader t (Ordinal n) =
     let tbits = fromIntegral $ fromEnum t
         nbits = fromIntegral n
@@ -363,7 +363,7 @@
     bs <- getLazyByteString (fromIntegral size)
     return $ BondedStream $ BL.append (protoHeader sig ver) bs
 
-skipVarInt :: forall t. (Protocol t, ReaderM t ~ B.Get) => BondGet t ()
+skipVarInt :: forall t. (ReaderM t ~ B.Get) => BondGet t ()
 skipVarInt = void (getVarInt :: BondGet t Word64)
 
 compactSkipType :: (TaggedProtocol t, ReaderM t ~ B.Get) => BondDataType -> BondGet t ()
@@ -395,17 +395,17 @@
             skip $ n * 2
         | otherwise -> fail $ "Invalid type to skip " ++ bondTypeName t
 
-putList :: forall a t. (TaggedProtocol t, WriterM t ~ ErrorT String B.PutM, BondType a) => [a] -> BondPut t
+putList :: forall a t. (TaggedProtocol t, Monad (WriterM t), BondType a) => [a] -> BondPut t
 putList xs = do
     putListHeader (getWireType (Proxy :: Proxy a)) (length xs)
     mapM_ bondPut xs
 
-putHashSet :: forall a t. (TaggedProtocol t, WriterM t ~ ErrorT String B.PutM, BondType a) => HashSet a -> BondPut t
+putHashSet :: forall a t. (TaggedProtocol t, Monad (WriterM t), BondType a) => HashSet a -> BondPut t
 putHashSet xs = do
     putListHeader (getWireType (Proxy :: Proxy a)) (H.size xs)
     mapM_ bondPut $ H.toList xs
 
-putSet :: forall a t. (TaggedProtocol t, WriterM t ~ ErrorT String B.PutM, BondType a) => Set a -> BondPut t
+putSet :: forall a t. (TaggedProtocol t, Monad (WriterM t), BondType a) => Set a -> BondPut t
 putSet xs = do
     putListHeader (getWireType (Proxy :: Proxy a)) (S.size xs)
     mapM_ bondPut $ S.toList xs
@@ -419,7 +419,7 @@
         bondPut k
         bondPut v
 
-putVector :: forall a t. (TaggedProtocol t, WriterM t ~ ErrorT String B.PutM, BondType a) => Vector a -> BondPut t
+putVector :: forall a t. (TaggedProtocol t, Monad (WriterM t), BondType a) => Vector a -> BondPut t
 putVector xs = do
     putListHeader (getWireType (Proxy :: Proxy a)) (V.length xs)
     V.mapM_ bondPut xs
diff --git a/src/Data/Bond/Internal/TaggedProtocol.hs b/src/Data/Bond/Internal/TaggedProtocol.hs
--- a/src/Data/Bond/Internal/TaggedProtocol.hs
+++ b/src/Data/Bond/Internal/TaggedProtocol.hs
@@ -34,10 +34,10 @@
     getTaggedStruct :: BondGet t Struct
     putFieldHeader :: BondDataType -> Ordinal -> BondPut t
     putListHeader :: (Integral a, FiniteBits a) => BondDataType -> a -> BondPut t
-    putTaggedStruct :: MonadError String (BondPutM t) => Struct -> BondPut t
+    putTaggedStruct :: Struct -> BondPut t
     skipStruct :: BondGet t ()
     skipRestOfStruct :: BondGet t ()
-    skipType :: TaggedProtocol t => BondDataType -> BondGet t ()
+    skipType :: BondDataType -> BondGet t ()
 
 getStruct :: forall a t. (Functor (ReaderM t), Monad (ReaderM t), TaggedProtocol t, BondStruct a) => StructLevel -> BondGet t a
 getStruct level = do
@@ -203,9 +203,9 @@
                 then writer
                 else throwError $ "element type do not match container type: " ++ bondTypeName td ++ " expected, " ++ bondTypeName realtd ++ " found"
 
-writeTagged :: forall t. (MonadError String (BondPutM t), WriterM t ~ ErrorT String B.PutM, TaggedProtocol t) => t -> Struct -> Either String BL.ByteString
+writeTagged :: forall t. (WriterM t ~ ErrorT String B.PutM, TaggedProtocol t) => t -> Struct -> Either String BL.ByteString
 writeTagged _ a = let BondPut g = putTaggedStruct a :: BondPut t
                    in tryPut g
 
-writeTaggedWithSchema :: (MonadError String (BondPutM t), WriterM t ~ ErrorT String B.PutM, TaggedProtocol t) => t -> StructSchema -> Struct -> Either String BL.ByteString
+writeTaggedWithSchema :: (WriterM t ~ ErrorT String B.PutM, TaggedProtocol t) => t -> StructSchema -> Struct -> Either String BL.ByteString
 writeTaggedWithSchema t schema struct = checkStructSchema schema struct >>= writeTagged t
diff --git a/test/Spec.hs b/test/Spec.hs
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -347,7 +347,7 @@
         s <- hoistEither $ bondReadWithSchema JsonProto schema dat
         hoistEither $ bondWriteWithSchema JsonProto schema s
 
-readAsType :: forall t a. (Show a, BondProto t, BondStruct a) => t -> Proxy a -> String -> Assertion
+readAsType :: forall t a. (BondProto t, BondStruct a) => t -> Proxy a -> String -> Assertion
 readAsType p _ f = assertEither $ do
     dat <- readData (compatDataPath </> f)
     void $ hoistEither (bondRead p dat :: Either String a)