    -- | @List@ functions with type limited to use @ListT@.
    -- This might come useful for type interference.
    --
    -- Functions where the @List@ is an input type and not only the result type do not need special limited versions.

    module Control.Monad.ListT.Funcs
        ( iterateM, repeatM, repeat, fromList
        ) where

    import Control.Monad.ListT (ListT)
    import qualified Data.List.Class as ListFuncs
    import Prelude hiding (repeat)

    iterateM :: Monad m => (a -> m a) -> m a -> ListT m a
    iterateM :: forall (m :: * -> *) a. Monad m => (a -> m a) -> m a -> ListT m a
    iterateM = (a -> m a) -> m a -> ListT m a
    (a -> ItemM (ListT m) a) -> ItemM (ListT m) a -> ListT m a
    forall (l :: * -> *) a.
    List l =>
    (a -> ItemM l a) -> ItemM l a -> l a
    ListFuncs.iterateM

    repeatM :: Monad m => m a -> ListT m a
    repeatM :: forall (m :: * -> *) a. Monad m => m a -> ListT m a
    repeatM = m a -> ListT m a
    ItemM (ListT m) a -> ListT m a
    forall (l :: * -> *) a. List l => ItemM l a -> l a
    ListFuncs.repeatM

    repeat :: Monad m => a -> ListT m a
    repeat :: forall (m :: * -> *) a. Monad m => a -> ListT m a
    repeat = a -> ListT m a
    forall (l :: * -> *) a. List l => a -> l a
    ListFuncs.repeat

    fromList :: Monad m => [a] -> ListT m a
    fromList :: forall (m :: * -> *) a. Monad m => [a] -> ListT m a
    fromList = [a] -> ListT m a
    forall (l :: * -> *) a. List l => [a] -> l a
    ListFuncs.fromList