diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,16 @@
 CHANGES
 =======
 
-### 4.7.5
+### 4.7.7 (2022-05-26)
 
+  - methods `sequence` and `mapM`: relax `Monad` constraint to `Applicative`
+  - `LANGUAGE TypeOperators` to fix GHC 9.4 warning
+  - allow `text-2.0`
+  - tested with GHC 7.10 - 9.4
+
+### 4.7.6 (2021-09-01)
+
+  - new implementation of `tail` in `DList` instance
   - warning-free for `-Wall` and `-Wcompat`
 
 ### 4.7.4 (2021-01-07)
diff --git a/ListLike.cabal b/ListLike.cabal
--- a/ListLike.cabal
+++ b/ListLike.cabal
@@ -1,5 +1,5 @@
 Name: ListLike
-Version: 4.7.6
+Version: 4.7.7
 License: BSD3
 Maintainer: David Fox <dsf@seereason.com>, Andreas Abel
 Author: John Goerzen
@@ -23,8 +23,10 @@
 Stability: Stable
 
 Tested-With:
-  GHC == 9.0.1
-  GHC == 8.10.4
+  GHC == 9.4.1
+  GHC == 9.2.2
+  GHC == 9.0.2
+  GHC == 8.10.7
   GHC == 8.8.4
   GHC == 8.6.5
   GHC == 8.4.4
@@ -66,7 +68,7 @@
                 ,containers >= 0.3   && < 0.7
                 ,bytestring >= 0.9.1 && < 0.12
                 ,array      >= 0.3   && < 0.6
-                ,text       >= 0.11  && < 1.3
+                ,text       >= 0.11  && < 1.3  || == 2.0.*
                 ,vector     >= 0.5   && < 0.13
                 ,dlist      >= 0.7   && < 1.1
                 ,fmlist     >= 0.8   && < 0.10
