group

group :: Eq a => [a] -> [[a]]
base Data.List
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 :: ByteString -> [ByteString]
bytestring Data.ByteString.Lazy, bytestring Data.ByteString.Lazy.Char8
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.
group :: ByteString -> [ByteString]
bytestring Data.ByteString, bytestring Data.ByteString.Char8
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 (==)
group :: Text -> [Text]
text Data.Text
O(n) Group characters in a string by equality.
group :: Text -> [Text]
text Data.Text.Lazy
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.
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
base Data.List
The groupBy function is the non-overloaded version of group.
groupBy :: (Char -> Char -> Bool) -> ByteString -> [ByteString]
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
The groupBy function is the non-overloaded version of group.
groupBy :: (Char -> Char -> Bool) -> Text -> [Text]
text Data.Text
O(n) Group characters in a string according to a predicate.
groupBy :: (Char -> Char -> Bool) -> Text -> [Text]
text Data.Text.Lazy
The groupBy function is the non-overloaded version of group.
groupBy :: (Word8 -> Word8 -> Bool) -> ByteString -> [ByteString]
bytestring Data.ByteString, bytestring Data.ByteString.Lazy
The groupBy function is the non-overloaded version of group.
groupExecuteMode :: FileMode
unix System.Posix.Files.ByteString, unix System.Posix.Files
Group has execute permission.
groupID :: GroupEntry -> GroupID
unix System.Posix.User
The unique numeric ID for this group (gr_gid)
groupMembers :: GroupEntry -> [String]
unix System.Posix.User
A list of zero or more usernames that are members (gr_mem)
groupModes :: FileMode
unix System.Posix.Files.ByteString, unix System.Posix.Files
Group has read, write and execute permission.
groupName :: GroupEntry -> String
unix System.Posix.User
The name of this group (gr_name)
package groupoid
package
A groupoid is structure consisting of a set of elements (here a Haskell type) and a binary operator (in present case the function gappend). It is comparable to the Monoid typeclass, but there is no obligation that the set supports a neutral element (mempty in Data.Monoid). In geometry, bounding boxes (represented as two points - bottom-left corner and top-right corner) give an example where a groupoid may be more satisfying than a monoid. The union operation on bounding boxes is essential to track the extent of shapes after their superimposition. To fit bounding box union into the Monoid typeclass one can do a clever trick representing mempty with the bottom-left corner at positive infinity and the top-right corner at negative infinity, the standard implementation of union which uses min and max will still proceed to identify the extreme corners correctly. This is nice enough if the bounding box coordinates are represented by Doubles, but a problem if they are Ints (say representing grid coordinates) - one might decide it is better simply to consider concrete bounding boxes and not their empty/infinite cousins. Version 0.1.0
package groupoids
package
This package has been absorbed into semigroupoids 4.0 Version 4.0
groupPassword :: GroupEntry -> String
unix System.Posix.User
The password for this group (gr_passwd)
groupReadMode :: FileMode
unix System.Posix.Files.ByteString, unix System.Posix.Files
Group has read permission.
package groups
package
Haskell 98 groups. A group is a monoid with invertibility. Version 0.4.0.0

Show more results