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.4.0.1
+version:             0.4.0.2
 synopsis:            Type classes for mapping, folding, and traversing monomorphic containers
 description:         Monomorphic variants of the Functor, Foldable, and Traversable typeclasses. Contains even more experimental code for abstracting containers and sequences.
 homepage:            https://github.com/snoyberg/mono-traversable
@@ -33,6 +33,8 @@
                      , comonad >=3.0.3
                      , vector-instances
                      , vector-algorithms >= 0.6
+                     , dlist >= 0.6 && < 1.0
+                     , dlist-instances == 0.1.*
   hs-source-dirs:      src
   default-language:    Haskell2010
 
diff --git a/src/Data/GrowingAppend.hs b/src/Data/GrowingAppend.hs
--- a/src/Data/GrowingAppend.hs
+++ b/src/Data/GrowingAppend.hs
@@ -19,6 +19,8 @@
 import qualified Data.HashSet as HashSet
 import qualified Data.IntSet as IntSet
 import qualified Data.IntMap as IntMap
+import qualified Data.DList as DList
+import Data.DList.Instances ()
 
 -- | olength (x <> y) >= olength x + olength y
 class (Semigroup mono, MonoFoldable mono) => GrowingAppend mono
@@ -39,3 +41,4 @@
 instance (Eq v, Hashable v) => GrowingAppend (HashSet.HashSet v)
 instance GrowingAppend IntSet.IntSet
 instance GrowingAppend (IntMap.IntMap v)
+instance GrowingAppend (DList.DList a)
diff --git a/src/Data/MinLen.hs b/src/Data/MinLen.hs
--- a/src/Data/MinLen.hs
+++ b/src/Data/MinLen.hs
@@ -47,6 +47,7 @@
 import Data.Monoid (Monoid (..))
 import Data.Semigroup (Semigroup (..))
 import Data.GrowingAppend
+import Control.Monad (liftM)
 
 -- Type level naturals
 data Zero = Zero
@@ -77,7 +78,11 @@
 deriving instance MonoFunctor mono => MonoFunctor (MinLen nat mono)
 deriving instance MonoFoldable mono => MonoFoldable (MinLen nat mono)
 deriving instance MonoFoldableOrd mono => MonoFoldableOrd (MinLen nat mono)
-deriving instance MonoTraversable mono => MonoTraversable (MinLen nat mono)
+instance MonoTraversable mono => MonoTraversable (MinLen nat mono) where
+    otraverse f (MinLen x) = fmap MinLen (otraverse f x)
+    {-# INLINE otraverse #-}
+    omapM f (MinLen x) = liftM MinLen (omapM f x)
+    {-# INLINE omapM #-}
 deriving instance GrowingAppend mono => GrowingAppend (MinLen nat mono)
 
 
diff --git a/src/Data/MonoTraversable.hs b/src/Data/MonoTraversable.hs
--- a/src/Data/MonoTraversable.hs
+++ b/src/Data/MonoTraversable.hs
@@ -85,6 +85,8 @@
 import qualified Data.IntSet as IntSet
 import Data.Semigroup (Semigroup, Option (..))
 import qualified Data.ByteString.Unsafe as SU
+import Data.DList (DList)
+import qualified Data.DList as DL
 
 type family Element mono
 type instance Element S.ByteString = Word8
@@ -97,6 +99,7 @@
 type instance Element (Maybe a) = a
 type instance Element (Tree a) = a
 type instance Element (Seq a) = a
+type instance Element (DList a) = a
 type instance Element (ViewL a) = a
 type instance Element (ViewR a) = a
 type instance Element (IntMap a) = a
@@ -161,6 +164,7 @@
 instance MonoFunctor (Maybe a)
 instance MonoFunctor (Tree a)
 instance MonoFunctor (Seq a)
+instance MonoFunctor (DList a)
 instance MonoFunctor (ViewL a)
 instance MonoFunctor (ViewR a)
 instance MonoFunctor (IntMap a)
@@ -501,6 +505,12 @@
     {-# INLINE unsafeHead #-}
 instance MonoFoldable (Set e)
 instance MonoFoldable (HashSet e)
+instance MonoFoldable (DList a) where
+    otoList = DL.toList
+    headEx = DL.head
+    {-# INLINE otoList #-}
+    {-# INLINE headEx #-}
+
 instance U.Unbox a => MonoFoldable (U.Vector a) where
     ofoldMap f = ofoldr (mappend . f) mempty
     ofoldr = U.foldr
@@ -799,6 +809,9 @@
 instance MonoTraversable (IntMap a)
 instance MonoTraversable (Option a)
 instance MonoTraversable (NonEmpty a)
+instance MonoTraversable (DList a) where
+     otraverse f = fmap DL.fromList . traverse f . DL.toList
+     omapM f = liftM DL.fromList . mapM f . DL.toList
 instance MonoTraversable (Identity a)
 instance MonoTraversable (Map k v)
 instance MonoTraversable (HashMap k v)
@@ -896,6 +909,9 @@
     {-# INLINE opoint #-}
 instance MonoPointed (Set a) where
     opoint = Set.singleton
+    {-# INLINE opoint #-}
+instance MonoPointed (DList a) where
+    opoint = DL.singleton
     {-# INLINE opoint #-}
 instance Hashable a => MonoPointed (HashSet a) where
     opoint = HashSet.singleton
diff --git a/src/Data/Sequences.hs b/src/Data/Sequences.hs
--- a/src/Data/Sequences.hs
+++ b/src/Data/Sequences.hs
@@ -21,6 +21,7 @@
 import Control.Arrow ((***), first, second)
 import Control.Monad (liftM)
 import qualified Data.Sequence as Seq
+import qualified Data.DList as DList
 import qualified Data.Vector as V
 import qualified Data.Vector.Unboxed as U
 import qualified Data.Vector.Storable as VS
@@ -631,6 +632,30 @@
     {-# INLINE initEx #-}
     {-# INLINE unsafeTail #-}
     {-# INLINE unsafeInit #-}
+
+instance SemiSequence (DList.DList a) where
+    type Index (DList.DList a) = Int
+    cons = DList.cons
+    snoc = DList.snoc
+
+    reverse = defaultReverse
+    sortBy = defaultSortBy
+    intersperse = defaultIntersperse
+    find = defaultFind
+    {-# INLINE intersperse #-}
+    {-# INLINE reverse #-}
+    {-# INLINE find #-}
+    {-# INLINE sortBy #-}
+    {-# INLINE cons #-}
+    {-# INLINE snoc #-}
+
+instance IsSequence (DList.DList a) where
+    fromList = DList.fromList
+    replicate = DList.replicate
+    tailEx = DList.tail
+    {-# INLINE fromList #-}
+    {-# INLINE replicate #-}
+    {-# INLINE tailEx #-}
 
 instance SemiSequence (V.Vector a) where
     type Index (V.Vector a) = Int