diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 0.1.1.1
+
+- Adapted to the revised module structure of `monoidmap-internal-0.4.0.0`.
+  The API of `Data.MonoidMap` is unchanged.
+
 # 0.1.1.0
 
 - Moved the definitions of the `MonoidMap` type, its instances, and all of
diff --git a/components/monoidmap/Data/MonoidMap.hs b/components/monoidmap/Data/MonoidMap.hs
--- a/components/monoidmap/Data/MonoidMap.hs
+++ b/components/monoidmap/Data/MonoidMap.hs
@@ -167,14 +167,10 @@
     , traverse
     )
 
-import Data.MonoidMap.Internal
-    ( NonNull
-    , NonNullMap (..)
-    , applyNonNull
-    , applyNonNull2
-    , fromNonNullMap
-    , maybeNonNull
-    )
+import Data.MonoidMap.Internal.NonNull
+    ( NonNull )
+import Data.MonoidMap.Internal.NonNullMap
+    ( NonNullMap (..) )
 
 import Control.Applicative
     ( Applicative (..) )
@@ -250,7 +246,8 @@
 import qualified Data.Monoid.GCD as C
 import qualified Data.Monoid.LCM as C
 import qualified Data.Monoid.Null as C
-import qualified Data.MonoidMap.Internal as Internal
+import qualified Data.MonoidMap.Internal.NonNull as NonNull
+import qualified Data.MonoidMap.Internal.NonNullMap as NonNullMap
 import qualified Data.Semigroup.Cancellative as C
 import qualified Data.Set as Set
 import qualified Data.Traversable as Traversable
@@ -582,6 +579,17 @@
 -- Internal alias used when extra brevity is required.
 type MM = MonoidMap
 
