diff --git a/cereal-plus.cabal b/cereal-plus.cabal
--- a/cereal-plus.cabal
+++ b/cereal-plus.cabal
@@ -1,7 +1,7 @@
 name:
   cereal-plus
 version:
-  0.1.0
+  0.2.0
 synopsis:
   Extended serialization library on top of "cereal".
 description:
diff --git a/src/CerealPlus/Serializable.hs b/src/CerealPlus/Serializable.hs
--- a/src/CerealPlus/Serializable.hs
+++ b/src/CerealPlus/Serializable.hs
@@ -36,7 +36,7 @@
 -- meaning that this can be used to provide serialization support for mutable data.
 -- 
 -- To use it in a pure context, refer to 'Identity' monad.
-class Serializable a m where
+class Serializable m a where
   serialize :: (Monad m, Applicative m) => a -> Serialize m ()
   deserialize :: (Monad m, Applicative m) => Deserialize m a
 
@@ -65,7 +65,7 @@
   serializeRep = serializeRep . Generics.unM1
   deserializeRep = Generics.M1 <$> deserializeRep
 
-instance (Serializable a m) => SerializableRep (Generics.K1 i a) m where
+instance (Serializable m a) => SerializableRep (Generics.K1 i a) m where
   serializeRep = serialize . Generics.unK1
   deserializeRep = Generics.K1 <$> deserialize
 
@@ -84,64 +84,64 @@
 
 -- Manual instances:
 
-instance (HasResolution a, Fractional (Fixed a)) => Serializable (Fixed a) m where
+instance (HasResolution a, Fractional (Fixed a)) => Serializable m (Fixed a) where
   serialize = serialize . toRational
   deserialize = fromRational <$> deserialize
 
 
 -- 'text' instances:
 
-instance Serializable Text m where
+instance Serializable m Text where
   serialize = serialize . Text.encodeUtf8
   deserialize = Text.decodeUtf8 <$> deserialize
 
-instance Serializable LazyText m where
+instance Serializable m LazyText where
   serialize = serialize . LazyText.encodeUtf8
   deserialize = LazyText.decodeUtf8 <$> deserialize
 
 
 -- 'time' instances:
 
-instance Serializable Day m where
+instance Serializable m Day where
   serialize = serialize . Time.toModifiedJulianDay
   deserialize = Time.ModifiedJulianDay <$> deserialize
 
-instance Serializable DiffTime m where
+instance Serializable m DiffTime where
   serialize = serialize . toRational
   deserialize = fromRational <$> deserialize
 
-instance Serializable UniversalTime m where
+instance Serializable m UniversalTime where
   serialize = serialize . Time.getModJulianDate
   deserialize = Time.ModJulianDate <$> deserialize
 
-instance Serializable UTCTime m where
+instance Serializable m UTCTime where
   serialize a = serialize (Time.utctDay a) *> serialize (Time.utctDayTime a)
   deserialize = Time.UTCTime <$> deserialize <*> deserialize
 
-instance Serializable NominalDiffTime m where
+instance Serializable m NominalDiffTime where
   serialize = serialize . toRational
   deserialize = fromRational <$> deserialize
 
-instance Serializable TimeOfDay m where
+instance Serializable m TimeOfDay where
   serialize a = serialize (Time.todHour a) *> serialize (Time.todMin a) *> serialize (Time.todSec a)
   deserialize = Time.TimeOfDay <$> deserialize <*> deserialize <*> deserialize
 
-instance Serializable TimeZone m where
+instance Serializable m TimeZone where
   serialize a = 
     serialize (Time.timeZoneMinutes a) *>
     serialize (Time.timeZoneSummerOnly a) *>
     serialize (Time.timeZoneName a)
   deserialize = Time.TimeZone <$> deserialize <*> deserialize <*> deserialize
 
-instance Serializable LocalTime m where
+instance Serializable m LocalTime where
   serialize a = serialize (Time.localDay a) *> serialize (Time.localTimeOfDay a)
   deserialize = Time.LocalTime <$> deserialize <*> deserialize
 
-instance Serializable ZonedTime m where
+instance Serializable m ZonedTime where
   serialize a = serialize (Time.zonedTimeToLocalTime a) *> serialize (Time.zonedTimeZone a)
   deserialize = Time.ZonedTime <$> deserialize <*> deserialize
 
-instance Serializable AbsoluteTime m where
+instance Serializable m AbsoluteTime where
   serialize a = serialize $ Time.diffAbsoluteTime a Time.taiEpoch
   deserialize = toAbsoluteTime <$> deserialize
     where
