Lvm.Common.Byte

Documentation

type Byte = Word8

data Bytes

Instances

Eq Bytes

Show Bytes

Monoid Bytes

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 newtypes and make those instances of Monoid, e.g. Sum and Product.

Minimal complete definition

mempty, mappend

Methods

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.

Instances

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 Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S." Since there is no "Semigroup" typeclass providing just mappend, we use Monoid instead.

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)

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