diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,11 @@
 # Changelog for unboxing-vector
 
+## Version 0.2.0.0 (2020-09-27)
+
+- Add coercion functions for mutable vectors.
+- Add `Unboxable` instance for several mode types: `Data.Semigroup.Arg`, `Data.Monoid.Alt`, `Data.Functor.Compose`.
+- The dependency on mono-traversable can be disabled via a package flag.
+
 ## Version 0.1.1.0 (2019-07-01)
 
 - Support older GHC versions.
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,7 +1,5 @@
 # unboxing-vector: A newtype-friendly variant of unboxed vectors
 
-[![Build Status](https://travis-ci.org/minoki/unboxing-vector.svg?branch=master)](https://travis-ci.org/minoki/unboxing-vector)
-
 This package provides newtype-friendly wrappers for `Data.Vector.Unboxed` in [`vector` package](http://hackage.haskell.org/package/vector).
 
 ## Description
diff --git a/src/Data/Vector/Unboxing.hs b/src/Data/Vector/Unboxing.hs
--- a/src/Data/Vector/Unboxing.hs
+++ b/src/Data/Vector/Unboxing.hs
@@ -78,6 +78,7 @@
   ,convert -- from Data.Vector.Generic
   ,toUnboxedVector
   ,fromUnboxedVector
+  ,coercionWithUnboxedVector
   ,coerceVector
   ,liftCoercion
   ,vectorCoercion
@@ -90,6 +91,7 @@
 import qualified Data.Vector.Generic as G
 import Data.Vector.Generic (convert)
 import Data.Vector.Unboxing.Internal
+import Data.Vector.Unboxing.Instances ()
 import Control.Monad.ST
 import Control.Monad.Primitive (PrimMonad,PrimState)
 
diff --git a/src/Data/Vector/Unboxing/Instances.hs b/src/Data/Vector/Unboxing/Instances.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Vector/Unboxing/Instances.hs
@@ -0,0 +1,164 @@
+{-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# OPTIONS_GHC -Wno-orphans -Wno-unused-imports #-}
+{-# OPTIONS_HADDOCK hide #-}
+module Data.Vector.Unboxing.Instances () where
+import Data.Vector.Unboxing.Internal
+import qualified Data.Vector.Generic as G
+
+#if defined(ENABLE_MONO_TRAVERSABLE)
+
+import qualified Data.MonoTraversable -- from mono-traversable
+import qualified Data.Sequences       -- from mono-traversable
+
+--
+-- Classes from mono-traversable
+--
+
+type instance Data.MonoTraversable.Element (Vector a) = a
+
+instance (Unboxable a) => Data.MonoTraversable.MonoFunctor (Vector a) where
+  omap = G.map
+  {-# INLINE omap #-}
+
+instance (Unboxable a) => Data.MonoTraversable.MonoFoldable (Vector a) where
+  ofoldMap f = G.foldr (mappend . f) mempty
+  ofoldr = G.foldr
+  ofoldl' = G.foldl'
+  otoList = G.toList
+  oall = G.all
+  oany = G.any
+  onull = G.null
+  olength = G.length
+  olength64 = fromIntegral . G.length
+  -- ocompareLength : use default
+  -- otraverse_ : use default
+  -- ofor_ : use default
+  -- omapM_ : use default (G.mapM_ requires a Monad, unfortunately)
+  -- oforM_ : use default (G.forM_ requires a Monad, unfortunately)
+  ofoldlM = G.foldM
+  -- ofoldMap1Ex : use default
+  ofoldr1Ex = G.foldr1
+  ofoldl1Ex' = G.foldl1'
+  headEx = G.head
+  lastEx = G.last
+  unsafeHead = G.unsafeHead
+  unsafeLast = G.unsafeLast
+  maximumByEx = G.maximumBy
+  minimumByEx = G.minimumBy
+  oelem = G.elem
+  onotElem = G.notElem
+  {-# INLINE ofoldMap #-}
+  {-# INLINE ofoldr #-}
+  {-# INLINE ofoldl' #-}
+  {-# INLINE otoList #-}
+  {-# INLINE oall #-}
+  {-# INLINE oany #-}
+  {-# INLINE onull #-}
+  {-# INLINE olength #-}
+  {-# INLINE olength64 #-}
+  {-# INLINE ofoldlM #-}
+  {-# INLINE ofoldr1Ex #-}
+  {-# INLINE ofoldl1Ex' #-}
+  {-# INLINE headEx #-}
+  {-# INLINE lastEx #-}
+  {-# INLINE unsafeHead #-}
+  {-# INLINE unsafeLast #-}
+  {-# INLINE maximumByEx #-}
+  {-# INLINE minimumByEx #-}
+  {-# INLINE oelem #-}
+  {-# INLINE onotElem #-}
+
+instance (Unboxable a) => Data.MonoTraversable.MonoTraversable (Vector a) where
+  otraverse f v = let !n = G.length v
+                  in G.fromListN n <$> traverse f (G.toList v)
+  omapM = Data.MonoTraversable.otraverse
+  {-# INLINE otraverse #-}
+  {-# INLINE omapM #-}
+
+instance (Unboxable a) => Data.MonoTraversable.MonoPointed (Vector a) where
+  opoint = G.singleton
+  {-# INLINE opoint #-}
+
+instance (Unboxable a) => Data.MonoTraversable.GrowingAppend (Vector a)
+
+instance (Unboxable a) => Data.Sequences.SemiSequence (Vector a) where
+  type Index (Vector a) = Int
+  intersperse = Data.Sequences.defaultIntersperse
+  reverse = G.reverse
+  find = G.find
+  sortBy = Data.Sequences.vectorSortBy
+  cons = G.cons
+  snoc = G.snoc
+  {-# INLINE intersperse #-}
+  {-# INLINE reverse #-}
+  {-# INLINE find #-}
+  {-# INLINE sortBy #-}
+  {-# INLINE cons #-}
+  {-# INLINE snoc #-}
+
+instance (Unboxable a) => Data.Sequences.IsSequence (Vector a) where
+  fromList = G.fromList
+  lengthIndex = G.length
+  break = G.break
+  span = G.span
+  dropWhile = G.dropWhile
+  takeWhile = G.takeWhile
+  splitAt = G.splitAt
+  -- unsafeSplitAt : use default
+  take = G.take
+  unsafeTake = G.unsafeTake
+  drop = G.drop
+  unsafeDrop = G.unsafeDrop
+  -- dropEnd : use default
+  partition = G.partition
+  uncons v | G.null v = Nothing
+           | otherwise = Just (G.head v, G.tail v)
+  unsnoc v | G.null v = Nothing
+           | otherwise = Just (G.init v, G.last v)
+  filter = G.filter
+  filterM = G.filterM
+  replicate = G.replicate
+  replicateM = G.replicateM
+  -- groupBy : use default
+  -- groupAllOn : use default
+  -- subsequences : use default
+  -- permutations : use default
+  tailEx = G.tail
+  -- tailMay : use default
+  initEx = G.init
+  -- initMay : use default
+  unsafeTail = G.unsafeTail
+  unsafeInit = G.unsafeInit
+  index = (G.!?)
+  indexEx = (G.!)
+  unsafeIndex = G.unsafeIndex
+  -- splitWhen : use default
+  {-# INLINE fromList #-}
+  {-# INLINE lengthIndex #-}
+  {-# INLINE break #-}
+  {-# INLINE span #-}
+  {-# INLINE dropWhile #-}
+  {-# INLINE takeWhile #-}
+  {-# INLINE splitAt #-}
+  {-# INLINE take #-}
+  {-# INLINE unsafeTake #-}
+  {-# INLINE drop #-}
+  {-# INLINE unsafeDrop #-}
+  {-# INLINE partition #-}
+  {-# INLINE uncons #-}
+  {-# INLINE unsnoc #-}
+  {-# INLINE filter #-}
+  {-# INLINE filterM #-}
+  {-# INLINE replicate #-}
+  {-# INLINE replicateM #-}
+  {-# INLINE tailEx #-}
+  {-# INLINE initEx #-}
+  {-# INLINE unsafeTail #-}
+  {-# INLINE unsafeInit #-}
+  {-# INLINE index #-}
+  {-# INLINE indexEx #-}
+  {-# INLINE unsafeIndex #-}
+
+#endif
diff --git a/src/Data/Vector/Unboxing/Internal.hs b/src/Data/Vector/Unboxing/Internal.hs
--- a/src/Data/Vector/Unboxing/Internal.hs
+++ b/src/Data/Vector/Unboxing/Internal.hs
@@ -6,7 +6,6 @@
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE UndecidableInstances #-}
@@ -24,6 +23,9 @@
   ,toUnboxedVector
   ,fromUnboxedVector
   ,coercionWithUnboxedVector
+  ,coerceMVector
+  ,liftCoercionM
+  ,mVectorCoercion
   ,toUnboxedMVector
   ,fromUnboxedMVector
   ,coercionWithUnboxedMVector
@@ -44,11 +46,10 @@
 import qualified Data.Complex
 import qualified Data.Functor.Identity
 import qualified Data.Functor.Const
+import qualified Data.Functor.Compose
 import qualified Data.Ord
 import qualified Data.Semigroup
 import qualified Data.Monoid
-import qualified Data.MonoTraversable -- from mono-traversable
-import qualified Data.Sequences       -- from mono-traversable
 import GHC.Exts (IsList(..))
 import Control.DeepSeq (NFData(..))
 import Text.Read (Read(..),readListPrecDefault)
@@ -122,6 +123,18 @@
 fromUnboxedVector = coerce
 {-# INLINE fromUnboxedVector #-}
 
+coerceMVector :: (Coercible a b, Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => MVector s a -> MVector s b
+coerceMVector = coerce
+{-# INLINE coerceMVector #-}
+
+liftCoercionM :: (Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Coercion a b -> Coercion (MVector s a) (MVector s b)
+liftCoercionM Coercion = Coercion
+{-# INLINE liftCoercionM #-}
+
+mVectorCoercion :: (Coercible a b, Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Coercion (MVector s a) (MVector s b)
+mVectorCoercion = Coercion
+{-# INLINE mVectorCoercion #-}
+
 toUnboxedMVector :: (Unboxable a, Rep a ~ a, IsTrivial a ~ 'True) => MVector s a -> UM.MVector s a
 toUnboxedMVector = coerce
 {-# INLINE toUnboxedMVector #-}
@@ -326,155 +339,6 @@
   {-# INLINE elemseq #-}
 
 --
--- Classes from mono-traversable
---
-
-type instance Data.MonoTraversable.Element (Vector a) = a
-
-instance (Unboxable a) => Data.MonoTraversable.MonoFunctor (Vector a) where
-  omap = G.map
-  {-# INLINE omap #-}
-
-instance (Unboxable a) => Data.MonoTraversable.MonoFoldable (Vector a) where
-  ofoldMap f = G.foldr (mappend . f) mempty
-  ofoldr = G.foldr
-  ofoldl' = G.foldl'
-  otoList = G.toList
-  oall = G.all
-  oany = G.any
-  onull = G.null
-  olength = G.length
-  olength64 = fromIntegral . G.length
-  -- ocompareLength : use default
-  -- otraverse_ : use default
-  -- ofor_ : use default
-  -- omapM_ : use default (G.mapM_ requires a Monad, unfortunately)
-  -- oforM_ : use default (G.forM_ requires a Monad, unfortunately)
-  ofoldlM = G.foldM
-  -- ofoldMap1Ex : use default
-  ofoldr1Ex = G.foldr1
-  ofoldl1Ex' = G.foldl1'
-  headEx = G.head
-  lastEx = G.last
-  unsafeHead = G.unsafeHead
-  unsafeLast = G.unsafeLast
-  maximumByEx = G.maximumBy
-  minimumByEx = G.minimumBy
-  oelem = G.elem
-  onotElem = G.notElem
-  {-# INLINE ofoldMap #-}
-  {-# INLINE ofoldr #-}
-  {-# INLINE ofoldl' #-}
-  {-# INLINE otoList #-}
-  {-# INLINE oall #-}
-  {-# INLINE oany #-}
-  {-# INLINE onull #-}
-  {-# INLINE olength #-}
-  {-# INLINE olength64 #-}
-  {-# INLINE ofoldlM #-}
-  {-# INLINE ofoldr1Ex #-}
-  {-# INLINE ofoldl1Ex' #-}
-  {-# INLINE headEx #-}
-  {-# INLINE lastEx #-}
-  {-# INLINE unsafeHead #-}
-  {-# INLINE unsafeLast #-}
-  {-# INLINE maximumByEx #-}
-  {-# INLINE minimumByEx #-}
-  {-# INLINE oelem #-}
-  {-# INLINE onotElem #-}
-
-instance (Unboxable a) => Data.MonoTraversable.MonoTraversable (Vector a) where
-  otraverse f v = let !n = G.length v
-                  in G.fromListN n <$> traverse f (G.toList v)
-  omapM = Data.MonoTraversable.otraverse
-  {-# INLINE otraverse #-}
-  {-# INLINE omapM #-}
-
-instance (Unboxable a) => Data.MonoTraversable.MonoPointed (Vector a) where
-  opoint = G.singleton
-  {-# INLINE opoint #-}
-
-instance (Unboxable a) => Data.MonoTraversable.GrowingAppend (Vector a)
-
-instance (Unboxable a) => Data.Sequences.SemiSequence (Vector a) where
-  type Index (Vector a) = Int
-  intersperse = Data.Sequences.defaultIntersperse
-  reverse = G.reverse
-  find = G.find
-  sortBy = Data.Sequences.vectorSortBy
-  cons = G.cons
-  snoc = G.snoc
-  {-# INLINE intersperse #-}
-  {-# INLINE reverse #-}
-  {-# INLINE find #-}
-  {-# INLINE sortBy #-}
-  {-# INLINE cons #-}
-  {-# INLINE snoc #-}
-
-instance (Unboxable a) => Data.Sequences.IsSequence (Vector a) where
-  fromList = G.fromList
-  lengthIndex = G.length
-  break = G.break
-  span = G.span
-  dropWhile = G.dropWhile
-  takeWhile = G.takeWhile
-  splitAt = G.splitAt
-  -- unsafeSplitAt : use default
-  take = G.take
-  unsafeTake = G.unsafeTake
-  drop = G.drop
-  unsafeDrop = G.unsafeDrop
-  -- dropEnd : use default
-  partition = G.partition
-  uncons v | G.null v = Nothing
-           | otherwise = Just (G.head v, G.tail v)
-  unsnoc v | G.null v = Nothing
-           | otherwise = Just (G.init v, G.last v)
-  filter = G.filter
-  filterM = G.filterM
-  replicate = G.replicate
-  replicateM = G.replicateM
-  -- groupBy : use default
-  -- groupAllOn : use default
-  -- subsequences : use default
-  -- permutations : use default
-  tailEx = G.tail
-  -- tailMay : use default
-  initEx = G.init
-  -- initMay : use default
-  unsafeTail = G.unsafeTail
-  unsafeInit = G.unsafeInit
-  index = (G.!?)
-  indexEx = (G.!)
-  unsafeIndex = G.unsafeIndex
-  -- splitWhen : use default
-  {-# INLINE fromList #-}
-  {-# INLINE lengthIndex #-}
-  {-# INLINE break #-}
-  {-# INLINE span #-}
-  {-# INLINE dropWhile #-}
-  {-# INLINE takeWhile #-}
-  {-# INLINE splitAt #-}
-  {-# INLINE take #-}
-  {-# INLINE unsafeTake #-}
-  {-# INLINE drop #-}
-  {-# INLINE unsafeDrop #-}
-  {-# INLINE partition #-}
-  {-# INLINE uncons #-}
-  {-# INLINE unsnoc #-}
-  {-# INLINE filter #-}
-  {-# INLINE filterM #-}
-  {-# INLINE replicate #-}
-  {-# INLINE replicateM #-}
-  {-# INLINE tailEx #-}
-  {-# INLINE initEx #-}
-  {-# INLINE unsafeTail #-}
-  {-# INLINE unsafeInit #-}
-  {-# INLINE index #-}
-  {-# INLINE indexEx #-}
-  {-# INLINE unsafeIndex #-}
-
---
 -- Unboxable instances
 --
 
@@ -569,57 +433,57 @@
 
 instance Unboxable a => Unboxable (Data.Functor.Identity.Identity a) where
   type Rep (Data.Functor.Identity.Identity a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Functor.Identity.runIdentity
+  unboxingTo = Data.Functor.Identity.Identity #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Functor.Const.Const a b) where
   type Rep (Data.Functor.Const.Const a b) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Functor.Const.getConst
+  unboxingTo = Data.Functor.Const.Const #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Semigroup.Min a) where
   type Rep (Data.Semigroup.Min a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Semigroup.getMin
+  unboxingTo = Data.Semigroup.Min #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Semigroup.Max a) where
   type Rep (Data.Semigroup.Max a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Semigroup.getMax
+  unboxingTo = Data.Semigroup.Max #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Semigroup.First a) where
   type Rep (Data.Semigroup.First a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Semigroup.getFirst
+  unboxingTo = Data.Semigroup.First #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Semigroup.Last a) where
   type Rep (Data.Semigroup.Last a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Semigroup.getLast
+  unboxingTo = Data.Semigroup.Last #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Semigroup.WrappedMonoid a) where
   type Rep (Data.Semigroup.WrappedMonoid a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Semigroup.unwrapMonoid
+  unboxingTo = Data.Semigroup.WrapMonoid #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Monoid.Dual a) where
   type Rep (Data.Monoid.Dual a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Monoid.getDual
+  unboxingTo = Data.Monoid.Dual #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
@@ -631,22 +495,22 @@
 
 instance Unboxable a => Unboxable (Data.Monoid.Sum a) where
   type Rep (Data.Monoid.Sum a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Monoid.getSum
+  unboxingTo = Data.Monoid.Sum #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Monoid.Product a) where
   type Rep (Data.Monoid.Product a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# Data.Monoid.getProduct
+  unboxingTo = Data.Monoid.Product #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
 instance Unboxable a => Unboxable (Data.Ord.Down a) where
   type Rep (Data.Ord.Down a) = Rep a
-  unboxingFrom = coerce (unboxingFrom @a)
-  unboxingTo = coerce (unboxingTo @a)
+  unboxingFrom = unboxingFrom .# (\(Data.Ord.Down x) -> x)
+  unboxingTo = Data.Ord.Down #. unboxingTo
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
 
@@ -656,3 +520,45 @@
   unboxingTo y = toEnum (fromIntegral y)
   {-# INLINE unboxingFrom #-}
   {-# INLINE unboxingTo #-}
+
+instance (Unboxable a, Unboxable b) => Unboxable (Data.Semigroup.Arg a b) where
+  type Rep (Data.Semigroup.Arg a b) = (Rep a, Rep b)
+  unboxingFrom (Data.Semigroup.Arg x y) = (unboxingFrom x, unboxingFrom y)
+  unboxingTo (x, y) = Data.Semigroup.Arg (unboxingTo x) (unboxingTo y)
+  {-# INLINE unboxingFrom #-}
+  {-# INLINE unboxingTo #-}
+
+instance Unboxable (f a) => Unboxable (Data.Monoid.Alt f a) where
+  type Rep (Data.Monoid.Alt f a) = Rep (f a)
+  unboxingFrom = unboxingFrom .# Data.Monoid.getAlt
+  unboxingTo = Data.Monoid.Alt #. unboxingTo
+  {-# INLINE unboxingFrom #-}
+  {-# INLINE unboxingTo #-}
+
+{-
+-- Since base-4.12.0.0
+instance Unboxable (f a) => Unboxable (Data.Monoid.Ap f a) where
+  type Rep (Data.Monoid.Ap f a) = Rep (f a)
+  unboxingFrom = unboxingFrom .# Data.Monoid.getAp
+  unboxingTo = Data.Monoid.Ap #. unboxingTo
+  {-# INLINE unboxingFrom #-}
+  {-# INLINE unboxingTo #-}
+-}
+
+instance Unboxable (f (g a)) => Unboxable (Data.Functor.Compose.Compose f g a) where
+  type Rep (Data.Functor.Compose.Compose f g a) = Rep (f (g a))
+  unboxingFrom = unboxingFrom .# Data.Functor.Compose.getCompose
+  unboxingTo = Data.Functor.Compose.Compose #. unboxingTo
+  {-# INLINE unboxingFrom #-}
+  {-# INLINE unboxingTo #-}
+
+infixr 9 #.
+infixl 8 .#
+
+(#.) :: Coercible b c => (b -> c) -> (a -> b) -> a -> c
+_ #. f = coerce f
+{-# INLINE (#.) #-}
+
+(.#) :: Coercible a b => (b -> c) -> (a -> b) -> a -> c
+f .# _ = coerce f
+{-# INLINE (.#) #-}
diff --git a/src/Data/Vector/Unboxing/Mutable.hs b/src/Data/Vector/Unboxing/Mutable.hs
--- a/src/Data/Vector/Unboxing/Mutable.hs
+++ b/src/Data/Vector/Unboxing/Mutable.hs
@@ -30,14 +30,19 @@
   -- ** Filling and copying
   ,set,copy,move,unsafeCopy,unsafeMove
   -- * Conversions from/to other vector types
+  ,coerceMVector
+  ,liftCoercionM
+  ,mVectorCoercion
   ,toUnboxedMVector
   ,fromUnboxedMVector
+  ,coercionWithUnboxedMVector
   ) where
 
 import Prelude (Int,Bool,Ord)
 import qualified Data.Vector.Generic.Mutable as G
 import qualified Data.Vector.Unboxed.Mutable as UM
 import Data.Vector.Unboxing.Internal
+import Data.Vector.Unboxing.Instances ()
 import Control.Monad.ST
 import Control.Monad.Primitive (PrimMonad,PrimState)
 import Data.Coerce
diff --git a/test-gnd/Spec.hs b/test-gnd/Spec.hs
--- a/test-gnd/Spec.hs
+++ b/test-gnd/Spec.hs
@@ -1,13 +1,23 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE DerivingStrategies #-}
 {-# LANGUAGE UndecidableInstances #-}
 import Prelude
 import Test.HUnit
+import qualified Data.Vector.Generic as G
 import qualified Data.Vector.Unboxing as V
 import Data.Monoid (Sum(..))
+#if defined(ENABLE_MONO_TRAVERSABLE)
 import Data.MonoTraversable (ofold)
+#endif
 ---
 import Foo (Foo,mkFoo)
+
+#if !defined(ENABLE_MONO_TRAVERSABLE)
+-- Ad-hoc definition
+ofold :: (Monoid a, G.Vector v a) => v a -> a
+ofold = mconcat . G.toList
+#endif
 
 newtype IntMod17 = IntMod17 Int
   deriving (Eq,Show)
diff --git a/test/Spec.hs b/test/Spec.hs
--- a/test/Spec.hs
+++ b/test/Spec.hs
@@ -1,16 +1,26 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE UndecidableInstances #-}
 import Prelude
 import Test.HUnit
+import qualified Data.Vector.Generic as G
 import qualified Data.Vector.Unboxing as V
 import qualified Data.Vector.Unboxed
 import Data.Monoid (Sum(..))
+#if defined(ENABLE_MONO_TRAVERSABLE)
 import Data.MonoTraversable (ofold)
+#endif
 ---
 import TestTypeErrors
 import Foo (Foo,mkFoo)
+
+#if !defined(ENABLE_MONO_TRAVERSABLE)
+-- Ad-hoc definition
+ofold :: (Monoid a, G.Vector v a) => v a -> a
+ofold = mconcat . G.toList
+#endif
 
 testInt = TestCase $ do
   let v = V.fromList [2,-5,42] :: V.Vector Int
diff --git a/unboxing-vector.cabal b/unboxing-vector.cabal
--- a/unboxing-vector.cabal
+++ b/unboxing-vector.cabal
@@ -1,13 +1,13 @@
 cabal-version: 1.12
 
--- This file has been generated from package.yaml by hpack version 0.31.2.
+-- This file has been generated from package.yaml by hpack version 0.33.0.
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 8fec698d5a4391032074d2a71e767bc6f667b179e962ed429de29ca13c44b918
+-- hash: aab8ac481656db609980811ae840b2e93bd1beb65b3da7423f6086ef13d529ea
 
 name:           unboxing-vector
-version:        0.1.1.0
+version:        0.2.0.0
 synopsis:       A newtype-friendly variant of unboxed vectors
 description:    Please see the README on GitHub at <https://github.com/minoki/unboxing-vector#readme>
 category:       Data, Data Structures
@@ -15,7 +15,7 @@
 bug-reports:    https://github.com/minoki/unboxing-vector/issues
 author:         ARATA Mizuki <minorinoki@gmail.com>
 maintainer:     ARATA Mizuki <minorinoki@gmail.com>
-copyright:      2019 ARATA Mizuki
+copyright:      2020 ARATA Mizuki
 license:        BSD3
 license-file:   LICENSE
 build-type:     Simple
@@ -27,21 +27,30 @@
   type: git
   location: https://github.com/minoki/unboxing-vector
 
+flag mono-traversable
+  description: Define instances for MonoTraversable
+  manual: True
+  default: True
+
 library
   exposed-modules:
       Data.Vector.Unboxing
       Data.Vector.Unboxing.Mutable
   other-modules:
       Data.Vector.Unboxing.Internal
+      Data.Vector.Unboxing.Instances
   hs-source-dirs:
       src
   ghc-options: -Wall
   build-depends:
       base >=4.9 && <5
     , deepseq
-    , mono-traversable
     , primitive
     , vector
+  if flag(mono-traversable)
+    cpp-options: -DENABLE_MONO_TRAVERSABLE
+    build-depends:
+        mono-traversable
   default-language: Haskell2010
 
 test-suite unboxing-vector-test
@@ -59,11 +68,14 @@
       HUnit
     , base >=4.9 && <5
     , deepseq
-    , mono-traversable
     , primitive
     , should-not-typecheck
     , unboxing-vector
     , vector
+  if flag(mono-traversable)
+    cpp-options: -DENABLE_MONO_TRAVERSABLE
+    build-depends:
+        mono-traversable
   default-language: Haskell2010
 
 test-suite unboxing-vector-test-deriving-via
@@ -82,11 +94,14 @@
       HUnit
     , base >=4.9 && <5
     , deepseq
-    , mono-traversable
     , primitive
     , should-not-typecheck
     , unboxing-vector
     , vector
+  if flag(mono-traversable)
+    cpp-options: -DENABLE_MONO_TRAVERSABLE
+    build-depends:
+        mono-traversable
   if impl(ghc >= 8.6.1)
     buildable: True
   else
@@ -106,10 +121,13 @@
       HUnit
     , base >=4.9 && <5
     , deepseq
-    , mono-traversable
     , primitive
     , unboxing-vector
     , vector
+  if flag(mono-traversable)
+    cpp-options: -DENABLE_MONO_TRAVERSABLE
+    build-depends:
+        mono-traversable
   if impl(ghc >= 8.2.1)
     buildable: True
   else
@@ -128,8 +146,15 @@
   build-depends:
       base >=4.9 && <5
     , deepseq
-    , mono-traversable
     , primitive
     , unboxing-vector
     , vector
+  if flag(mono-traversable)
+    cpp-options: -DENABLE_MONO_TRAVERSABLE
+    build-depends:
+        mono-traversable
+  if impl(ghc >= 8.2.1)
+    buildable: True
+  else
+    buildable: False
   default-language: Haskell2010