@@ -150,26 +150,26 @@
 
 -- 'cereal' primitive instances wrappers:
 
-instance Serializable Bool m where serialize = put; deserialize = get
-instance Serializable Char m where serialize = put; deserialize = get
-instance Serializable Double m where serialize = put; deserialize = get
-instance Serializable Float m where serialize = put; deserialize = get
-instance Serializable Int m where serialize = put; deserialize = get
-instance Serializable Int8 m where serialize = put; deserialize = get
-instance Serializable Int16 m where serialize = put; deserialize = get
-instance Serializable Int32 m where serialize = put; deserialize = get
-instance Serializable Int64 m where serialize = put; deserialize = get
-instance Serializable Integer m where serialize = put; deserialize = get
-instance Serializable Ordering m where serialize = put; deserialize = get
-instance Serializable Word m where serialize = put; deserialize = get
-instance Serializable Word8 m where serialize = put; deserialize = get
-instance Serializable Word16 m where serialize = put; deserialize = get
-instance Serializable Word32 m where serialize = put; deserialize = get
-instance Serializable Word64 m where serialize = put; deserialize = get
-instance Serializable () m where serialize = put; deserialize = get
-instance Serializable ByteString m where serialize = put; deserialize = get
-instance Serializable LazyByteString m where serialize = put; deserialize = get
-instance Serializable IntSet m where serialize = put; deserialize = get
+instance Serializable m Bool where serialize = put; deserialize = get
+instance Serializable m Char where serialize = put; deserialize = get
+instance Serializable m Double where serialize = put; deserialize = get
+instance Serializable m Float where serialize = put; deserialize = get
+instance Serializable m Int where serialize = put; deserialize = get
+instance Serializable m Int8 where serialize = put; deserialize = get
+instance Serializable m Int16 where serialize = put; deserialize = get
+instance Serializable m Int32 where serialize = put; deserialize = get
+instance Serializable m Int64 where serialize = put; deserialize = get
+instance Serializable m Integer where serialize = put; deserialize = get
+instance Serializable m Ordering where serialize = put; deserialize = get
+instance Serializable m Word where serialize = put; deserialize = get
+instance Serializable m Word8 where serialize = put; deserialize = get
+instance Serializable m Word16 where serialize = put; deserialize = get
+instance Serializable m Word32 where serialize = put; deserialize = get
+instance Serializable m Word64 where serialize = put; deserialize = get
+instance Serializable m () where serialize = put; deserialize = get
+instance Serializable m ByteString where serialize = put; deserialize = get
+instance Serializable m LazyByteString where serialize = put; deserialize = get
+instance Serializable m IntSet where serialize = put; deserialize = get
 
 put :: (Monad m, Applicative m, Cereal.Serialize a) => a -> Serialize m ()
 put = Serialize.liftPut . Cereal.put
@@ -180,46 +180,46 @@
 
 -- Monoid wrappers instances:
 
-instance (Serializable a m) => Serializable (Dual a) m where
+instance (Serializable m a) => Serializable m (Dual a) where
   serialize = serialize . \case Dual a -> a
   deserialize = Dual <$> deserialize
   
-instance Serializable All m where
+instance Serializable m All where
   serialize = serialize . \case All a -> a
   deserialize = All <$> deserialize
 
-instance Serializable Any m where
+instance Serializable m Any where
   serialize = serialize . \case Any a -> a
   deserialize = Any <$> deserialize
 
-instance (Serializable a m) => Serializable (Sum a) m where
+instance (Serializable m a) => Serializable m (Sum a) where
   serialize = serialize . \case Sum a -> a
   deserialize = Sum <$> deserialize
 
-instance (Serializable a m) => Serializable (Product a) m where
+instance (Serializable m a) => Serializable m (Product a) where
   serialize = serialize . \case Product a -> a
   deserialize = Product <$> deserialize
 
-instance (Serializable a m) => Serializable (First a) m where
+instance (Serializable m a) => Serializable m (First a) where
   serialize = serialize . \case First a -> a
   deserialize = First <$> deserialize
 
-instance (Serializable a m) => Serializable (Last a) m where
+instance (Serializable m a) => Serializable m (Last a) where
   serialize = serialize . \case Last a -> a
   deserialize = Last <$> deserialize
 
 
 -- Composite instances:
 
-instance (Serializable a m, Integral a) => Serializable (Ratio a) m where
+instance (Serializable m a, Integral a) => Serializable m (Ratio a) where
   serialize a = serialize (numerator a) *> serialize (denominator a)
   deserialize = (%) <$> deserialize <*> deserialize
 
