:: Int -> [a] -> [[a]] -package:combinatorial

chunksOf n splits a list into length-n pieces. The last piece will be shorter if n does not evenly divide the length of the list. If n <= 0, chunksOf n l returns an infinite list of empty lists.

>>> chunksOf 3 [1..12]
[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]

>>> chunksOf 3 "Hello there"
["Hel","lo ","the","re"]

>>> chunksOf 3 ([] :: [Int])
[]

Note that chunksOf n [] is [], not [[]]. This is intentional, and satisfies the property that

chunksOf n xs ++ chunksOf n ys == chunksOf n (xs ++ ys)

whenever n evenly divides the length of xs.

Produce all permutations of removing k elements from a list.

>>> removes 2 "abcdef"
["cdef","abef","abcd"]

Split a list into chunks of a given size. The last chunk may contain fewer than n elements. The chunk size must be positive.

chunksOf 3 "my test" == ["my ","tes","t"]
chunksOf 3 "mytest"  == ["myt","est"]
chunksOf 8 ""        == []
chunksOf 0 "test"    == undefined

>>> sliceHorizontal 6 ['a'..'z']
["agmsy","bhntz","ciou","djpv","ekqw","flrx"]

\(NonEmpty xs) -> QC.forAll (QC.choose (1, length xs)) $ \n -> sliceHorizontal n xs == transpose (sliceVertical n (xs::String))

\(NonEmpty xs) -> QC.forAll (QC.choose (1, length xs)) $ \n -> sliceVertical  n xs == transpose (sliceHorizontal n (xs::String))

The properties do not hold for empty lists because of:

>>> sliceHorizontal 4 ([]::[Int])
[[],[],[],[]]

>>> sliceVertical 6 ['a'..'z']
["abcdef","ghijkl","mnopqr","stuvwx","yz"]

Helper function to split a list in chunks Int length. Last chunk may be smaller.

Group a list of elements in the sublists of length i

Chop up a list in chunks of a given length. O(n).

Given a maximum length, splits a list into sublists

>>> chunksOf 5 (take 30 $ repeat 'a')
["aaaaa","aaaaa","aaaaa","aaaaa","aaaaa","aaaaa"]

Deprecated: Use XMonad.Prelude.chunksOf instead.

Split the list into lists of n elements where n is the first parameter. Can be used efficiently just for the finite lists. Contains the modified code of the unfoldr function from the base package.

O(n). Splits a list into components of the given length. The last element may be shorter than the other chunks, depending on the length of the input.

>>> listChunksOf 3 [0..7]
[[0,1,2],[3,4,5],[6,7]]

>>> listChunksOf 0 [0..10]
[]

>>> listChunksOf (-13) [0..10]
[]

>>> listChunksOf 100 [1,2,3]
[[1,2,3]]

>>> P.take 2 $ listChunksOf 3 [1..]
[[1,2,3],[4,5,6]]

chunksOf n splits a vector into length-n pieces. The last piece will be shorter if n does not evenly divide the length of the vector. If n <= 0, chunksOf n l returns an infinite list of empty vectors. For example: Note that chunksOf n [] is [], not [[]]. This is intentional, and is consistent with a recursive definition of chunksOf; it satisfies the property that

chunksOf n xs ++ chunksOf n ys == chunksOf n (xs ++ ys)

whenever n evenly divides the length of xs.

Generalized version of replicateConcurrently.

Generalized version of replicateConcurrently.

replicateM n act performs the action act n times, and then returns the list of results.

replicateM n (pure x) == replicate n x

Examples

>>> replicateM 3 getLine
hi
heya
hiya
["hi","heya","hiya"]

>>> import Control.Monad.State

>>> runState (replicateM 3 $ state $ \s -> (s, s + 1)) 1
([1,2,3],4)

replicateM n act performs the action act n times, and then returns the list of results:

Examples

>>> import Control.Monad.State

>>> runState (replicateM 3 $ state $ \s -> (s, s + 1)) 1
([1,2,3],4)

count n p parses n occurrences of p. If n is smaller or equal to zero, the parser equals to pure []. Returns a list of n parsed values.

count = replicateM

See also: skipCount, count'.

count n p parses n occurrences of p. If n is smaller or equal to zero, the parser equals to return []. Returns a list of n values returned by p.

replicateM n act performs the action n times, gathering the results. Using ApplicativeDo: 'replicateM 5 as' can be understood as the do expression

do a1 <- as
a2 <- as
a3 <- as
a4 <- as
a5 <- as
pure [a1,a2,a3,a4,a5]

Note the Applicative constraint.

replicateM n act performs the action n times, gathering the results.