group

The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result is non-empty, all elements are equal to the first one, and consecutive equal elements of the input end up in the same element of the output list. group is a special case of groupBy, which allows the programmer to supply their own equality test. It's often preferable to use Data.List.NonEmpty.group, which provides type-level guarantees of non-emptiness of inner lists. A common idiom to squash repeating elements map head . group is better served by map Data.List.NonEmpty.head . Data.List.NonEmpty.group because it avoids partial functions.

Examples

>>> group "Mississippi"
["M","i","ss","i","ss","i","pp","i"]

>>> group [1, 1, 1, 2, 2, 3, 4, 5, 5]
[[1,1,1],[2,2],[3],[4],[5,5]]

The group function takes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements, and consecutive equal elements of the input end up in the same stream of the output list. For example, in list notation:

>>> group "Mississippi"
['M' :| "",'i' :| "",'s' :| "s",'i' :| "",'s' :| "s",'i' :| "",'p' :| "p",'i' :| ""]

The group function takes a ByteString and returns a list of ByteStrings such that the concatenation of the result is equal to the argument. Moreover, each string in the result contains only equal elements. For example,

group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test. It is about 40% faster than groupBy (==)

The group function takes a ByteString and returns a list of ByteStrings such that the concatenation of the result is equal to the argument. Moreover, each string in the result contains only equal elements. For example,

group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test.

O(n) Group characters in a string by equality.

The group function takes a Text and returns a list of Texts such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test.

O(n) Split a vector into a list of slices of the input vector. The concatenation of this list of slices is equal to the argument vector, and each slice contains only equal elements. Does not fuse. This is the equivalent of 'groupBy (==)'.

>>> import qualified Data.Vector as V

>>> V.group (V.fromList "Mississippi")
["M","i","ss","i","ss","i","pp","i"]

See also group.

O(n) Split a vector into a list of slices. The concatenation of this list of slices is equal to the argument vector, and each slice contains only equal elements. This is the equivalent of 'groupBy (==)'.

>>> import qualified Data.Vector.Strict as V

>>> V.group (V.fromList "Mississippi")
["M","i","ss","i","ss","i","pp","i"]

See also group.

O(n) Split a vector into a list of slices of the input vector. The concatenation of this list of slices is equal to the argument vector, and each slice contains only equal elements. Does not fuse. This is the equivalent of 'groupBy (==)'.

>>> import qualified Data.Vector.Primitive as VP

>>> VP.group (VP.fromList "Mississippi")
["M","i","ss","i","ss","i","pp","i"]

See also group.

O(n) Split a vector into a list of slices of the input vector. The concatenation of this list of slices is equal to the argument vector, and each slice contains only equal elements. Does not fuse. This is the equivalent of 'groupBy (==)'.

>>> import qualified Data.Vector.Storable as VS

>>> VS.group (VS.fromList "Mississippi")
["M","i","ss","i","ss","i","pp","i"]

See also group.

O(n) Split a vector into a list of slices of the input vector. The concatenation of this list of slices is equal to the argument vector, and each slice contains only equal elements. Does not fuse. This is the equivalent of 'groupBy (==)'.

>>> import qualified Data.Vector.Unboxed as VU

>>> VU.group (VU.fromList "Mississippi")
["M","i","ss","i","ss","i","pp","i"]

See also group.

(group x) tries laying out x into a single line by removing the contained line breaks; if this does not fit the page, or when a hardline within x prevents it from being flattened, x is laid out without any changes. The group function is key to layouts that adapt to available space nicely. See vcat, line, or flatAlt for examples that are related, or make good use of it.

The group function takes a stream and returns a list of streams such that flattening the resulting list is equal to the argument. Moreover, each stream in the resulting list contains only equal elements. For example, in list notation:

'group' $ 'cycle' "Mississippi"
= "M" : "i" : "ss" : "i" : "ss" : "i" : "pp" : "i" : "M" : "i" : ...

Divides a list into sublists such that the members in a sublist share the same key. It uses semantics of groupBy, not that of groupBy.

The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result is non-empty and all elements are equal to the first one. group is a special case of groupBy, which allows the programmer to supply their own equality test. It's often preferable to use Data.List.NonEmpty.group, which provides type-level guarantees of non-emptiness of inner lists.

Examples

>>> group "Mississippi"
["M","i","ss","i","ss","i","pp","i"]

>>> group [1, 1, 1, 2, 2, 3, 4, 5, 5]
[[1,1,1],[2,2],[3],[4],[5,5]]

Group successive equal items together

>>> S.toList $ mapped S.toList $ S.group $ each "baaaaad"
["b","aaaaa","d"] :> ()

>>> S.toList $ concats $ maps (S.drained . S.splitAt 1) $ S.group $ each "baaaaaaad"
"bad" :> ()

The group function takes a ByteString and returns a list of ByteStrings such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test. It is about 40% faster than groupBy (==)

The group function takes a ByteString and returns a list of ByteStrings such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

group "Mississippi" = ["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test.

The group function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example,

>>> group "Mississippi"
["M","i","ss","i","ss","i","pp","i"]

It is a special case of groupBy, which allows the programmer to supply their own equality test.

Group a set of related code.

Equivalent to groupBy (==)

Like groupBy, where the equality predicate is (==)

The group combinator is used to specify alternative layouts. The document (group x) undoes all line breaks in document x. The resulting line is added to the current line if that fits the page. Otherwise, the document x is rendered without any changes.