-instance (Serializable a m) => Serializable (Tree a) m where
+instance (Serializable m a) => Serializable m (Tree a) where
   serialize (Data.Tree.Node root sub) = serialize root *> serialize sub
   deserialize = Data.Tree.Node <$> deserialize <*> deserialize
 
-instance (Serializable a m, Serializable b m) => Serializable (Either a b) m where
+instance (Serializable m a, Serializable m b) => Serializable m (Either a b) where
   serialize = \case
     Right a -> serialize True *> serialize a
     Left a -> serialize False *> serialize a
@@ -228,7 +228,7 @@
       True -> Right <$> deserialize
       False -> Left <$> deserialize
 
-instance (Serializable a m) => Serializable (Maybe a) m where
+instance (Serializable m a) => Serializable m (Maybe a) where
   serialize = \case 
     Just a -> serialize True >> serialize a
     Nothing -> serialize False
@@ -238,7 +238,7 @@
       then deserialize >>= return . Just
       else return Nothing
 
-instance (Serializable a m) => Serializable [a] m where
+instance (Serializable m a) => Serializable m [a] where
   serialize l = do
     serialize (length l)
     mapM_ serialize l
@@ -246,103 +246,103 @@
     n <- deserialize
     replicateM n deserialize
 
-instance (Serializable a m) => Serializable (Seq a) m where
+instance (Serializable m a) => Serializable m (Seq a) where
   serialize = serialize . toList
   deserialize = Data.Sequence.fromList <$> deserialize
 
 
 -- Tuple instances:
 
-instance (Serializable a m) => Serializable (Identity a) m where
+instance (Serializable m a) => Serializable m (Identity a) where
   serialize = serialize . \case Identity a -> a
   deserialize = Identity <$> deserialize
 
-instance (Serializable a m, Serializable b m) => Serializable (a, b) m where
+instance (Serializable m a, Serializable m b) => Serializable m (a, b) where
   serialize (a, b) = serialize a *> serialize b
   deserialize = (,) <$> deserialize <*> deserialize
   
-instance (Serializable a m, Serializable b m, Serializable c m) => Serializable (a, b, c) m where
+instance (Serializable m a, Serializable m b, Serializable m c) => Serializable m (a, b, c) where
   serialize (a, b, c) = serialize a *> serialize b *> serialize c
   deserialize = (,,) <$> deserialize <*> deserialize <*> deserialize
   
-instance (Serializable a m, Serializable b m, Serializable c m, Serializable d m) => Serializable (a, b, c, d) m where
+instance (Serializable m a, Serializable m b, Serializable m c, Serializable m d) => Serializable m (a, b, c, d) where
   serialize (a, b, c, d) = serialize a *> serialize b *> serialize c *> serialize d
   deserialize = (,,,) <$> deserialize <*> deserialize <*> deserialize <*> deserialize
 
-instance (Serializable a m, Serializable b m, Serializable c m, Serializable d m, Serializable e m) => Serializable (a, b, c, d, e) m where
+instance (Serializable m a, Serializable m b, Serializable m c, Serializable m d, Serializable m e) => Serializable m (a, b, c, d, e) where
   serialize (a, b, c, d, e) = serialize a *> serialize b *> serialize c *> serialize d *> serialize e
   deserialize = (,,,,) <$> deserialize <*> deserialize <*> deserialize <*> deserialize <*> deserialize
 
 
 -- 'containers' instances:
 
-instance (Serializable a m, Ord a) => Serializable (Set a) m where
+instance (Serializable m a, Ord a) => Serializable m (Set a) where
   serialize = serialize . Data.Set.toAscList
   deserialize = Data.Set.fromDistinctAscList <$> deserialize
 
-instance (Serializable a m) => Serializable (IntMap a) m where
+instance (Serializable m a) => Serializable m (IntMap a) where
   serialize = serialize . Data.IntMap.toAscList
   deserialize = Data.IntMap.fromDistinctAscList <$> deserialize
 
-instance (Serializable a m, Serializable b m, Ord a) => Serializable (Map a b) m where
+instance (Serializable m a, Serializable m b, Ord a) => Serializable m (Map a b) where
   serialize = serialize . Data.Map.toAscList
   deserialize = Data.Map.fromDistinctAscList <$> deserialize
 
 
 -- 'unordered-containers' instances:
 
