Int -> [a] -> [[a]]

drop :: Int -> [a] -> [a]
base Prelude, base Data.List
drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs: > drop 6 "Hello World!" == "World!" > drop 3 [1,2,3,4,5] == [4,5] > drop 3 [1,2] == [] > drop 3 [] == [] > drop (-1) [1,2] == [1,2] > drop 0 [1,2] == [1,2] It is an instance of the more general Data.List.genericDrop, in which n may be of any integral type.
take :: Int -> [a] -> [a]
base Prelude, base Data.List
take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length xs: > take 5 "Hello World!" == "Hello" > take 3 [1,2,3,4,5] == [1,2,3] > take 3 [1,2] == [1,2] > take 3 [] == [] > take (-1) [1,2] == [] > take 0 [1,2] == [] It is an instance of the more general Data.List.genericTake, in which n may be of any integral type.
replicateM :: Monad m => Int -> m a -> m [a]
base Control.Monad
replicateM n act performs the action n times, gathering the results.
intersperse :: a -> [a] -> [a]
base Data.List
The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example, > intersperse ',' "abcde" == "a,b,c,d,e"
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.
number :: Int -> String -> String
QuickCheck Test.QuickCheck.Text
short :: Int -> String -> String
QuickCheck Test.QuickCheck.Text
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
base Data.List
The non-overloaded version of insert.
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
base Data.List
The deleteBy function behaves like delete, but takes a user-supplied equality predicate.
genericDrop :: Integral i => i -> [a] -> [a]
base Data.List
The genericDrop function is an overloaded version of drop, which accepts any Integral value as the number of elements to drop.
genericTake :: Integral i => i -> [a] -> [a]
base Data.List
The genericTake function is an overloaded version of take, which accepts any Integral value as the number of elements to take.
(++) :: [a] -> [a] -> [a]
base Prelude, base Data.List
Append two lists, i.e., > [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] > [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...] If the first list is not finite, the result is the first list.
chunksOf :: Int -> Text -> [Text]
text Data.Text
O(n) Splits a Text into components of length k. The last element may be shorter than the other chunks, depending on the length of the input. Examples: > chunksOf 3 "foobarbaz" == ["foo","bar","baz"] > chunksOf 4 "haskell.org" == ["hask","ell.","org"]
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The deleteFirstsBy function takes a predicate and two lists and returns the first list with the first occurrence of each element of the second list removed.
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The intersectBy function is the non-overloaded version of intersect.
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The unionBy function is the non-overloaded version of union.
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.
insert :: Ord a => a -> [a] -> [a]
base Data.List
The insert function takes an element and a list and inserts the element into the list at the last position or equal to the next element. In particular, if the list is sorted before the call, the result will also be sorted. It is a special case of insertBy, which allows the programmer to supply their own comparison function.
delete :: Eq a => a -> [a] -> [a]
base Data.List
delete x removes the first occurrence of x from its list argument. For example, > delete 'a' "banana" == "bnana" It is a special case of deleteBy, which allows the programmer to supply their own equality test.
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.
intercalate :: [a] -> [[a]] -> [a]
base Data.List
intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.
(<|>) :: Alternative f => f a -> f a -> f a
base Control.Applicative
mplus :: MonadPlus m => m a -> m a -> m a
base Control.Monad
(*>) :: Applicative f => f a -> f b -> f b
base Control.Applicative
getPath :: Node -> RTree -> Path
fgl Data.Graph.Inductive.Internal.RootPath
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.
(<*) :: Applicative f => f a -> f b -> f a
base Control.Applicative
replicateM_ :: Monad m => Int -> m a -> m ()
base Control.Monad
Like replicateM, but discards the result.
replace :: Eq a => a -> a -> [a] -> [a]
cgi Network.CGI.Protocol
Replaces all instances of a value in a list by another value.
renderHtmlWithLanguage :: HTML html => String -> html -> String
xhtml Text.XHtml.Strict
Outputs indented XHTML. Because space matters in HTML, the output is quite messy.
sp :: (Graph gr, Real b) => Node -> Node -> gr a b -> Path
fgl Data.Graph.Inductive.Query.SP
esp :: Graph gr => Node -> Node -> gr a b -> Path
fgl Data.Graph.Inductive.Query.BFS
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
base Prelude, base Data.List
zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.
(\\) :: Eq a => [a] -> [a] -> [a]
base Data.List
The \\ function is list difference ((non-associative). In the result of xs \\ ys, the first occurrence of each element of ys in turn (if any) has been removed from xs. Thus > (xs ++ ys) \\ xs == ys. It is a special case of deleteFirstsBy, which allows the programmer to supply their own equality test.
intersect :: Eq a => [a] -> [a] -> [a]
base Data.List
The intersect function takes the list intersection of two lists. For example, > [1,2,3,4] `intersect` [2,4,6,8] == [2,4] If the first list contains duplicates, so will the result. > [1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4] It is a special case of intersectBy, which allows the programmer to supply their own equality test.
union :: Eq a => [a] -> [a] -> [a]
base Data.List
The union function returns the list union of the two lists. For example, > "dog" `union` "cow" == "dogcw" Duplicates, and elements of the first list, are removed from the the second list, but if the first list contains duplicates, so will the result. It is a special case of unionBy, which allows the programmer to supply their own equality test.
qRecover :: Quasi m => m a -> m a -> m a
template-haskell Language.Haskell.TH.Syntax
(>>) :: Monad m => m a -> m b -> m b
base Prelude, base Control.Monad, base Control.Monad.Instances
msPath :: Real b => LRTree b -> Node -> Node -> Path
fgl Data.Graph.Inductive.Query.MST
enumFromThen :: Enum a => a -> a -> [a]
base Prelude
enumFromTo :: Enum a => a -> a -> [a]
base Prelude
ext0 :: (Typeable a, Typeable b) => c a -> c b -> c a
syb Data.Generics.Aliases
Flexible type extension
(<$) :: 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.
elemIndices :: Eq a => a -> [a] -> [Int]
base Data.List
The elemIndices function extends elemIndex, by returning the indices of all elements equal to the query element, in ascending order.
formatTime :: FormatTime t => TimeLocale -> String -> t -> String
time Data.Time.Format
Substitute various time-related information for each %-code in the string, as per formatCharacter. For all types (note these three are done here, not by formatCharacter): * %% % * %t tab * %n newline glibc-style modifiers can be used before the letter (here marked as z): * %-z no padding * %_z pad with spaces * %0z pad with zeros * %^z convert to upper case * %#z convert to lower case (consistently, unlike glibc) For TimeZone (and ZonedTime and UTCTime): * %z timezone offset in the format -HHMM. * %Z timezone name For LocalTime (and ZonedTime and UTCTime): * %c as dateTimeFmt locale (e.g. %a %b %e %H:%M:%S %Z %Y) For TimeOfDay (and LocalTime and ZonedTime and UTCTime): * %R same as %H:%M * %T same as %H:%M:%S * %X as timeFmt locale (e.g. %H:%M:%S) * %r as time12Fmt locale (e.g. %I:%M:%S %p) * %P day-half of day from (amPm locale), converted to lowercase, am, pm * %p day-half of day from (amPm locale), AM, PM * %H hour of day (24-hour), 0-padded to two chars, 00 - 23 * %k hour of day (24-hour), space-padded to two chars,  0 - 23 * %I hour of day-half (12-hour), 0-padded to two chars, 01 - 12 * %l hour of day-half (12-hour), space-padded to two chars,  1 - 12 * %M minute of hour, 0-padded to two chars, 00 - 59 * %S second of minute (without decimal part), 0-padded to two chars, 00 - 60 * %q picosecond of second, 0-padded to twelve chars, 000000000000 - 999999999999. * %Q decimal point and fraction of second, up to 12 second decimals, without trailing zeros. For a whole number of seconds, %Q produces the empty string. For UTCTime and ZonedTime: * %s number of whole seconds since the Unix epoch. For times before the Unix epoch, this is a negative number. Note that in %s.%q and %s%Q the decimals are positive, not negative. For example, 0.9 seconds before the Unix epoch is formatted as -1.1 with %s%Q. For Day (and LocalTime and ZonedTime and UTCTime): * %D same as %m/%d/%y * %F same as %Y-%m-%d * %x as dateFmt locale (e.g. %m/%d/%y) * %Y year, no padding. Note %0y and %_y pad to four chars * %y year of century, 0-padded to two chars, 00 - 99 * %C century, no padding. Note %0C and %_C pad to two chars * %B month name, long form (fst from months locale), January - December * %b, %h month name, short form (snd from months locale), Jan - Dec * %m month of year, 0-padded to two chars, 01 - 12 * %d day of month, 0-padded to two chars, 01 - 31 * %e day of month, space-padded to two chars,  1 - 31 * %j day of year, 0-padded to three chars, 001 - 366 * %G year for Week Date format, no padding. Note %0G and %_G pad to four chars * %g year of century for Week Date format, 0-padded to two chars, 00 - 99 * %f century for Week Date format, no padding. Note %0f and %_f pad to two chars * %V week of year for Week Date format, 0-padded to two chars, 01 - 53 * %u day of week for Week Date format, 1 - 7 * %a day of week, short form (snd from wDays locale), Sun - Sat * %A day of week, long form (fst from wDays locale), Sunday - Saturday * %U week of year sundayStartWeek), 0-padded to two chars, 00 - 53 * %w day of week number, 0 (= Sunday) - 6 (= Saturday) * %W week of year mondayStartWeek), 0-padded to two chars, 00 - 53
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
base Prelude, base Data.List
The zipWith3 function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to zipWith.
zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
base Control.Monad
The zipWithM function generalizes zipWith to arbitrary monads.
buf_toStr :: BufferOp a -> a -> String
HTTP Network.BufferType
enumFromThenTo :: Enum a => a -> a -> a -> [a]
base Prelude
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.
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
base Control.Applicative
Lift a binary function to actions.
foldM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m ()
base Control.Monad
Like foldM, but discards the result.
extR :: (Monad m, Typeable a, Typeable b) => m a -> m b -> m a
syb Data.Generics.Aliases
Extend a generic reader
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
base Control.Applicative
Lift a ternary function to actions.
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.
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.
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
base Control.Monad
Promote a function to a monad, scanning the monadic arguments from left to right. For example, > liftM2 (+) [0,1] [0,2] = [0,2,1,3] > liftM2 (+) (Just 1) Nothing = Nothing
zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
base Control.Monad
zipWithM_ is the extension of zipWithM which ignores the final result.
rangeFM :: Ord a => FiniteMap a b -> a -> a -> [b]
fgl Data.Graph.Inductive.Internal.FiniteMap
applies lookup to an interval

Show more results