Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell98 |
- type Byte = Word8
- data Bytes
- class Monoid a where
- unit :: Byte -> Bytes
- isEmpty :: Bytes -> Bool
- bytesLength :: Bytes -> Int
- writeBytes :: FilePath -> Bytes -> IO ()
- bytesFromList :: [Byte] -> Bytes
- listFromBytes :: Bytes -> [Byte]
- bytesFromString :: String -> Bytes
- stringFromBytes :: Bytes -> String
- bytesFromInt32 :: Int -> Bytes
- byteFromInt8 :: Int -> Byte
- readByteList :: FilePath -> IO [Byte]
- int32FromByteList :: [Byte] -> (Int, [Byte])
- stringFromByteList :: [Byte] -> String
- bytesFromByteList :: [Byte] -> Bytes
Documentation
class Monoid a where
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
mappend mempty x = x
mappend x mempty = x
mappend x (mappend y z) = mappend (mappend x y) z
mconcat =
foldr
mappend mempty
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Minimal complete definition: mempty
and mappend
.
Some types can be viewed as a monoid in more than one way,
e.g. both addition and multiplication on numbers.
In such cases we often define newtype
s and make those instances
of Monoid
, e.g. Sum
and Product
.
mempty :: a
Identity of mappend
mappend :: a -> a -> a
An associative operation
mconcat :: [a] -> a
Fold a list using the monoid.
For most types, the default definition for mconcat
will be
used, but the function is included in the class definition so
that an optimized version can be provided for specific types.
Monoid Ordering | |
Monoid () | |
Monoid All | |
Monoid Any | |
Monoid IntSet | |
Monoid Text | |
Monoid Text | |
Monoid Bytes | |
Monoid [a] | |
Monoid a => Monoid (Dual a) | |
Monoid (Endo a) | |
Num a => Monoid (Sum a) | |
Num a => Monoid (Product a) | |
Monoid (First a) | |
Monoid (Last a) | |
Monoid a => Monoid (Maybe a) | Lift a semigroup into |
Monoid (IntMap a) | |
Ord a => Monoid (Set a) | |
Monoid b => Monoid (a -> b) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid a => Monoid (Const a b) | |
Monoid (Proxy * s) | |
Typeable (* -> Constraint) Monoid | |
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) |
bytesLength :: Bytes -> Int Source
writeBytes :: FilePath -> Bytes -> IO () Source
bytesFromList :: [Byte] -> Bytes Source
listFromBytes :: Bytes -> [Byte] Source
bytesFromString :: String -> Bytes Source
stringFromBytes :: Bytes -> String Source
bytesFromInt32 :: Int -> Bytes Source
byteFromInt8 :: Int -> Byte Source
readByteList :: FilePath -> IO [Byte] Source
int32FromByteList :: [Byte] -> (Int, [Byte]) Source
stringFromByteList :: [Byte] -> String Source
bytesFromByteList :: [Byte] -> Bytes Source