-instance (Serializable a m, Serializable b m, Hashable a, Eq a) => Serializable (HashMap a b) m where
+instance (Serializable m a, Serializable m b, Hashable a, Eq a) => Serializable m (HashMap a b) where
   serialize = serialize . Data.HashMap.Lazy.toList
   deserialize = Data.HashMap.Lazy.fromList <$> deserialize
 
-instance (Serializable a m, Hashable a, Eq a) => Serializable (HashSet a) m where
+instance (Serializable m a, Hashable a, Eq a) => Serializable m (HashSet a) where
   serialize = serialize . Data.HashSet.toList
   deserialize = Data.HashSet.fromList <$> deserialize
 
 
 -- 'array' instances:
 
-instance (Serializable e m, Serializable i m, Ix i) => Serializable (Array i e) m where
+instance (Serializable m e, Serializable m i, Ix i) => Serializable m (Array i e) where
   serialize = serializeArray
   deserialize = deserializeArray
 
-instance (Serializable e m, Serializable i m, IArray UArray e, Ix i) => Serializable (UArray i e) m where
+instance (Serializable m e, Serializable m i, IArray UArray e, Ix i) => Serializable m (UArray i e) where
   serialize = serializeArray
   deserialize = deserializeArray
 
-serializeArray :: (Monad m, Applicative m, Ix i, Serializable e m, Serializable i m, IArray a e) => a i e -> Serialize m ()
+serializeArray :: (Monad m, Applicative m, Ix i, Serializable m e, Serializable m i, IArray a e) => a i e -> Serialize m ()
 serializeArray a = do 
   serialize $ Data.Array.IArray.bounds a
   serialize $ Data.Array.IArray.elems a
 
-deserializeArray :: (Monad m, Applicative m, Ix i, Serializable e m, Serializable i m, IArray a e) => Deserialize m (a i e)
+deserializeArray :: (Monad m, Applicative m, Ix i, Serializable m e, Serializable m i, IArray a e) => Deserialize m (a i e)
 deserializeArray = Data.Array.IArray.listArray <$> deserialize <*> deserialize
 
 
 -- 'vector' instances:
 
-instance (Serializable a m) => Serializable (Vector a) m where
+instance (Serializable m a) => Serializable m (Vector a) where
   serialize = serializeVector
   deserialize = deserializeVector
 
-instance (Serializable a m, Data.Vector.Primitive.Prim a) => Serializable (PVector a) m where
+instance (Serializable m a, Data.Vector.Primitive.Prim a) => Serializable m (PVector a) where
   serialize = serializeVector
   deserialize = deserializeVector
 
-instance (Serializable a m, Data.Vector.Storable.Storable a) => Serializable (SVector a) m where
+instance (Serializable m a, Data.Vector.Storable.Storable a) => Serializable m (SVector a) where
   serialize = serializeVector
   deserialize = deserializeVector
 
-instance (Serializable a m, Data.Vector.Unboxed.Unbox a) => Serializable (UVector a) m where
+instance (Serializable m a, Data.Vector.Unboxed.Unbox a) => Serializable m (UVector a) where
   serialize = serializeVector
   deserialize = deserializeVector
 
-serializeVector :: (Monad m, Applicative m, Data.Vector.Generic.Vector v a, Serializable a m) => v a -> Serialize m ()
+serializeVector :: (Monad m, Applicative m, Data.Vector.Generic.Vector v a, Serializable m a) => v a -> Serialize m ()
 serializeVector a = do
   serialize (Data.Vector.Generic.length a)
   Data.Vector.Generic.mapM_ serialize a
 
-deserializeVector :: (Monad m, Applicative m, Data.Vector.Generic.Vector v a, Serializable a m) => Deserialize m (v a)
+deserializeVector :: (Monad m, Applicative m, Data.Vector.Generic.Vector v a, Serializable m a) => Deserialize m (v a)
 deserializeVector = do
   length <- deserialize
   Data.Vector.Generic.replicateM length deserialize
@@ -350,23 +350,23 @@
 
 -- 'hashtables' instances:
 
-instance ( Serializable a (ST s), Serializable b (ST s), Hashable a, Eq a ) => 
-         Serializable (Hashtables_Basic.HashTable s a b) (ST s) where
+instance ( Serializable (ST s) a, Serializable (ST s) b, Hashable a, Eq a ) => 
+         Serializable (ST s) (Hashtables_Basic.HashTable s a b) where
   serialize = serializeHashTableST
   deserialize = deserializeHashTableST
 