+-- Internal conversions between 'MonoidMap' and 'NonNullMap', which have the
+-- same representation.
+
+fromNonNullMap :: NonNullMap k v -> MonoidMap k v
+fromNonNullMap (NonNullMap m) = MonoidMap m
+{-# INLINE fromNonNullMap #-}
+
+toNonNullMap :: MonoidMap k v -> NonNullMap k v
+toNonNullMap (MonoidMap m) = NonNullMap m
+{-# INLINE toNonNullMap #-}
+
 --------------------------------------------------------------------------------
 -- Instances
 --------------------------------------------------------------------------------
@@ -857,7 +865,7 @@
 -- @since 0.0.0.0
 --
 fromMap :: MonoidNull v => Map k v -> MonoidMap k v
-fromMap = MonoidMap . Internal.fromMap
+fromMap = fromNonNullMap . NonNullMap.fromMap
 {-# INLINABLE fromMap #-}
 
 -- | \(O(n)\). Constructs a 'MonoidMap' from an ordinary 'Map', applying
@@ -875,7 +883,7 @@
 -- @since 0.0.4.0
 --
 fromMapWith :: MonoidNull v2 => (v1 -> v2) -> Map k v1 -> MonoidMap k v2
-fromMapWith f = MonoidMap . Internal.fromMapWith f
+fromMapWith f = fromNonNullMap . NonNullMap.fromMapWith f
 {-# INLINABLE fromMapWith #-}
 
 -- | \(O(n)\). Constructs a 'MonoidMap' from a 'Set' and a function from
@@ -956,7 +964,7 @@
 -- @since 0.0.0.0
 --
 toMap :: MonoidMap k v -> Map k v
-toMap (MonoidMap m) = fromNonNullMap m
+toMap = NonNullMap.toMap . toNonNullMap
 {-# INLINE toMap #-}
 
 --------------------------------------------------------------------------------
@@ -992,7 +1000,7 @@
 -- @since 0.0.0.0
 --
 set :: (Ord k, MonoidNull v) => k -> v -> MonoidMap k v -> MonoidMap k v
-set k v (MonoidMap m) = MonoidMap $ case maybeNonNull v of
+set k v (MonoidMap m) = MonoidMap $ case NonNull.nonNull v of
     Just v0 -> Map.insert k v0 m
     Nothing -> Map.delete k    m
 
@@ -1013,7 +1021,7 @@
     -> MonoidMap k v
     -> MonoidMap k v
 adjust f k (MonoidMap m) = MonoidMap $
-    Map.alter (maybeNonNull . maybe (f mempty) (applyNonNull f)) k m
+    Map.alter (NonNull.nonNull . maybe (f mempty) (NonNull.apply f)) k m
 
 --------------------------------------------------------------------------------
 -- Nullification
@@ -1263,7 +1271,7 @@
 -- @since 0.0.0.0
 --
 filter :: (v -> Bool) -> MonoidMap k v -> MonoidMap k v
-filter f (MonoidMap m) = MonoidMap $ Map.filter (applyNonNull f) m
+filter f (MonoidMap m) = MonoidMap $ Map.filter (NonNull.apply f) m
 
 -- | \(O(n)\). Filters a map according to a predicate on /keys/.
 --
@@ -1310,7 +1318,7 @@
 --
 filterWithKey :: (k -> v -> Bool) -> MonoidMap k v -> MonoidMap k v
 filterWithKey f (MonoidMap m) =
-    MonoidMap $ Map.filterWithKey (applyNonNull . f) m
+    MonoidMap $ Map.filterWithKey (NonNull.apply . f) m
 
 --------------------------------------------------------------------------------
 -- Partitioning
@@ -1347,7 +1355,7 @@
 --
 partition :: (v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
 partition f (MonoidMap m) =
-    B.bimap MonoidMap MonoidMap $ Map.partition (applyNonNull f) m
+    B.bimap MonoidMap MonoidMap $ Map.partition (NonNull.apply f) m
 
 -- | \(O(n)\). Partitions a map according to a predicate on /keys/.
 --
@@ -1415,7 +1423,7 @@
 partitionWithKey
     :: (k -> v -> Bool) -> MonoidMap k v -> (MonoidMap k v, MonoidMap k v)
 partitionWithKey f (MonoidMap m) =
-    B.bimap MonoidMap MonoidMap $ Map.partitionWithKey (applyNonNull . f) m
+    B.bimap MonoidMap MonoidMap $ Map.partitionWithKey (NonNull.apply . f) m
 
 --------------------------------------------------------------------------------
 -- Mapping
@@ -1455,7 +1463,7 @@
     -> MonoidMap k v1
     -> MonoidMap k v2
 map f (MonoidMap m) =
-    MonoidMap $ Map.mapMaybe (maybeNonNull . applyNonNull f) m
+    MonoidMap $ Map.mapMaybe (NonNull.nonNull . NonNull.apply f) m
 
 -- | \(O(n \log n)\). Applies a function to all the keys of a 'MonoidMap' that
 --   are associated with non-'C.null' values.
@@ -1527,7 +1535,7 @@
 mapWithKey f (MonoidMap m) =
     MonoidMap . runIdentity $
     Map.traverseMaybeWithKey
-        (\k v -> Identity $ maybeNonNull $ applyNonNull (f k) v) m
+        (\k v -> Identity $ NonNull.nonNull $ NonNull.apply (f k) v) m
 
 --------------------------------------------------------------------------------
 -- Folding
@@ -1720,7 +1728,7 @@
 traverseWithKey f (MonoidMap m) =
     MonoidMap <$>
     Map.traverseMaybeWithKey
-        (\k v -> maybeNonNull <$> applyNonNull (f k) v) m
+        (\k v -> NonNull.nonNull <$> NonNull.apply (f k) v) m
 {-# INLINE traverseWithKey #-}
 
 -- | \(O(n)\). Threads an accumulating argument through the map in ascending
@@ -3944,7 +3952,7 @@
     -> WhenOneSideNull f k v1 v2
 withNonNull f
     = Map.mapMaybeMissing
-    $ \_k v -> maybeNonNull $ applyNonNull f v
+    $ \_k v -> NonNull.nonNull $ NonNull.apply f v
 {-# INLINE withNonNull #-}
 
 withNonNullA
@@ -3953,7 +3961,7 @@
     -> WhenOneSideNull f k v1 v2
 withNonNullA f
     = Map.traverseMaybeMissing
-    $ \_k v -> maybeNonNull <$> applyNonNull f v
+    $ \_k v -> NonNull.nonNull <$> NonNull.apply f v
 {-# INLINE withNonNullA #-}
 
 withBoth
@@ -3962,7 +3970,7 @@
     -> WhenBothNonNull f k v1 v2 v3
 withBoth f
     = Map.zipWithMaybeMatched
-    $ \_k v1 v2 -> maybeNonNull $ applyNonNull2 f v1 v2
+    $ \_k v1 v2 -> NonNull.nonNull $ NonNull.apply2 f v1 v2
 {-# INLINE withBoth #-}
 
 withBothA
@@ -3971,7 +3979,7 @@
     -> WhenBothNonNull f k v1 v2 v3
 withBothA f
     = Map.zipWithMaybeAMatched
-    $ \_k v1 v2 -> maybeNonNull <$> applyNonNull2 f v1 v2
+    $ \_k v1 v2 -> NonNull.nonNull <$> NonNull.apply2 f v1 v2
 {-# INLINE withBothA #-}
 
 --------------------------------------------------------------------------------
diff --git a/monoidmap.cabal b/monoidmap.cabal
--- a/monoidmap.cabal
+++ b/monoidmap.cabal
@@ -1,6 +1,6 @@
 cabal-version:  3.0
 name:           monoidmap
-version:        0.1.1.0
+version:        0.1.1.1
 homepage:       https://github.com/jonathanknowles/monoidmap
 bug-reports:    https://github.com/jonathanknowles/monoidmap/issues
 license:        Apache-2.0
@@ -32,7 +32,7 @@
 common dependency-monoid-subclasses
     build-depends:monoid-subclasses             >= 1.2.3      && < 1.3
 common dependency-monoidmap-internal
-    build-depends:monoidmap-internal            >= 0.3.0.0    && < 0.4
+    build-depends:monoidmap-internal            >= 0.4.0.0    && < 0.5
 common dependency-nothunks
     build-depends:nothunks                      >= 0.1.3      && < 0.4
 common dependency-pretty-show