Int -> Get DataEntry -> Get [DataEntry]

Did you mean: Int -> RequestMethod -> RequestMethod

replicateM :: Monad m => Int -> m a -> m [a]
base Control.Monad
replicateM n act performs the action n times, gathering the results.
replicate :: Int -> a -> [a]
base Prelude, base Data.List
replicate n x is a list of length n with x the value of every element. It is an instance of the more general Data.List.genericReplicate, in which n may be of any integral type.
genericReplicate :: Integral i => i -> a -> [a]
base Data.List
The genericReplicate function is an overloaded version of replicate, which accepts any Integral value as the number of repetitions to make.
scanl :: (a -> b -> a) -> a -> [b] -> [a]
base Prelude, base Data.List
scanl is similar to foldl, but returns a list of successive reduced values from the left: > scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] Note that > last (scanl f z xs) == foldl f z xs.
scanr :: (a -> b -> b) -> b -> [a] -> [b]
base Prelude, base Data.List
scanr is the right-to-left dual of scanl. Note that > head (scanr f z xs) == foldr f z xs.
(<$) :: Functor f => a -> f b -> f a
base Data.Functor
(<$) :: Functor f => a -> f b -> f a
base Control.Applicative
Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.
foldlM :: (Foldable t, Monad m) => (a -> b -> m a) -> a -> t b -> m a
base Data.Foldable
Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.
foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
base Control.Monad
The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue commutative. > foldM f a1 [x1, x2, ..., xm] == > do > a2 <- f a1 x1 > a3 <- f a2 x2 > ... > f am xm If right-to-left evaluation is required, the input list should be reversed.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
base Data.Foldable
Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.
polymatchM :: (RegexLike a b, Monad m) => a -> b -> m b
regex-base Text.Regex.Base.Impl
matchM :: (RegexContext regex source target, Monad m) => regex -> source -> m target
regex-base Text.Regex.Base.RegexLike
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext Regex source1 target, Monad m) => source1 -> source -> m target
regex-posix Text.Regex.Posix.Wrap
makeRegexOptsM :: (RegexMaker regex compOpt execOpt source, Monad m) => compOpt -> execOpt -> source -> m regex
regex-base Text.Regex.Base.RegexLike