-instance ( Serializable a (ST s), Serializable b (ST s), Hashable a, Eq a ) => 
-         Serializable (Hashtables_Cuckoo.HashTable s a b) (ST s) where
+instance ( Serializable (ST s) a, Serializable (ST s) b, Hashable a, Eq a ) => 
+         Serializable (ST s) (Hashtables_Cuckoo.HashTable s a b) where
   serialize = serializeHashTableST
   deserialize = deserializeHashTableST
 
-instance ( Serializable a (ST s), Serializable b (ST s), Hashable a, Eq a ) => 
-         Serializable (Hashtables_Linear.HashTable s a b) (ST s) where
+instance ( Serializable (ST s) a, Serializable (ST s) b, Hashable a, Eq a ) => 
+         Serializable (ST s) (Hashtables_Linear.HashTable s a b) where
   serialize = serializeHashTableST
   deserialize = deserializeHashTableST
 
 serializeHashTableST :: 
-  (Hashtables_Class.HashTable t, Serializable a (ST s), Serializable b (ST s)) => 
+  (Hashtables_Class.HashTable t, Serializable (ST s) a, Serializable (ST s) b) => 
   t s a b -> Serialize (ST s) ()
 serializeHashTableST t = do
   join $ lift $ Hashtables_Class.foldM (\a b -> return $ a >> processRow b) (return ()) t
@@ -380,7 +380,7 @@
     signalEnd = serialize False
 
 deserializeHashTableST :: 
-  (Hashtables_Class.HashTable t, Serializable a (ST s), Serializable b (ST s), Hashable a, Eq a) => 
+  (Hashtables_Class.HashTable t, Serializable (ST s) a, Serializable (ST s) b, Hashable a, Eq a) => 
   Deserialize (ST s) (t s a b)
 deserializeHashTableST = do
   t <- lift $ Hashtables_Class.new
@@ -395,40 +395,40 @@
         True -> action >> loop action
     deserializeRow = (,) <$> deserialize <*> deserialize
 
-instance ( Serializable a (ST RealWorld), Serializable b (ST RealWorld), Hashable a, Eq a ) => 
-         Serializable (Hashtables_Basic.HashTable RealWorld a b) IO where
+instance ( Serializable (ST RealWorld) a, Serializable (ST RealWorld) b, Hashable a, Eq a ) => 
+         Serializable IO (Hashtables_Basic.HashTable RealWorld a b) where
   serialize = Serialize.mapBase stToIO . serializeHashTableST
   deserialize = Deserialize.mapBase stToIO deserializeHashTableST
 
-instance ( Serializable a (ST RealWorld), Serializable b (ST RealWorld), Hashable a, Eq a ) => 
-         Serializable (Hashtables_Cuckoo.HashTable RealWorld a b) IO where
+instance ( Serializable (ST RealWorld) a, Serializable (ST RealWorld) b, Hashable a, Eq a ) => 
+         Serializable IO (Hashtables_Cuckoo.HashTable RealWorld a b) where
   serialize = Serialize.mapBase stToIO . serializeHashTableST
   deserialize = Deserialize.mapBase stToIO deserializeHashTableST
 
-instance ( Serializable a (ST RealWorld), Serializable b (ST RealWorld), Hashable a, Eq a ) => 
-         Serializable (Hashtables_Linear.HashTable RealWorld a b) IO where
+instance ( Serializable (ST RealWorld) a, Serializable (ST RealWorld) b, Hashable a, Eq a ) => 
+         Serializable IO (Hashtables_Linear.HashTable RealWorld a b) where
   serialize = Serialize.mapBase stToIO . serializeHashTableST
   deserialize = Deserialize.mapBase stToIO deserializeHashTableST
 
 
 -- Instances for mutable types from 'base':
 
-instance (Serializable a IO) => Serializable (IORef a) IO where
+instance (Serializable IO a) => Serializable IO (IORef a) where
   serialize = serialize <=< lift . readIORef
   deserialize = lift . newIORef =<< deserialize
 
-instance (Serializable a IO) => Serializable (MVar a) IO where
+instance (Serializable IO a) => Serializable IO (MVar a) where
   serialize = lift . readMVar >=> serialize
   deserialize = deserialize >>= lift . newMVar
 
 
 -- Instances for 'stm':
 
-instance (Serializable a STM) => Serializable (TVar a) STM where
+instance (Serializable STM a) => Serializable STM (TVar a) where
   serialize = serialize <=< lift . readTVar
   deserialize = lift . newTVar =<< deserialize
 
-instance (Serializable a IO) => Serializable (TVar a) IO where
+instance (Serializable IO a) => Serializable IO (TVar a) where
   serialize = lift . atomically . readTVar >=> serialize
   deserialize = deserialize >>= lift . atomically . newTVar