diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+## 0.3.2
+
+- Add `(un)wrapFix/Mu/Nu`
+- Support `transformers-0.6`
+
+## 0.3.1
+
+- Update bounds for GHC-9.0
+
 ## 0.3.0
 
 - Rename `cata`, `ana` and `hylo` into `foldFix`, `unfoldFix` and `refold.
diff --git a/data-fix.cabal b/data-fix.cabal
--- a/data-fix.cabal
+++ b/data-fix.cabal
@@ -1,5 +1,5 @@
 Name:            data-fix
-Version:         0.3.1
+Version:         0.3.2
 Cabal-Version:   >= 1.10
 License:         BSD3
 License-file:    LICENSE
@@ -29,8 +29,9 @@
    || ==8.2.2
    || ==8.4.4
    || ==8.6.5
-   || ==8.8.3
-   || ==8.10.1
+   || ==8.8.4
+   || ==8.10.4
+   || ==9.0.1
 
 extra-source-files:
   CHANGELOG.md
@@ -64,5 +65,5 @@
 
   if !impl(ghc >=8.0)
     build-depends:
-        transformers         >=0.3   && <0.6
-      , transformers-compat  >=0.6.5 && <0.7
+        transformers         >=0.3   && <0.7
+      , transformers-compat  >=0.6.5 && <0.8
diff --git a/src/Data/Fix.hs b/src/Data/Fix.hs
--- a/src/Data/Fix.hs
+++ b/src/Data/Fix.hs
@@ -57,16 +57,22 @@
     hoistFix',
     foldFix,
     unfoldFix,
+    wrapFix,
+    unwrapFix,
     -- * Mu - least fixed point
     Mu (..),
     hoistMu,
     foldMu,
     unfoldMu,
+    wrapMu,
+    unwrapMu,
     -- * Nu - greatest fixed point
     Nu (..),
     hoistNu,
     foldNu,
     unfoldNu,
+    wrapNu,
+    unwrapNu,
     -- * Refolding
     refold,
     -- * Monadic variants
@@ -84,7 +90,7 @@
 import Prelude (Eq (..), Functor (..), Monad (..), Ord (..), Read (..), Show (..), showParen, showString, ($), (.), (=<<))
 
 #ifdef __GLASGOW_HASKELL__
-#if! HAS_POLY_TYPEABLE
+#if !HAS_POLY_TYPEABLE
 import Prelude (const, error, undefined)
 #endif
 #endif
@@ -110,7 +116,7 @@
 
 -- $setup
 -- >>> :set -XDeriveFunctor
--- >>> import Prelude (showChar, Int, Num (..))
+-- >>> import Prelude
 -- >>> import Data.Functor.Classes
 -- >>> data ListF a b = Nil | Cons a b deriving (Show, Functor)
 --
@@ -158,6 +164,28 @@
 unfoldFix :: Functor f => (a -> f a) -> a -> Fix f
 unfoldFix f = go where go = Fix . fmap go . f
 
+-- | Wrap 'Fix'.
+--
+-- >>> let x = unfoldFix (\i -> if i < 3 then Cons i (i + 1) else Nil) (0 :: Int)
+-- >>> wrapFix (Cons 10 x)
+-- Fix (Cons 10 (Fix (Cons 0 (Fix (Cons 1 (Fix (Cons 2 (Fix Nil))))))))
+--
+-- @since 0.3.2
+--
+wrapFix :: f (Fix f) -> Fix f
+wrapFix = Fix
+
+-- | Unwrap 'Fix'.
+--
+-- >>> let x = unfoldFix (\i -> if i < 3 then Cons i (i + 1) else Nil) (0 :: Int)
+-- >>> unwrapFix x
+-- Cons 0 (Fix (Cons 1 (Fix (Cons 2 (Fix Nil)))))
+--
+-- @since 0.3.2
+--
+unwrapFix :: Fix f -> f (Fix f)
+unwrapFix = unFix
+
 -------------------------------------------------------------------------------
 -- Functor instances
 -------------------------------------------------------------------------------
@@ -275,6 +303,28 @@
 unfoldMu :: Functor f => (a -> f a) -> a -> Mu f
 unfoldMu f x = Mu $ \mk -> refold mk f x
 
+-- | Wrap 'Mu'.
+--
+-- >>> let x = unfoldMu (\i -> if i < 3 then Cons i (i + 1) else Nil) (0 :: Int)
+-- >>> wrapMu (Cons 10 x)
+-- unfoldMu unFix (Fix (Cons 10 (Fix (Cons 0 (Fix (Cons 1 (Fix (Cons 2 (Fix Nil)))))))))
+--
+-- @since 0.3.2
+--
+wrapMu :: Functor f => f (Mu f) -> Mu f
+wrapMu fx = Mu $ \f -> f (fmap (foldMu f) fx)
+
+-- | Unwrap 'Mu'.
+--
+-- >>> let x = unfoldMu (\i -> if i < 3 then Cons i (i + 1) else Nil) (0 :: Int)
+-- >>> unwrapMu x
+-- Cons 0 (unfoldMu unFix (Fix (Cons 1 (Fix (Cons 2 (Fix Nil))))))
+--
+-- @since 0.3.2
+--
+unwrapMu :: Functor f => Mu f -> f (Mu f)
+unwrapMu = foldMu (fmap wrapMu)
+
 -------------------------------------------------------------------------------
 -- Nu
 -------------------------------------------------------------------------------
@@ -319,6 +369,28 @@
 -- unfoldNu unFix (Fix (Cons 0 (Fix (Cons 1 (Fix (Cons 2 (Fix (Cons 3 (Fix Nil)))))))))
 unfoldNu :: (a -> f a) -> a -> Nu f
 unfoldNu = Nu
+
+-- | Wrap 'Nu'.
+--
+-- >>> let x = unfoldNu (\i -> if i < 3 then Cons i (i + 1) else Nil) (0 :: Int)
+-- >>> wrapNu (Cons 10 x)
+-- unfoldNu unFix (Fix (Cons 10 (Fix (Cons 0 (Fix (Cons 1 (Fix (Cons 2 (Fix Nil)))))))))
+--
+-- @since 0.3.2
+--
+wrapNu :: Functor f => f (Nu f) -> Nu f
+wrapNu = unfoldNu (fmap unwrapNu)
+
+-- | Unwrap 'Nu'.
+--
+-- >>> let x = unfoldNu (\i -> if i < 3 then Cons i (i + 1) else Nil) (0 :: Int)
+-- >>> unwrapNu x
+-- Cons 0 (unfoldNu unFix (Fix (Cons 1 (Fix (Cons 2 (Fix Nil))))))
+--
+-- @since 0.3.2
+--
+unwrapNu :: Functor f => Nu f -> f (Nu f)
+unwrapNu (Nu f x) = fmap (Nu f) (f x)
 
 -------------------------------------------------------------------------------
 -- refold