diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,7 @@
+## 0.10.0
+
+* Remove `Functor` instance for `MinLen` [#82](https://github.com/snoyberg/mono-traversable/issues/82)
+
 ## 0.9.3
 
 * Added `intercalate`, `splitWhen`, `splitElem`, and `splitSeq` [#80](https://github.com/snoyberg/mono-traversable/pull/80)
diff --git a/mono-traversable.cabal b/mono-traversable.cabal
--- a/mono-traversable.cabal
+++ b/mono-traversable.cabal
@@ -1,5 +1,5 @@
 name:                mono-traversable
-version:             0.9.3
+version:             0.10.0
 synopsis:            Type classes for mapping, folding, and traversing monomorphic containers
 description:         Monomorphic variants of the Functor, Foldable, and Traversable typeclasses. If you understand Haskell's basic typeclasses, you understand mono-traversable. In addition to what you are used to, it adds on an IsSequence typeclass and has code for marking data structures as non-empty.
 homepage:            https://github.com/snoyberg/mono-traversable
diff --git a/src/Data/MinLen.hs b/src/Data/MinLen.hs
--- a/src/Data/MinLen.hs
+++ b/src/Data/MinLen.hs
@@ -162,7 +162,7 @@
 newtype MinLen nat mono =
     MinLen {
         unMinLen :: mono -- ^ Get the monomorphic container out of a 'MinLen' wrapper.
-    } deriving (Eq, Ord, Read, Show, Data, Typeable, Functor)
+    } deriving (Eq, Ord, Read, Show, Data, Typeable)
 
 type instance Element (MinLen nat mono) = Element mono
 deriving instance MonoFunctor mono => MonoFunctor (MinLen nat mono)
@@ -176,6 +176,9 @@
     {-# INLINE omapM #-}
 deriving instance GrowingAppend mono => GrowingAppend (MinLen nat mono)
 
+-- | This function is unsafe, and must not be exposed from this module.
+unsafeMap :: (mono -> mono) -> MinLen nat mono -> MinLen nat mono
+unsafeMap f (MinLen x) = MinLen (f x)
 
 instance GrowingAppend mono => Semigroup (MinLen nat mono) where
     MinLen x <> MinLen y = MinLen (x <> y)
@@ -183,12 +186,12 @@
 instance SemiSequence seq => SemiSequence (MinLen nat seq) where
     type Index (MinLen nat seq) = Index seq
 
-    intersperse e = fmap $ intersperse e
-    reverse       = fmap reverse
+    intersperse e = unsafeMap $ intersperse e
+    reverse       = unsafeMap reverse
     find f        = find f . unMinLen
-    cons x        = fmap $ cons x
-    snoc xs x     = fmap (flip snoc x) xs
-    sortBy f      = fmap $ sortBy f
+    cons x        = unsafeMap $ cons x
+    snoc xs x     = unsafeMap (flip snoc x) xs
+    sortBy f      = unsafeMap $ sortBy f
 
 instance MonoPointed mono => MonoPointed (MinLen Zero mono) where
     opoint = MinLen . opoint