@@ -84,7 +86,7 @@
   -- Since ListLike defines orphan instances, we would need to include
   -- the minor version number in the upper bounds.
   -- (See issues #7 and #10.)
-  -- However, this could involve a maintenance to relax upper bounds.
+  -- However, this could involve a maintenance marathon to relax upper bounds.
 
   If !impl(ghc >= 8.4)
     Build-Depends: semigroups >= 0.16 && < 0.20
diff --git a/src/Data/ListLike/Base.hs b/src/Data/ListLike/Base.hs
--- a/src/Data/ListLike/Base.hs
+++ b/src/Data/ListLike/Base.hs
@@ -7,6 +7,7 @@
             ,FlexibleContexts
             ,ConstraintKinds
             ,CPP #-}
+{-# LANGUAGE TypeOperators #-}  -- for GHC >= 9.4
 
 {-
 Copyright (C) 2007 John Goerzen <jgoerzen@complete.org>
@@ -38,19 +39,24 @@
     InfiniteListLike(..),
     zip, zipWith, sequence_
     ) where
-import Prelude hiding (length, {-uncons,-} head, last, null, tail, map, filter, concat,
-                       any, lookup, init, all, foldl, foldr, foldl1, foldr1,
-                       maximum, minimum, iterate, span, break, takeWhile,
-                       dropWhile, {-dropWhileEnd,-} reverse, zip, zipWith, sequence,
-                       sequence_, mapM, mapM_, concatMap, and, or, sum,
-                       product, repeat, replicate, cycle, take, drop,
-                       splitAt, elem, notElem, unzip, lines, words,
-                       unlines, unwords, foldMap)
+
+import Prelude
+  ( Applicative(..), Bool(..), Eq(..), Int, Integer, Integral
+  , Maybe(..), Monad, Monoid(..), Num(..), Ord(..), Ordering(..)
+  , ($), (.), (&&), (||), (++), asTypeOf, error, flip, fst, snd
+  , id, maybe, max, min, not, otherwise
+  , sequenceA
+  )
+#if MIN_VERSION_base(4,17,0)
+import Data.Type.Equality -- GHC 9.4: type equality ~ is just an operator now
+#endif
+
 import qualified Data.List as L
 import Data.ListLike.FoldableLL
-import qualified Control.Monad as M
-import Data.Monoid
-import Data.Maybe
+    ( FoldableLL(foldr, foldr1, foldl), fold, foldMap, sequence_ )
+import qualified Control.Applicative as A
+import Data.Monoid ( All(All, getAll), Any(Any, getAny) )
+import Data.Maybe ( listToMaybe )
 import GHC.Exts (IsList(Item, fromList, {-fromListN,-} toList))
 
 {- | The class implementing list-like functions.
@@ -364,18 +370,14 @@
 
     ------------------------------ Monadic operations
     {- | Evaluate each action in the sequence and collect the results -}
-    sequence :: (Monad m, ListLike fullinp (m item)) =>
+    sequence :: (Applicative m, ListLike fullinp (m item)) =>
                 fullinp -> m full
-    sequence l = foldr func (return empty) l
-        where func litem results =
-                do x <- litem
-                   xs <- results
-                   return (cons x xs)
+    sequence = foldr (A.liftA2 cons) (pure empty)
 
     {- | A map in monad space.  Same as @'sequence' . 'map'@
 
          See also 'rigidMapM' -}
-    mapM :: (Monad m, ListLike full' item') =>
+    mapM :: (Applicative m, ListLike full' item') =>
             (item -> m item') -> full -> m full'
     mapM func l = sequence mapresult
             where mapresult = asTypeOf (map func l) []
@@ -550,13 +552,13 @@
         | count <= 0 = empty
         | otherwise = map (\_ -> x) [1..count]
 
-#if __GLASGOW_HASKELL__ >= 708
+
     {-# MINIMAL (singleton, uncons, null) |
                 (singleton, uncons, genericLength) |
                 (singleton, head, tail, null) |
                 (singleton, head, tail, genericLength) #-}
-#endif
 
+
 -- | A version of 'ListLike' with a single type parameter, the item
 -- type is obtained using the 'Item' type function from 'IsList'.
 type ListOps full = (ListLike full (Item full))
@@ -646,7 +648,7 @@
     elemIndex = L.elemIndex
     elemIndices item = fromList . L.elemIndices item
     findIndex = L.findIndex
-    sequence = M.sequence . toList
+    sequence = sequenceA . toList
     -- mapM = M.mapM
     nub = L.nub
     delete = L.delete
@@ -671,7 +673,7 @@
           ListLike fullb itemb,
           ListLike result (item, itemb)) =>
           full -> fullb -> result
-zip = zipWith (\a b -> (a, b))
+zip = zipWith (,)
 
 {- | Takes two lists and combines them with a custom combining function -}
 zipWith :: (ListLike full item,
diff --git a/src/Data/ListLike/Instances.hs b/src/Data/ListLike/Instances.hs
--- a/src/Data/ListLike/Instances.hs
+++ b/src/Data/ListLike/Instances.hs
@@ -4,6 +4,9 @@
             ,TypeFamilies
             ,TypeSynonymInstances #-}
 {-# OPTIONS -fno-warn-orphans #-}
+#if __GLASGOW_HASKELL__ > 901
+{-# OPTIONS -fno-warn-incomplete-uni-patterns #-}
+#endif
 
 {-
 Copyright (C) 2007 John Goerzen <jgoerzen@complete.org>
@@ -39,7 +42,6 @@
                        splitAt, elem, notElem, unzip, lines, words,
                        unlines, unwords)
 import qualified Prelude as P
-import           Control.Monad
 import qualified Data.List as L
 import qualified Data.Sequence as S
 import           Data.Sequence ((><), (|>), (<|))
@@ -188,8 +190,8 @@
     findIndices x = fromList . BS.findIndices x
     -- the default definitions don't work well for array-like things, so
     -- do monadic stuff via a list instead
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
     --nub = BS.nub
     --delete = BS.delete
     --deleteFirsts = BS.deleteFirsts
@@ -311,8 +313,8 @@
     --elemIndices x = fromList . L.map fromIntegral . BSL.elemIndices x
     findIndex f = mi64toi . BSL.findIndex f
     --findIndices x = fromList . L.map fromIntegral . BSL.findIndices x
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
     --sequence = BSL.sequence
     --mapM = BSL.mapM
     --mapM_ = BSL.mapM_
@@ -460,8 +462,8 @@
     elemIndices i = fromList . L.elemIndices i . toList
     findIndex f = L.findIndex f . toList
     findIndices f = fromList . L.findIndices f . toList
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
     -- rigidMapM = mapM
     nub = fromList . L.nub . toList
     -- delete
diff --git a/src/Data/ListLike/Text/Text.hs b/src/Data/ListLike/Text/Text.hs
--- a/src/Data/ListLike/Text/Text.hs
+++ b/src/Data/ListLike/Text/Text.hs
@@ -7,7 +7,6 @@
 where
 
 import           Prelude as P
-import           Control.Monad
 import qualified Data.Text as T
 import qualified Data.Text.IO as TI
 import qualified Data.Text.Lazy as Lazy (toStrict)
@@ -78,8 +77,8 @@
     genericSplitAt i = T.splitAt (fromIntegral i)
     genericReplicate i = LL.replicate (fromIntegral i)
 
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
 
 instance ListLikeIO T.Text Char where
     hGetLine = TI.hGetLine
diff --git a/src/Data/ListLike/Text/TextLazy.hs b/src/Data/ListLike/Text/TextLazy.hs
--- a/src/Data/ListLike/Text/TextLazy.hs
+++ b/src/Data/ListLike/Text/TextLazy.hs
@@ -7,7 +7,6 @@
 where
 
 import           Prelude as P
-import           Control.Monad
 import qualified Data.Text.Lazy as T
 import qualified Data.Text.Lazy.IO as TI
 import           Data.Text.Encoding (decodeUtf8)
@@ -75,8 +74,8 @@
     genericSplitAt i = T.splitAt (fromIntegral i)
     genericReplicate i = LL.replicate (fromIntegral i)
 
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
 
 instance ListLikeIO T.Text Char where
     hGetLine = TI.hGetLine
diff --git a/src/Data/ListLike/UTF8.hs b/src/Data/ListLike/UTF8.hs
--- a/src/Data/ListLike/UTF8.hs
+++ b/src/Data/ListLike/UTF8.hs
@@ -108,8 +108,8 @@
     -- findIndices x = fromList . UTF8.findIndices x
     -- -- the default definitions don't work well for array-like things, so
     -- -- do monadic stuff via a list instead
-    -- sequence  = liftM fromList . P.sequence  . toList
-    -- mapM func = liftM fromList . P.mapM func . toList
+    -- sequence  = fmap fromList . P.sequenceA  . toList
+    -- mapM func = fmap fromList . P.traverse func . toList
     -- --nub = UTF8.nub
     -- --delete = UTF8.delete
     -- --deleteFirsts = UTF8.deleteFirsts
@@ -231,8 +231,8 @@
     -- findIndices x = fromList . UTF8.findIndices x
     -- -- the default definitions don't work well for array-like things, so
     -- -- do monadic stuff via a list instead
-    -- sequence  = liftM fromList . P.sequence  . toList
-    -- mapM func = liftM fromList . P.mapM func . toList
+    -- sequence  = fmap fromList . P.sequenceA  . toList
+    -- mapM func = fmap fromList . P.traverse func . toList
     -- --nub = UTF8.nub
     -- --delete = UTF8.delete
     -- --deleteFirsts = UTF8.deleteFirsts
diff --git a/src/Data/ListLike/Vector/Generic.hs b/src/Data/ListLike/Vector/Generic.hs
--- a/src/Data/ListLike/Vector/Generic.hs
+++ b/src/Data/ListLike/Vector/Generic.hs
@@ -4,6 +4,7 @@
             ,FlexibleInstances
             ,TypeFamilies
             ,UndecidableInstances #-}
+{-# LANGUAGE TypeOperators #-}  -- for GHC >= 9.4
 #if __GLASGOW_HASKELL__ < 710
 {-# LANGUAGE OverlappingInstances #-}
 #endif
@@ -17,7 +18,6 @@
 where
 
 import           Prelude as P
-import           Control.Monad
 import qualified Data.Vector.Generic as V
 import           Data.Vector.Generic ((!))
 import           Data.ListLike.Base
@@ -90,8 +90,8 @@
     --genericSplitAt i =
     genericReplicate i = V.replicate (fromIntegral i)
 
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
 
 instance (Eq (v Char), V.Vector v Char) => IsString (v Char) where
     fromString = V.fromList
diff --git a/src/Data/ListLike/Vector/Storable.hs b/src/Data/ListLike/Vector/Storable.hs
--- a/src/Data/ListLike/Vector/Storable.hs
+++ b/src/Data/ListLike/Vector/Storable.hs
@@ -8,7 +8,6 @@
 where
 
 import           Prelude as P
-import           Control.Monad
 import qualified Data.Vector.Storable as V
 import           Data.Vector.Storable ((!))
 import           Data.ListLike.Base
@@ -76,8 +75,8 @@
     --genericSplitAt i =
     genericReplicate i = V.replicate (fromIntegral i)
 
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
 
 instance IsString (V.Vector Char) where
     fromString = fromList
diff --git a/src/Data/ListLike/Vector/Unboxed.hs b/src/Data/ListLike/Vector/Unboxed.hs
--- a/src/Data/ListLike/Vector/Unboxed.hs
+++ b/src/Data/ListLike/Vector/Unboxed.hs
@@ -8,7 +8,6 @@
 where
 
 import           Prelude as P
-import           Control.Monad
 import qualified Data.Vector.Unboxed as V
 import           Data.Vector.Unboxed (Unbox, (!))
 import           Data.ListLike.Base
@@ -74,8 +73,8 @@
     --genericSplitAt i =
     genericReplicate i = V.replicate (fromIntegral i)
 
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
 
 instance IsString (V.Vector Char) where
     fromString = fromList
diff --git a/src/Data/ListLike/Vector/Vector.hs b/src/Data/ListLike/Vector/Vector.hs
--- a/src/Data/ListLike/Vector/Vector.hs
+++ b/src/Data/ListLike/Vector/Vector.hs
@@ -8,7 +8,6 @@
 where
 
 import           Prelude as P
-import           Control.Monad
 import qualified Data.Vector as V
 import           Data.Vector ((!))
 import           Data.ListLike.Base
@@ -73,8 +72,8 @@
     --genericSplitAt i =
     genericReplicate i = V.replicate (fromIntegral i)
 
-    sequence  = liftM fromList . P.sequence  . toList
-    mapM func = liftM fromList . P.mapM func . toList
+    sequence  = fmap fromList . P.sequenceA  . toList
+    mapM func = fmap fromList . P.traverse func . toList
 
 instance IsString (V.Vector Char) where
     fromString = fromList