Safe Haskell	None
Language	Haskell98

Text.ProtocolBuffers.Basic

Contents

Basic types for protocol buffer fields in Haskell
Haskell types that act in the place of DescritorProto values
Some of the type classes implemented messages and fields

Description

Text.ProtocolBuffers.Basic defines or re-exports most of the basic field types; Maybe,Bool, Double, and Float come from the Prelude instead. This module also defines the Mergeable and Default classes. The Wire class is not defined here to avoid orphans.

Synopsis

Basic types for protocol buffer fields in Haskell

data Double :: * #

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double
Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Floating Double	Since: 2.1
Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
Data Double	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double # toConstr :: Double -> Constr # dataTypeOf :: Double -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Double) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) # gmapT :: (forall b. Data b => b -> b) -> Double -> Double # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #
Ord Double
Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Read Double	Since: 2.1
Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
RealFloat Double	Since: 2.1
Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool # atan2 :: Double -> Double -> Double #
PrintfArg Double	Since: 2.1
Methods formatArg :: Double -> FieldFormatter # parseFormat :: Double -> ModifierParser #
Storable Double	Since: 2.1
Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
Default Double #
Methods defaultValue :: Double #
Mergeable Double #
Methods mergeAppend :: Double -> Double -> Double # mergeConcat :: Foldable t => t Double -> Double #
TextType Double #
Methods tellT :: String -> Double -> Output # getT :: Stream s Identity Char => String -> Parsec s () Double #
Wire Double #
Methods wireSize :: FieldType -> Double -> WireSize # wirePut :: FieldType -> Double -> Put # wirePutWithSize :: FieldType -> Double -> PutM WireSize # wireGet :: FieldType -> Get Double # wireGetPacked :: FieldType -> Get (Seq Double) #
GPB Double #

IArray UArray Double
Methods bounds :: Ix i => UArray i Double -> (i, i) # numElements :: Ix i => UArray i Double -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Double)] -> UArray i Double unsafeAt :: Ix i => UArray i Double -> Int -> Double unsafeReplace :: Ix i => UArray i Double -> [(Int, Double)] -> UArray i Double unsafeAccum :: Ix i => (Double -> e' -> Double) -> UArray i Double -> [(Int, e')] -> UArray i Double unsafeAccumArray :: Ix i => (Double -> e' -> Double) -> Double -> (i, i) -> [(Int, e')] -> UArray i Double
Generic1 k (URec k Double)
Associated Types type Rep1 (URec k Double) (f :: URec k Double -> ) :: k -> # Methods from1 :: f a -> Rep1 (URec k Double) f a # to1 :: Rep1 (URec k Double) f a -> f a #
MessageAPI msg (msg -> Double) Double #
Methods getVal :: msg -> (msg -> Double) -> Double # isSet :: msg -> (msg -> Double) -> Bool #
MArray (STUArray s) Double (ST s)
Methods getBounds :: Ix i => STUArray s i Double -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Double -> ST s Int newArray :: Ix i => (i, i) -> Double -> ST s (STUArray s i Double) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) unsafeRead :: Ix i => STUArray s i Double -> Int -> ST s Double unsafeWrite :: Ix i => STUArray s i Double -> Int -> Double -> ST s ()
Functor (URec * Double)
Methods fmap :: (a -> b) -> URec * Double a -> URec * Double b # (<$) :: a -> URec * Double b -> URec * Double a #
Foldable (URec * Double)
Methods fold :: Monoid m => URec * Double m -> m # foldMap :: Monoid m => (a -> m) -> URec * Double a -> m # foldr :: (a -> b -> b) -> b -> URec * Double a -> b # foldr' :: (a -> b -> b) -> b -> URec * Double a -> b # foldl :: (b -> a -> b) -> b -> URec * Double a -> b # foldl' :: (b -> a -> b) -> b -> URec * Double a -> b # foldr1 :: (a -> a -> a) -> URec * Double a -> a # foldl1 :: (a -> a -> a) -> URec * Double a -> a # toList :: URec * Double a -> [a] # null :: URec * Double a -> Bool # length :: URec * Double a -> Int # elem :: Eq a => a -> URec * Double a -> Bool # maximum :: Ord a => URec * Double a -> a # minimum :: Ord a => URec * Double a -> a # sum :: Num a => URec * Double a -> a # product :: Num a => URec * Double a -> a #
Traversable (URec * Double)
Methods traverse :: Applicative f => (a -> f b) -> URec * Double a -> f (URec * Double b) # sequenceA :: Applicative f => URec * Double (f a) -> f (URec * Double a) # mapM :: Monad m => (a -> m b) -> URec * Double a -> m (URec * Double b) # sequence :: Monad m => URec * Double (m a) -> m (URec * Double a) #
Eq (URec k Double p)
Methods (==) :: URec k Double p -> URec k Double p -> Bool # (/=) :: URec k Double p -> URec k Double p -> Bool #
Ord (URec k Double p)
Methods compare :: URec k Double p -> URec k Double p -> Ordering # (<) :: URec k Double p -> URec k Double p -> Bool # (<=) :: URec k Double p -> URec k Double p -> Bool # (>) :: URec k Double p -> URec k Double p -> Bool # (>=) :: URec k Double p -> URec k Double p -> Bool # max :: URec k Double p -> URec k Double p -> URec k Double p # min :: URec k Double p -> URec k Double p -> URec k Double p #
Show (URec k Double p)
Methods showsPrec :: Int -> URec k Double p -> ShowS # show :: URec k Double p -> String # showList :: [URec k Double p] -> ShowS #
Generic (URec k Double p)
Associated Types type Rep (URec k Double p) :: * -> * # Methods from :: URec k Double p -> Rep (URec k Double p) x # to :: Rep (URec k Double p) x -> URec k Double p #
data URec k Double	Used for marking occurrences of `Double#` Since: 4.9.0.0
data URec k Double = UDouble { uDouble# :: Double# }
type Rep1 k (URec k Double)
type Rep1 k (URec k Double) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UDouble" PrefixI True) (S1 k (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble k)))
type Rep (URec k Double p)
type Rep (URec k Double p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UDouble" PrefixI True) (S1 * (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble *)))

data Float :: * #

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

Eq Float
Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Floating Float	Since: 2.1
Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
Data Float	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float # toConstr :: Float -> Constr # dataTypeOf :: Float -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Float) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) # gmapT :: (forall b. Data b => b -> b) -> Float -> Float # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #
Ord Float
Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Read Float	Since: 2.1
Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
RealFloat Float	Since: 2.1
Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool # atan2 :: Float -> Float -> Float #
PrintfArg Float	Since: 2.1
Methods formatArg :: Float -> FieldFormatter # parseFormat :: Float -> ModifierParser #
Storable Float	Since: 2.1
Methods sizeOf :: Float -> Int # alignment :: Float -> Int # peekElemOff :: Ptr Float -> Int -> IO Float # pokeElemOff :: Ptr Float -> Int -> Float -> IO () # peekByteOff :: Ptr b -> Int -> IO Float # pokeByteOff :: Ptr b -> Int -> Float -> IO () # peek :: Ptr Float -> IO Float # poke :: Ptr Float -> Float -> IO () #
Default Float #
Methods defaultValue :: Float #
Mergeable Float #
Methods mergeAppend :: Float -> Float -> Float # mergeConcat :: Foldable t => t Float -> Float #
TextType Float #
Methods tellT :: String -> Float -> Output # getT :: Stream s Identity Char => String -> Parsec s () Float #
Wire Float #
Methods wireSize :: FieldType -> Float -> WireSize # wirePut :: FieldType -> Float -> Put # wirePutWithSize :: FieldType -> Float -> PutM WireSize # wireGet :: FieldType -> Get Float # wireGetPacked :: FieldType -> Get (Seq Float) #
GPB Float #

IArray UArray Float
Methods bounds :: Ix i => UArray i Float -> (i, i) # numElements :: Ix i => UArray i Float -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Float)] -> UArray i Float unsafeAt :: Ix i => UArray i Float -> Int -> Float unsafeReplace :: Ix i => UArray i Float -> [(Int, Float)] -> UArray i Float unsafeAccum :: Ix i => (Float -> e' -> Float) -> UArray i Float -> [(Int, e')] -> UArray i Float unsafeAccumArray :: Ix i => (Float -> e' -> Float) -> Float -> (i, i) -> [(Int, e')] -> UArray i Float
Generic1 k (URec k Float)
Associated Types type Rep1 (URec k Float) (f :: URec k Float -> ) :: k -> # Methods from1 :: f a -> Rep1 (URec k Float) f a # to1 :: Rep1 (URec k Float) f a -> f a #
MessageAPI msg (msg -> Float) Float #
Methods getVal :: msg -> (msg -> Float) -> Float # isSet :: msg -> (msg -> Float) -> Bool #
MArray (STUArray s) Float (ST s)
Methods getBounds :: Ix i => STUArray s i Float -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Float -> ST s Int newArray :: Ix i => (i, i) -> Float -> ST s (STUArray s i Float) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) unsafeRead :: Ix i => STUArray s i Float -> Int -> ST s Float unsafeWrite :: Ix i => STUArray s i Float -> Int -> Float -> ST s ()
Functor (URec * Float)
Methods fmap :: (a -> b) -> URec * Float a -> URec * Float b # (<$) :: a -> URec * Float b -> URec * Float a #
Foldable (URec * Float)
Methods fold :: Monoid m => URec * Float m -> m # foldMap :: Monoid m => (a -> m) -> URec * Float a -> m # foldr :: (a -> b -> b) -> b -> URec * Float a -> b # foldr' :: (a -> b -> b) -> b -> URec * Float a -> b # foldl :: (b -> a -> b) -> b -> URec * Float a -> b # foldl' :: (b -> a -> b) -> b -> URec * Float a -> b # foldr1 :: (a -> a -> a) -> URec * Float a -> a # foldl1 :: (a -> a -> a) -> URec * Float a -> a # toList :: URec * Float a -> [a] # null :: URec * Float a -> Bool # length :: URec * Float a -> Int # elem :: Eq a => a -> URec * Float a -> Bool # maximum :: Ord a => URec * Float a -> a # minimum :: Ord a => URec * Float a -> a # sum :: Num a => URec * Float a -> a # product :: Num a => URec * Float a -> a #
Traversable (URec * Float)
Methods traverse :: Applicative f => (a -> f b) -> URec * Float a -> f (URec * Float b) # sequenceA :: Applicative f => URec * Float (f a) -> f (URec * Float a) # mapM :: Monad m => (a -> m b) -> URec * Float a -> m (URec * Float b) # sequence :: Monad m => URec * Float (m a) -> m (URec * Float a) #
Eq (URec k Float p)
Methods (==) :: URec k Float p -> URec k Float p -> Bool # (/=) :: URec k Float p -> URec k Float p -> Bool #
Ord (URec k Float p)
Methods compare :: URec k Float p -> URec k Float p -> Ordering # (<) :: URec k Float p -> URec k Float p -> Bool # (<=) :: URec k Float p -> URec k Float p -> Bool # (>) :: URec k Float p -> URec k Float p -> Bool # (>=) :: URec k Float p -> URec k Float p -> Bool # max :: URec k Float p -> URec k Float p -> URec k Float p # min :: URec k Float p -> URec k Float p -> URec k Float p #
Show (URec k Float p)
Methods showsPrec :: Int -> URec k Float p -> ShowS # show :: URec k Float p -> String # showList :: [URec k Float p] -> ShowS #
Generic (URec k Float p)
Associated Types type Rep (URec k Float p) :: * -> * # Methods from :: URec k Float p -> Rep (URec k Float p) x # to :: Rep (URec k Float p) x -> URec k Float p #
data URec k Float	Used for marking occurrences of `Float#` Since: 4.9.0.0
data URec k Float = UFloat { uFloat# :: Float# }
type Rep1 k (URec k Float)
type Rep1 k (URec k Float) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UFloat" PrefixI True) (S1 k (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat k)))
type Rep (URec k Float p)
type Rep (URec k Float p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UFloat" PrefixI True) (S1 * (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat *)))

data Bool :: * #

Instances

Bounded Bool	Since: 2.1
Methods minBound :: Bool # maxBound :: Bool #
Enum Bool	Since: 2.1
Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Eq Bool
Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Data Bool	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool # toConstr :: Bool -> Constr # dataTypeOf :: Bool -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Bool) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) # gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool #
Ord Bool
Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Read Bool	Since: 2.1
Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Show Bool
Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Ix Bool	Since: 2.1
Methods range :: (Bool, Bool) -> [Bool] # index :: (Bool, Bool) -> Bool -> Int # unsafeIndex :: (Bool, Bool) -> Bool -> Int inRange :: (Bool, Bool) -> Bool -> Bool # rangeSize :: (Bool, Bool) -> Int # unsafeRangeSize :: (Bool, Bool) -> Int
Generic Bool
Associated Types type Rep Bool :: * -> * # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
SingKind Bool	Since: 4.9.0.0
Associated Types type DemoteRep Bool :: * Methods fromSing :: Sing Bool a -> DemoteRep Bool
Storable Bool	Since: 2.1
Methods sizeOf :: Bool -> Int # alignment :: Bool -> Int # peekElemOff :: Ptr Bool -> Int -> IO Bool # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () # peekByteOff :: Ptr b -> Int -> IO Bool # pokeByteOff :: Ptr b -> Int -> Bool -> IO () # peek :: Ptr Bool -> IO Bool # poke :: Ptr Bool -> Bool -> IO () #
Bits Bool	Interpret `Bool` as 1-bit bit-field Since: 4.7.0.0
Methods (.&.) :: Bool -> Bool -> Bool # (.\|.) :: Bool -> Bool -> Bool # xor :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # zeroBits :: Bool # bit :: Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # bitSize :: Bool -> Int # isSigned :: Bool -> Bool # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # rotateR :: Bool -> Int -> Bool # popCount :: Bool -> Int #
FiniteBits Bool	Since: 4.7.0.0
Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int #
Default Bool #
Methods defaultValue :: Bool #
Mergeable Bool #
Methods mergeAppend :: Bool -> Bool -> Bool # mergeConcat :: Foldable t => t Bool -> Bool #
TextType Bool #
Methods tellT :: String -> Bool -> Output # getT :: Stream s Identity Char => String -> Parsec s () Bool #
Wire Bool #
Methods wireSize :: FieldType -> Bool -> WireSize # wirePut :: FieldType -> Bool -> Put # wirePutWithSize :: FieldType -> Bool -> PutM WireSize # wireGet :: FieldType -> Get Bool # wireGetPacked :: FieldType -> Get (Seq Bool) #
GPB Bool #

IArray UArray Bool
Methods bounds :: Ix i => UArray i Bool -> (i, i) # numElements :: Ix i => UArray i Bool -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Bool)] -> UArray i Bool unsafeAt :: Ix i => UArray i Bool -> Int -> Bool unsafeReplace :: Ix i => UArray i Bool -> [(Int, Bool)] -> UArray i Bool unsafeAccum :: Ix i => (Bool -> e' -> Bool) -> UArray i Bool -> [(Int, e')] -> UArray i Bool unsafeAccumArray :: Ix i => (Bool -> e' -> Bool) -> Bool -> (i, i) -> [(Int, e')] -> UArray i Bool
SingI Bool False	Since: 4.9.0.0
Methods sing :: Sing False a
SingI Bool True	Since: 4.9.0.0
Methods sing :: Sing True a
MArray (STUArray s) Bool (ST s)
Methods getBounds :: Ix i => STUArray s i Bool -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Bool -> ST s Int newArray :: Ix i => (i, i) -> Bool -> ST s (STUArray s i Bool) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Bool) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Bool) unsafeRead :: Ix i => STUArray s i Bool -> Int -> ST s Bool unsafeWrite :: Ix i => STUArray s i Bool -> Int -> Bool -> ST s ()
type Rep Bool
type Rep Bool = D1 * (MetaData "Bool" "GHC.Types" "ghc-prim" False) ((:+:) * (C1 * (MetaCons "False" PrefixI False) (U1 )) (C1 (MetaCons "True" PrefixI False) (U1 *)))
data Sing Bool
data Sing Bool where STrue :: Sing Bool True SFalse :: Sing Bool False
type DemoteRep Bool
type DemoteRep Bool = Bool
type (==) Bool a b
type (==) Bool a b = EqBool a b

data Maybe a :: * -> * #

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Instances

Monad Maybe	Since: 2.1
Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a # fail :: String -> Maybe a #
Functor Maybe	Since: 2.1
Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Applicative Maybe	Since: 2.1
Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Foldable Maybe	Since: 2.1
Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Traversable Maybe	Since: 2.1
Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Eq1 Maybe	Since: 4.9.0.0
Methods liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool #
Ord1 Maybe	Since: 4.9.0.0
Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering #
Read1 Maybe	Since: 4.9.0.0
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] #
Show1 Maybe	Since: 4.9.0.0
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS #
Alternative Maybe	Since: 2.1
Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
MonadPlus Maybe	Since: 2.1
Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
ExtKey Maybe #
Methods putExt :: Key Maybe msg v -> Maybe v -> msg -> msg # getExt :: Key Maybe msg v -> msg -> Either String (Maybe v) # clearExt :: Key Maybe msg v -> msg -> msg # wireGetKey :: Key Maybe msg v -> msg -> Get msg #
MonadError () Maybe	Since: 2.2.2
Methods throwError :: () -> Maybe a # catchError :: Maybe a -> (() -> Maybe a) -> Maybe a #
(Default msg, Default a) => MessageAPI msg (msg -> Maybe a) a #
Methods getVal :: msg -> (msg -> Maybe a) -> a # isSet :: msg -> (msg -> Maybe a) -> Bool #
Default v => MessageAPI msg (Key Maybe msg v) v #
Methods getVal :: msg -> Key Maybe msg v -> v # isSet :: msg -> Key Maybe msg v -> Bool #
Eq a => Eq (Maybe a)
Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Data a => Data (Maybe a)	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) # toConstr :: Maybe a -> Constr # dataTypeOf :: Maybe a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) # gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r # gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #
Ord a => Ord (Maybe a)
Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
Read a => Read (Maybe a)	Since: 2.1
Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Show a => Show (Maybe a)
Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Generic (Maybe a)
Associated Types type Rep (Maybe a) :: * -> * # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
Semigroup a => Semigroup (Maybe a)	Since: 4.9.0.0
Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe 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 `ee = e` and `es = s = se` for all `s ∈ S`." Since there used to be no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead. Since: 2.1*
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
SingKind a => SingKind (Maybe a)	Since: 4.9.0.0
Associated Types type DemoteRep (Maybe a) :: * Methods fromSing :: Sing (Maybe a) a -> DemoteRep (Maybe a)
Default (Maybe a) #
Methods defaultValue :: Maybe a #
Mergeable a => Mergeable (Maybe a) #
Methods mergeAppend :: Maybe a -> Maybe a -> Maybe a # mergeConcat :: Foldable t => t (Maybe a) -> Maybe a #
TextType a => TextType (Maybe a) #
Methods tellT :: String -> Maybe a -> Output # getT :: Stream s Identity Char => String -> Parsec s () (Maybe a) #
Generic1 * Maybe
Associated Types type Rep1 Maybe (f :: Maybe -> ) :: k -> # Methods from1 :: f a -> Rep1 Maybe f a # to1 :: Rep1 Maybe f a -> f a #
SingI (Maybe a) (Nothing a)	Since: 4.9.0.0
Methods sing :: Sing (Nothing a) a
SingI a1 a2 => SingI (Maybe a1) (Just a1 a2)	Since: 4.9.0.0
Methods sing :: Sing (Just a1 a2) a
type Rep (Maybe a)
type Rep (Maybe a) = D1 * (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) * (C1 * (MetaCons "Nothing" PrefixI False) (U1 )) (C1 (MetaCons "Just" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))))
data Sing (Maybe a)
data Sing (Maybe a) where SNothing :: Sing (Maybe a) (Nothing a) SJust :: Sing (Maybe a) (Just a a1)
type DemoteRep (Maybe a)
type DemoteRep (Maybe a) = Maybe (DemoteRep a)
type Rep1 * Maybe
type Rep1 * Maybe = D1 * (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) * (C1 * (MetaCons "Nothing" PrefixI False) (U1 )) (C1 (MetaCons "Just" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))
type (==) (Maybe k) a b
type (==) (Maybe k) a b = EqMaybe k a b

data Seq a :: * -> * #

General-purpose finite sequences.

Instances

Monad Seq
Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a # fail :: String -> Seq a #
Functor Seq
Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Applicative Seq
Methods pure :: a -> Seq a # (<>) :: Seq (a -> b) -> Seq a -> Seq b # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # (>) :: Seq a -> Seq b -> Seq b # (<*) :: Seq a -> Seq b -> Seq a #
Foldable Seq
Methods fold :: Monoid m => Seq m -> m # foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] # null :: Seq a -> Bool # length :: Seq a -> Int # elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # minimum :: Ord a => Seq a -> a # sum :: Num a => Seq a -> a # product :: Num a => Seq a -> a #
Traversable Seq
Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) # sequence :: Monad m => Seq (m a) -> m (Seq a) #
Eq1 Seq
Methods liftEq :: (a -> b -> Bool) -> Seq a -> Seq b -> Bool #
Ord1 Seq
Methods liftCompare :: (a -> b -> Ordering) -> Seq a -> Seq b -> Ordering #
Read1 Seq
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Seq a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Seq a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Seq a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Seq a] #
Show1 Seq
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Seq a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Seq a] -> ShowS #
MonadZip Seq
Methods mzip :: Seq a -> Seq b -> Seq (a, b) # mzipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # munzip :: Seq (a, b) -> (Seq a, Seq b) #
Alternative Seq
Methods empty :: Seq a # (<\|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
MonadPlus Seq
Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
UnzipWith Seq
Methods unzipWith :: (x -> (a, b)) -> Seq x -> (Seq a, Seq b)
ExtKey Seq #
Methods putExt :: Key Seq msg v -> Seq v -> msg -> msg # getExt :: Key Seq msg v -> msg -> Either String (Seq v) # clearExt :: Key Seq msg v -> msg -> msg # wireGetKey :: Key Seq msg v -> msg -> Get msg #
MessageAPI msg (msg -> Seq a) (Seq a) #
Methods getVal :: msg -> (msg -> Seq a) -> Seq a # isSet :: msg -> (msg -> Seq a) -> Bool #
Default v => MessageAPI msg (Key Seq msg v) (Seq v) #
Methods getVal :: msg -> Key Seq msg v -> Seq v # isSet :: msg -> Key Seq msg v -> Bool #
IsList (Seq a)
Associated Types type Item (Seq a) :: * # Methods fromList :: [Item (Seq a)] -> Seq a # fromListN :: Int -> [Item (Seq a)] -> Seq a # toList :: Seq a -> [Item (Seq a)] #
Eq a => Eq (Seq a)
Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Data a => Data (Seq a)
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Seq a -> c (Seq a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Seq a) # toConstr :: Seq a -> Constr # dataTypeOf :: Seq a -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Seq a)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Seq a)) # gmapT :: (forall b. Data b => b -> b) -> Seq a -> Seq a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r # gmapQ :: (forall d. Data d => d -> u) -> Seq a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Seq a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) #
Ord a => Ord (Seq a)
Methods compare :: Seq a -> Seq a -> Ordering # (<) :: Seq a -> Seq a -> Bool # (<=) :: Seq a -> Seq a -> Bool # (>) :: Seq a -> Seq a -> Bool # (>=) :: Seq a -> Seq a -> Bool # max :: Seq a -> Seq a -> Seq a # min :: Seq a -> Seq a -> Seq a #
Read a => Read (Seq a)
Methods readsPrec :: Int -> ReadS (Seq a) # readList :: ReadS [Seq a] # readPrec :: ReadPrec (Seq a) # readListPrec :: ReadPrec [Seq a] #
Show a => Show (Seq a)
Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
IsString (Seq Char)
Methods fromString :: String -> Seq Char #
Semigroup (Seq a)
Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
Monoid (Seq a)
Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
NFData a => NFData (Seq a)
Methods rnf :: Seq a -> () #
Default (Seq a) #
Methods defaultValue :: Seq a #
Mergeable (Seq a) #
Methods mergeAppend :: Seq a -> Seq a -> Seq a # mergeConcat :: Foldable t => t (Seq a) -> Seq a #
TextType a => TextType (Seq a) #
Methods tellT :: String -> Seq a -> Output # getT :: Stream s Identity Char => String -> Parsec s () (Seq a) #
type Item (Seq a)
type Item (Seq a) = a

newtype Utf8 #

Utf8 is used to mark ByteString values that (should) contain valid utf8 encoded strings. This type is used to represent TYPE_STRING values.

Constructors

Utf8 ByteString

Instances

Eq Utf8 #
Methods (==) :: Utf8 -> Utf8 -> Bool # (/=) :: Utf8 -> Utf8 -> Bool #
Data Utf8 #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Utf8 -> c Utf8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Utf8 # toConstr :: Utf8 -> Constr # dataTypeOf :: Utf8 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Utf8) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8) # gmapT :: (forall b. Data b => b -> b) -> Utf8 -> Utf8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Utf8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Utf8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Utf8 -> m Utf8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Utf8 -> m Utf8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Utf8 -> m Utf8 #
Ord Utf8 #
Methods compare :: Utf8 -> Utf8 -> Ordering # (<) :: Utf8 -> Utf8 -> Bool # (<=) :: Utf8 -> Utf8 -> Bool # (>) :: Utf8 -> Utf8 -> Bool # (>=) :: Utf8 -> Utf8 -> Bool # max :: Utf8 -> Utf8 -> Utf8 # min :: Utf8 -> Utf8 -> Utf8 #
Read Utf8 #
Methods readsPrec :: Int -> ReadS Utf8 # readList :: ReadS [Utf8] # readPrec :: ReadPrec Utf8 # readListPrec :: ReadPrec [Utf8] #
Show Utf8 #
Methods showsPrec :: Int -> Utf8 -> ShowS # show :: Utf8 -> String # showList :: [Utf8] -> ShowS #
Semigroup Utf8 #
Methods (<>) :: Utf8 -> Utf8 -> Utf8 # sconcat :: NonEmpty Utf8 -> Utf8 # stimes :: Integral b => b -> Utf8 -> Utf8 #
Monoid Utf8 #
Methods mempty :: Utf8 # mappend :: Utf8 -> Utf8 -> Utf8 # mconcat :: [Utf8] -> Utf8 #
Default Utf8 #
Methods defaultValue :: Utf8 #
Mergeable Utf8 #
Methods mergeAppend :: Utf8 -> Utf8 -> Utf8 # mergeConcat :: Foldable t => t Utf8 -> Utf8 #
Dotted Utf8 #
Methods uncons :: Utf8 -> Maybe (Char, Utf8) # cons :: Char -> Utf8 -> Utf8 # dot :: Utf8 -> Utf8 -> Utf8 # validI :: Utf8 -> Maybe (IName Utf8) # validDI :: Utf8 -> Maybe (DIName Utf8) # split :: Utf8 -> [Utf8] #
TextType Utf8 #
Methods tellT :: String -> Utf8 -> Output # getT :: Stream s Identity Char => String -> Parsec s () Utf8 #
Wire Utf8 #
Methods wireSize :: FieldType -> Utf8 -> WireSize # wirePut :: FieldType -> Utf8 -> Put # wirePutWithSize :: FieldType -> Utf8 -> PutM WireSize # wireGet :: FieldType -> Get Utf8 # wireGetPacked :: FieldType -> Get (Seq Utf8) #
GPB Utf8 #

MessageAPI msg (msg -> Utf8) Utf8 #
Methods getVal :: msg -> (msg -> Utf8) -> Utf8 # isSet :: msg -> (msg -> Utf8) -> Bool #
Mangle (FIName Utf8) (PFName String) #
Methods mangle :: FIName Utf8 -> PFName String #
Mangle (FIName Utf8) (PMName String) #
Methods mangle :: FIName Utf8 -> PMName String #
Mangle (DIName Utf8) (PFName String) #
Methods mangle :: DIName Utf8 -> PFName String #
Mangle (DIName Utf8) (PMName String) #
Methods mangle :: DIName Utf8 -> PMName String #
Mangle (IName Utf8) (FName String) #
Methods mangle :: IName Utf8 -> FName String #
Mangle (IName Utf8) (MName String) #
Methods mangle :: IName Utf8 -> MName String #

data ByteString :: * #

A space-efficient representation of a Word8 vector, supporting many efficient operations.

A lazy ByteString contains 8-bit bytes, or by using the operations from Data.ByteString.Lazy.Char8 it can be interpreted as containing 8-bit characters.

Instances

Eq ByteString
Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Data ByteString
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString # toConstr :: ByteString -> Constr # dataTypeOf :: ByteString -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) # gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #
Ord ByteString
Methods compare :: ByteString -> ByteString -> Ordering # (<) :: ByteString -> ByteString -> Bool # (<=) :: ByteString -> ByteString -> Bool # (>) :: ByteString -> ByteString -> Bool # (>=) :: ByteString -> ByteString -> Bool # max :: ByteString -> ByteString -> ByteString # min :: ByteString -> ByteString -> ByteString #
Read ByteString
Methods readsPrec :: Int -> ReadS ByteString # readList :: ReadS [ByteString] # readPrec :: ReadPrec ByteString # readListPrec :: ReadPrec [ByteString] #
Show ByteString
Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
IsString ByteString
Methods fromString :: String -> ByteString #
Semigroup ByteString
Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Monoid ByteString
Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
NFData ByteString
Methods rnf :: ByteString -> () #
Default ByteString #
Methods defaultValue :: ByteString #
Mergeable ByteString #
Methods mergeAppend :: ByteString -> ByteString -> ByteString # mergeConcat :: Foldable t => t ByteString -> ByteString #
TextType ByteString #
Methods tellT :: String -> ByteString -> Output # getT :: Stream s Identity Char => String -> Parsec s () ByteString #
Wire ByteString #
Methods wireSize :: FieldType -> ByteString -> WireSize # wirePut :: FieldType -> ByteString -> Put # wirePutWithSize :: FieldType -> ByteString -> PutM WireSize # wireGet :: FieldType -> Get ByteString # wireGetPacked :: FieldType -> Get (Seq ByteString) #
GPB ByteString #

Monad m => Stream ByteString m Char
Methods uncons :: ByteString -> m (Maybe (Char, ByteString)) #
MessageAPI msg (msg -> ByteString) ByteString #
Methods getVal :: msg -> (msg -> ByteString) -> ByteString # isSet :: msg -> (msg -> ByteString) -> Bool #

data Int32 :: * #

32-bit signed integer type

Instances

Bounded Int32	Since: 2.1
Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32	Since: 2.1
Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Eq Int32	Since: 2.1
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Integral Int32	Since: 2.1
Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Data Int32	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 # toConstr :: Int32 -> Constr # dataTypeOf :: Int32 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int32) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) # gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #
Num Int32	Since: 2.1
Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Ord Int32	Since: 2.1
Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Read Int32	Since: 2.1
Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Real Int32	Since: 2.1
Methods toRational :: Int32 -> Rational #
Show Int32	Since: 2.1
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Ix Int32	Since: 2.1
Methods range :: (Int32, Int32) -> [Int32] # index :: (Int32, Int32) -> Int32 -> Int # unsafeIndex :: (Int32, Int32) -> Int32 -> Int inRange :: (Int32, Int32) -> Int32 -> Bool # rangeSize :: (Int32, Int32) -> Int # unsafeRangeSize :: (Int32, Int32) -> Int
PrintfArg Int32	Since: 2.1
Methods formatArg :: Int32 -> FieldFormatter # parseFormat :: Int32 -> ModifierParser #
Storable Int32	Since: 2.1
Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Bits Int32	Since: 2.1
Methods (.&.) :: Int32 -> Int32 -> Int32 # (.\|.) :: Int32 -> Int32 -> Int32 # xor :: Int32 -> Int32 -> Int32 # complement :: Int32 -> Int32 # shift :: Int32 -> Int -> Int32 # rotate :: Int32 -> Int -> Int32 # zeroBits :: Int32 # bit :: Int -> Int32 # setBit :: Int32 -> Int -> Int32 # clearBit :: Int32 -> Int -> Int32 # complementBit :: Int32 -> Int -> Int32 # testBit :: Int32 -> Int -> Bool # bitSizeMaybe :: Int32 -> Maybe Int # bitSize :: Int32 -> Int # isSigned :: Int32 -> Bool # shiftL :: Int32 -> Int -> Int32 # unsafeShiftL :: Int32 -> Int -> Int32 # shiftR :: Int32 -> Int -> Int32 # unsafeShiftR :: Int32 -> Int -> Int32 # rotateL :: Int32 -> Int -> Int32 # rotateR :: Int32 -> Int -> Int32 # popCount :: Int32 -> Int #
FiniteBits Int32	Since: 4.6.0.0
Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int #
Default Int32 #
Methods defaultValue :: Int32 #
Mergeable Int32 #
Methods mergeAppend :: Int32 -> Int32 -> Int32 # mergeConcat :: Foldable t => t Int32 -> Int32 #
TextType Int32 #
Methods tellT :: String -> Int32 -> Output # getT :: Stream s Identity Char => String -> Parsec s () Int32 #
Wire Int32 #
Methods wireSize :: FieldType -> Int32 -> WireSize # wirePut :: FieldType -> Int32 -> Put # wirePutWithSize :: FieldType -> Int32 -> PutM WireSize # wireGet :: FieldType -> Get Int32 # wireGetPacked :: FieldType -> Get (Seq Int32) #
GPB Int32 #

IArray UArray Int32
Methods bounds :: Ix i => UArray i Int32 -> (i, i) # numElements :: Ix i => UArray i Int32 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int32)] -> UArray i Int32 unsafeAt :: Ix i => UArray i Int32 -> Int -> Int32 unsafeReplace :: Ix i => UArray i Int32 -> [(Int, Int32)] -> UArray i Int32 unsafeAccum :: Ix i => (Int32 -> e' -> Int32) -> UArray i Int32 -> [(Int, e')] -> UArray i Int32 unsafeAccumArray :: Ix i => (Int32 -> e' -> Int32) -> Int32 -> (i, i) -> [(Int, e')] -> UArray i Int32
MessageAPI msg (msg -> Int32) Int32 #
Methods getVal :: msg -> (msg -> Int32) -> Int32 # isSet :: msg -> (msg -> Int32) -> Bool #
MArray (STUArray s) Int32 (ST s)
Methods getBounds :: Ix i => STUArray s i Int32 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Int32 -> ST s Int newArray :: Ix i => (i, i) -> Int32 -> ST s (STUArray s i Int32) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int32) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int32) unsafeRead :: Ix i => STUArray s i Int32 -> Int -> ST s Int32 unsafeWrite :: Ix i => STUArray s i Int32 -> Int -> Int32 -> ST s ()

data Int64 :: * #

64-bit signed integer type

Instances

Bounded Int64	Since: 2.1
Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64	Since: 2.1
Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Eq Int64	Since: 2.1
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Integral Int64	Since: 2.1
Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Data Int64	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 # toConstr :: Int64 -> Constr # dataTypeOf :: Int64 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int64) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) # gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #
Num Int64	Since: 2.1
Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Ord Int64	Since: 2.1
Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Read Int64	Since: 2.1
Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Real Int64	Since: 2.1
Methods toRational :: Int64 -> Rational #
Show Int64	Since: 2.1
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Ix Int64	Since: 2.1
Methods range :: (Int64, Int64) -> [Int64] # index :: (Int64, Int64) -> Int64 -> Int # unsafeIndex :: (Int64, Int64) -> Int64 -> Int inRange :: (Int64, Int64) -> Int64 -> Bool # rangeSize :: (Int64, Int64) -> Int # unsafeRangeSize :: (Int64, Int64) -> Int
PrintfArg Int64	Since: 2.1
Methods formatArg :: Int64 -> FieldFormatter # parseFormat :: Int64 -> ModifierParser #
Storable Int64	Since: 2.1
Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Bits Int64	Since: 2.1
Methods (.&.) :: Int64 -> Int64 -> Int64 # (.\|.) :: Int64 -> Int64 -> Int64 # xor :: Int64 -> Int64 -> Int64 # complement :: Int64 -> Int64 # shift :: Int64 -> Int -> Int64 # rotate :: Int64 -> Int -> Int64 # zeroBits :: Int64 # bit :: Int -> Int64 # setBit :: Int64 -> Int -> Int64 # clearBit :: Int64 -> Int -> Int64 # complementBit :: Int64 -> Int -> Int64 # testBit :: Int64 -> Int -> Bool # bitSizeMaybe :: Int64 -> Maybe Int # bitSize :: Int64 -> Int # isSigned :: Int64 -> Bool # shiftL :: Int64 -> Int -> Int64 # unsafeShiftL :: Int64 -> Int -> Int64 # shiftR :: Int64 -> Int -> Int64 # unsafeShiftR :: Int64 -> Int -> Int64 # rotateL :: Int64 -> Int -> Int64 # rotateR :: Int64 -> Int -> Int64 # popCount :: Int64 -> Int #
FiniteBits Int64	Since: 4.6.0.0
Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int #
Default Int64 #
Methods defaultValue :: Int64 #
Mergeable Int64 #
Methods mergeAppend :: Int64 -> Int64 -> Int64 # mergeConcat :: Foldable t => t Int64 -> Int64 #
TextType Int64 #
Methods tellT :: String -> Int64 -> Output # getT :: Stream s Identity Char => String -> Parsec s () Int64 #
Wire Int64 #
Methods wireSize :: FieldType -> Int64 -> WireSize # wirePut :: FieldType -> Int64 -> Put # wirePutWithSize :: FieldType -> Int64 -> PutM WireSize # wireGet :: FieldType -> Get Int64 # wireGetPacked :: FieldType -> Get (Seq Int64) #
GPB Int64 #

IArray UArray Int64
Methods bounds :: Ix i => UArray i Int64 -> (i, i) # numElements :: Ix i => UArray i Int64 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int64)] -> UArray i Int64 unsafeAt :: Ix i => UArray i Int64 -> Int -> Int64 unsafeReplace :: Ix i => UArray i Int64 -> [(Int, Int64)] -> UArray i Int64 unsafeAccum :: Ix i => (Int64 -> e' -> Int64) -> UArray i Int64 -> [(Int, e')] -> UArray i Int64 unsafeAccumArray :: Ix i => (Int64 -> e' -> Int64) -> Int64 -> (i, i) -> [(Int, e')] -> UArray i Int64
MessageAPI msg (msg -> Int64) Int64 #
Methods getVal :: msg -> (msg -> Int64) -> Int64 # isSet :: msg -> (msg -> Int64) -> Bool #
MArray (STUArray s) Int64 (ST s)
Methods getBounds :: Ix i => STUArray s i Int64 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Int64 -> ST s Int newArray :: Ix i => (i, i) -> Int64 -> ST s (STUArray s i Int64) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int64) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int64) unsafeRead :: Ix i => STUArray s i Int64 -> Int -> ST s Int64 unsafeWrite :: Ix i => STUArray s i Int64 -> Int -> Int64 -> ST s ()

data Word32 :: * #

32-bit unsigned integer type

Instances

Bounded Word32	Since: 2.1
Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32	Since: 2.1
Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Eq Word32	Since: 2.1
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Integral Word32	Since: 2.1
Methods quot :: Word32 -> Word32 -> Word32 # rem :: Word32 -> Word32 -> Word32 # div :: Word32 -> Word32 -> Word32 # mod :: Word32 -> Word32 -> Word32 # quotRem :: Word32 -> Word32 -> (Word32, Word32) # divMod :: Word32 -> Word32 -> (Word32, Word32) # toInteger :: Word32 -> Integer #
Data Word32	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 # toConstr :: Word32 -> Constr # dataTypeOf :: Word32 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word32) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) # gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #
Num Word32	Since: 2.1
Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Ord Word32	Since: 2.1
Methods compare :: Word32 -> Word32 -> Ordering # (<) :: Word32 -> Word32 -> Bool # (<=) :: Word32 -> Word32 -> Bool # (>) :: Word32 -> Word32 -> Bool # (>=) :: Word32 -> Word32 -> Bool # max :: Word32 -> Word32 -> Word32 # min :: Word32 -> Word32 -> Word32 #
Read Word32	Since: 2.1
Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Real Word32	Since: 2.1
Methods toRational :: Word32 -> Rational #
Show Word32	Since: 2.1
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Ix Word32	Since: 2.1
Methods range :: (Word32, Word32) -> [Word32] # index :: (Word32, Word32) -> Word32 -> Int # unsafeIndex :: (Word32, Word32) -> Word32 -> Int inRange :: (Word32, Word32) -> Word32 -> Bool # rangeSize :: (Word32, Word32) -> Int # unsafeRangeSize :: (Word32, Word32) -> Int
PrintfArg Word32	Since: 2.1
Methods formatArg :: Word32 -> FieldFormatter # parseFormat :: Word32 -> ModifierParser #
Storable Word32	Since: 2.1
Methods sizeOf :: Word32 -> Int # alignment :: Word32 -> Int # peekElemOff :: Ptr Word32 -> Int -> IO Word32 # pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word32 # pokeByteOff :: Ptr b -> Int -> Word32 -> IO () # peek :: Ptr Word32 -> IO Word32 # poke :: Ptr Word32 -> Word32 -> IO () #
Bits Word32	Since: 2.1
Methods (.&.) :: Word32 -> Word32 -> Word32 # (.\|.) :: Word32 -> Word32 -> Word32 # xor :: Word32 -> Word32 -> Word32 # complement :: Word32 -> Word32 # shift :: Word32 -> Int -> Word32 # rotate :: Word32 -> Int -> Word32 # zeroBits :: Word32 # bit :: Int -> Word32 # setBit :: Word32 -> Int -> Word32 # clearBit :: Word32 -> Int -> Word32 # complementBit :: Word32 -> Int -> Word32 # testBit :: Word32 -> Int -> Bool # bitSizeMaybe :: Word32 -> Maybe Int # bitSize :: Word32 -> Int # isSigned :: Word32 -> Bool # shiftL :: Word32 -> Int -> Word32 # unsafeShiftL :: Word32 -> Int -> Word32 # shiftR :: Word32 -> Int -> Word32 # unsafeShiftR :: Word32 -> Int -> Word32 # rotateL :: Word32 -> Int -> Word32 # rotateR :: Word32 -> Int -> Word32 # popCount :: Word32 -> Int #
FiniteBits Word32	Since: 4.6.0.0
Methods finiteBitSize :: Word32 -> Int # countLeadingZeros :: Word32 -> Int # countTrailingZeros :: Word32 -> Int #
Default Word32 #
Methods defaultValue :: Word32 #
Mergeable Word32 #
Methods mergeAppend :: Word32 -> Word32 -> Word32 # mergeConcat :: Foldable t => t Word32 -> Word32 #
TextType Word32 #
Methods tellT :: String -> Word32 -> Output # getT :: Stream s Identity Char => String -> Parsec s () Word32 #
Wire Word32 #
Methods wireSize :: FieldType -> Word32 -> WireSize # wirePut :: FieldType -> Word32 -> Put # wirePutWithSize :: FieldType -> Word32 -> PutM WireSize # wireGet :: FieldType -> Get Word32 # wireGetPacked :: FieldType -> Get (Seq Word32) #
GPB Word32 #

IArray UArray Word32
Methods bounds :: Ix i => UArray i Word32 -> (i, i) # numElements :: Ix i => UArray i Word32 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word32)] -> UArray i Word32 unsafeAt :: Ix i => UArray i Word32 -> Int -> Word32 unsafeReplace :: Ix i => UArray i Word32 -> [(Int, Word32)] -> UArray i Word32 unsafeAccum :: Ix i => (Word32 -> e' -> Word32) -> UArray i Word32 -> [(Int, e')] -> UArray i Word32 unsafeAccumArray :: Ix i => (Word32 -> e' -> Word32) -> Word32 -> (i, i) -> [(Int, e')] -> UArray i Word32
MessageAPI msg (msg -> Word32) Word32 #
Methods getVal :: msg -> (msg -> Word32) -> Word32 # isSet :: msg -> (msg -> Word32) -> Bool #
MArray (STUArray s) Word32 (ST s)
Methods getBounds :: Ix i => STUArray s i Word32 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Word32 -> ST s Int newArray :: Ix i => (i, i) -> Word32 -> ST s (STUArray s i Word32) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32) unsafeRead :: Ix i => STUArray s i Word32 -> Int -> ST s Word32 unsafeWrite :: Ix i => STUArray s i Word32 -> Int -> Word32 -> ST s ()

data Word64 :: * #

64-bit unsigned integer type

Instances

Bounded Word64	Since: 2.1
Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64	Since: 2.1
Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Eq Word64	Since: 2.1
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Integral Word64	Since: 2.1
Methods quot :: Word64 -> Word64 -> Word64 # rem :: Word64 -> Word64 -> Word64 # div :: Word64 -> Word64 -> Word64 # mod :: Word64 -> Word64 -> Word64 # quotRem :: Word64 -> Word64 -> (Word64, Word64) # divMod :: Word64 -> Word64 -> (Word64, Word64) # toInteger :: Word64 -> Integer #
Data Word64	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 # toConstr :: Word64 -> Constr # dataTypeOf :: Word64 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word64) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) # gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #
Num Word64	Since: 2.1
Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Ord Word64	Since: 2.1
Methods compare :: Word64 -> Word64 -> Ordering # (<) :: Word64 -> Word64 -> Bool # (<=) :: Word64 -> Word64 -> Bool # (>) :: Word64 -> Word64 -> Bool # (>=) :: Word64 -> Word64 -> Bool # max :: Word64 -> Word64 -> Word64 # min :: Word64 -> Word64 -> Word64 #
Read Word64	Since: 2.1
Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Real Word64	Since: 2.1
Methods toRational :: Word64 -> Rational #
Show Word64	Since: 2.1
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Ix Word64	Since: 2.1
Methods range :: (Word64, Word64) -> [Word64] # index :: (Word64, Word64) -> Word64 -> Int # unsafeIndex :: (Word64, Word64) -> Word64 -> Int inRange :: (Word64, Word64) -> Word64 -> Bool # rangeSize :: (Word64, Word64) -> Int # unsafeRangeSize :: (Word64, Word64) -> Int
PrintfArg Word64	Since: 2.1
Methods formatArg :: Word64 -> FieldFormatter # parseFormat :: Word64 -> ModifierParser #
Storable Word64	Since: 2.1
Methods sizeOf :: Word64 -> Int # alignment :: Word64 -> Int # peekElemOff :: Ptr Word64 -> Int -> IO Word64 # pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Word64 # pokeByteOff :: Ptr b -> Int -> Word64 -> IO () # peek :: Ptr Word64 -> IO Word64 # poke :: Ptr Word64 -> Word64 -> IO () #
Bits Word64	Since: 2.1
Methods (.&.) :: Word64 -> Word64 -> Word64 # (.\|.) :: Word64 -> Word64 -> Word64 # xor :: Word64 -> Word64 -> Word64 # complement :: Word64 -> Word64 # shift :: Word64 -> Int -> Word64 # rotate :: Word64 -> Int -> Word64 # zeroBits :: Word64 # bit :: Int -> Word64 # setBit :: Word64 -> Int -> Word64 # clearBit :: Word64 -> Int -> Word64 # complementBit :: Word64 -> Int -> Word64 # testBit :: Word64 -> Int -> Bool # bitSizeMaybe :: Word64 -> Maybe Int # bitSize :: Word64 -> Int # isSigned :: Word64 -> Bool # shiftL :: Word64 -> Int -> Word64 # unsafeShiftL :: Word64 -> Int -> Word64 # shiftR :: Word64 -> Int -> Word64 # unsafeShiftR :: Word64 -> Int -> Word64 # rotateL :: Word64 -> Int -> Word64 # rotateR :: Word64 -> Int -> Word64 # popCount :: Word64 -> Int #
FiniteBits Word64	Since: 4.6.0.0
Methods finiteBitSize :: Word64 -> Int # countLeadingZeros :: Word64 -> Int # countTrailingZeros :: Word64 -> Int #
Default Word64 #
Methods defaultValue :: Word64 #
Mergeable Word64 #
Methods mergeAppend :: Word64 -> Word64 -> Word64 # mergeConcat :: Foldable t => t Word64 -> Word64 #
TextType Word64 #
Methods tellT :: String -> Word64 -> Output # getT :: Stream s Identity Char => String -> Parsec s () Word64 #
Wire Word64 #
Methods wireSize :: FieldType -> Word64 -> WireSize # wirePut :: FieldType -> Word64 -> Put # wirePutWithSize :: FieldType -> Word64 -> PutM WireSize # wireGet :: FieldType -> Get Word64 # wireGetPacked :: FieldType -> Get (Seq Word64) #
GPB Word64 #

IArray UArray Word64
Methods bounds :: Ix i => UArray i Word64 -> (i, i) # numElements :: Ix i => UArray i Word64 -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word64)] -> UArray i Word64 unsafeAt :: Ix i => UArray i Word64 -> Int -> Word64 unsafeReplace :: Ix i => UArray i Word64 -> [(Int, Word64)] -> UArray i Word64 unsafeAccum :: Ix i => (Word64 -> e' -> Word64) -> UArray i Word64 -> [(Int, e')] -> UArray i Word64 unsafeAccumArray :: Ix i => (Word64 -> e' -> Word64) -> Word64 -> (i, i) -> [(Int, e')] -> UArray i Word64
MessageAPI msg (msg -> Word64) Word64 #
Methods getVal :: msg -> (msg -> Word64) -> Word64 # isSet :: msg -> (msg -> Word64) -> Bool #
MArray (STUArray s) Word64 (ST s)
Methods getBounds :: Ix i => STUArray s i Word64 -> ST s (i, i) # getNumElements :: Ix i => STUArray s i Word64 -> ST s Int newArray :: Ix i => (i, i) -> Word64 -> ST s (STUArray s i Word64) # newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64) # unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64) unsafeRead :: Ix i => STUArray s i Word64 -> Int -> ST s Word64 unsafeWrite :: Ix i => STUArray s i Word64 -> Int -> Word64 -> ST s ()

Haskell types that act in the place of DescritorProto values

newtype WireTag #

WireTag is the 32 bit value with the upper 29 bits being the FieldId and the lower 3 bits being the WireType

Constructors

WireTag
Fields getWireTag :: Word32

Instances

Bounded WireTag #
Methods minBound :: WireTag # maxBound :: WireTag #
Enum WireTag #
Methods succ :: WireTag -> WireTag # pred :: WireTag -> WireTag # toEnum :: Int -> WireTag # fromEnum :: WireTag -> Int # enumFrom :: WireTag -> [WireTag] # enumFromThen :: WireTag -> WireTag -> [WireTag] # enumFromTo :: WireTag -> WireTag -> [WireTag] # enumFromThenTo :: WireTag -> WireTag -> WireTag -> [WireTag] #
Eq WireTag #
Methods (==) :: WireTag -> WireTag -> Bool # (/=) :: WireTag -> WireTag -> Bool #
Data WireTag #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WireTag -> c WireTag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WireTag # toConstr :: WireTag -> Constr # dataTypeOf :: WireTag -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c WireTag) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag) # gmapT :: (forall b. Data b => b -> b) -> WireTag -> WireTag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WireTag -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WireTag -> r # gmapQ :: (forall d. Data d => d -> u) -> WireTag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WireTag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WireTag -> m WireTag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WireTag -> m WireTag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WireTag -> m WireTag #
Num WireTag #
Methods (+) :: WireTag -> WireTag -> WireTag # (-) :: WireTag -> WireTag -> WireTag # (*) :: WireTag -> WireTag -> WireTag # negate :: WireTag -> WireTag # abs :: WireTag -> WireTag # signum :: WireTag -> WireTag # fromInteger :: Integer -> WireTag #
Ord WireTag #
Methods compare :: WireTag -> WireTag -> Ordering # (<) :: WireTag -> WireTag -> Bool # (<=) :: WireTag -> WireTag -> Bool # (>) :: WireTag -> WireTag -> Bool # (>=) :: WireTag -> WireTag -> Bool # max :: WireTag -> WireTag -> WireTag # min :: WireTag -> WireTag -> WireTag #
Read WireTag #
Methods readsPrec :: Int -> ReadS WireTag # readList :: ReadS [WireTag] # readPrec :: ReadPrec WireTag # readListPrec :: ReadPrec [WireTag] #
Show WireTag #
Methods showsPrec :: Int -> WireTag -> ShowS # show :: WireTag -> String # showList :: [WireTag] -> ShowS #
Bits WireTag #
Methods (.&.) :: WireTag -> WireTag -> WireTag # (.\|.) :: WireTag -> WireTag -> WireTag # xor :: WireTag -> WireTag -> WireTag # complement :: WireTag -> WireTag # shift :: WireTag -> Int -> WireTag # rotate :: WireTag -> Int -> WireTag # zeroBits :: WireTag # bit :: Int -> WireTag # setBit :: WireTag -> Int -> WireTag # clearBit :: WireTag -> Int -> WireTag # complementBit :: WireTag -> Int -> WireTag # testBit :: WireTag -> Int -> Bool # bitSizeMaybe :: WireTag -> Maybe Int # bitSize :: WireTag -> Int # isSigned :: WireTag -> Bool # shiftL :: WireTag -> Int -> WireTag # unsafeShiftL :: WireTag -> Int -> WireTag # shiftR :: WireTag -> Int -> WireTag # unsafeShiftR :: WireTag -> Int -> WireTag # rotateL :: WireTag -> Int -> WireTag # rotateR :: WireTag -> Int -> WireTag # popCount :: WireTag -> Int #

newtype FieldId #

FieldId is the field number which can be in the range 1 to 2^29-1 but the value from 19000 to 19999 are forbidden (so sayeth Google).

Constructors

FieldId
Fields getFieldId :: Int32

Instances

Bounded FieldId #
Methods minBound :: FieldId # maxBound :: FieldId #
Enum FieldId #
Methods succ :: FieldId -> FieldId # pred :: FieldId -> FieldId # toEnum :: Int -> FieldId # fromEnum :: FieldId -> Int # enumFrom :: FieldId -> [FieldId] # enumFromThen :: FieldId -> FieldId -> [FieldId] # enumFromTo :: FieldId -> FieldId -> [FieldId] # enumFromThenTo :: FieldId -> FieldId -> FieldId -> [FieldId] #
Eq FieldId #
Methods (==) :: FieldId -> FieldId -> Bool # (/=) :: FieldId -> FieldId -> Bool #
Data FieldId #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldId -> c FieldId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldId # toConstr :: FieldId -> Constr # dataTypeOf :: FieldId -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c FieldId) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId) # gmapT :: (forall b. Data b => b -> b) -> FieldId -> FieldId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldId -> r # gmapQ :: (forall d. Data d => d -> u) -> FieldId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldId -> m FieldId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldId -> m FieldId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldId -> m FieldId #
Num FieldId #
Methods (+) :: FieldId -> FieldId -> FieldId # (-) :: FieldId -> FieldId -> FieldId # (*) :: FieldId -> FieldId -> FieldId # negate :: FieldId -> FieldId # abs :: FieldId -> FieldId # signum :: FieldId -> FieldId # fromInteger :: Integer -> FieldId #
Ord FieldId #
Methods compare :: FieldId -> FieldId -> Ordering # (<) :: FieldId -> FieldId -> Bool # (<=) :: FieldId -> FieldId -> Bool # (>) :: FieldId -> FieldId -> Bool # (>=) :: FieldId -> FieldId -> Bool # max :: FieldId -> FieldId -> FieldId # min :: FieldId -> FieldId -> FieldId #
Read FieldId #
Methods readsPrec :: Int -> ReadS FieldId # readList :: ReadS [FieldId] # readPrec :: ReadPrec FieldId # readListPrec :: ReadPrec [FieldId] #
Show FieldId #
Methods showsPrec :: Int -> FieldId -> ShowS # show :: FieldId -> String # showList :: [FieldId] -> ShowS #
Ix FieldId #
Methods range :: (FieldId, FieldId) -> [FieldId] # index :: (FieldId, FieldId) -> FieldId -> Int # unsafeIndex :: (FieldId, FieldId) -> FieldId -> Int inRange :: (FieldId, FieldId) -> FieldId -> Bool # rangeSize :: (FieldId, FieldId) -> Int # unsafeRangeSize :: (FieldId, FieldId) -> Int

newtype WireType #

WireType is the 3 bit wire encoding value, and is currently in the range 0 to 5, leaving 6 and 7 currently invalid.

0 Varint : int32, int64, uint32, uint64, sint32, sint64, bool, enum
1 64-bit : fixed64, sfixed64, double
2 Length-delimited : string, bytes, embedded messages
3 Start group : groups (deprecated)
4 End group : groups (deprecated)
5 32-bit : fixed32, sfixed32, float

Constructors

WireType
Fields getWireType :: Word32

Instances

Bounded WireType #
Methods minBound :: WireType # maxBound :: WireType #
Enum WireType #
Methods succ :: WireType -> WireType # pred :: WireType -> WireType # toEnum :: Int -> WireType # fromEnum :: WireType -> Int # enumFrom :: WireType -> [WireType] # enumFromThen :: WireType -> WireType -> [WireType] # enumFromTo :: WireType -> WireType -> [WireType] # enumFromThenTo :: WireType -> WireType -> WireType -> [WireType] #
Eq WireType #
Methods (==) :: WireType -> WireType -> Bool # (/=) :: WireType -> WireType -> Bool #
Data WireType #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WireType -> c WireType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WireType # toConstr :: WireType -> Constr # dataTypeOf :: WireType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c WireType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType) # gmapT :: (forall b. Data b => b -> b) -> WireType -> WireType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WireType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WireType -> r # gmapQ :: (forall d. Data d => d -> u) -> WireType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WireType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WireType -> m WireType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WireType -> m WireType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WireType -> m WireType #
Num WireType #
Methods (+) :: WireType -> WireType -> WireType # (-) :: WireType -> WireType -> WireType # (*) :: WireType -> WireType -> WireType # negate :: WireType -> WireType # abs :: WireType -> WireType # signum :: WireType -> WireType # fromInteger :: Integer -> WireType #
Ord WireType #
Methods compare :: WireType -> WireType -> Ordering # (<) :: WireType -> WireType -> Bool # (<=) :: WireType -> WireType -> Bool # (>) :: WireType -> WireType -> Bool # (>=) :: WireType -> WireType -> Bool # max :: WireType -> WireType -> WireType # min :: WireType -> WireType -> WireType #
Read WireType #
Methods readsPrec :: Int -> ReadS WireType # readList :: ReadS [WireType] # readPrec :: ReadPrec WireType # readListPrec :: ReadPrec [WireType] #
Show WireType #
Methods showsPrec :: Int -> WireType -> ShowS # show :: WireType -> String # showList :: [WireType] -> ShowS #

newtype FieldType #

FieldType is the integer associated with the FieldDescriptorProto's Type. The allowed range is currently 1 to 18, as shown below (excerpt from descritor.proto)

   // 0 is reserved for errors.
   // Order is weird for historical reasons.
   TYPE_DOUBLE         = 1;
   TYPE_FLOAT          = 2;
   TYPE_INT64          = 3;   // Not ZigZag encoded.  Negative numbers
                              // take 10 bytes.  Use TYPE_SINT64 if negative
                              // values are likely.
   TYPE_UINT64         = 4;
   TYPE_INT32          = 5;   // Not ZigZag encoded.  Negative numbers
                              // take 10 bytes.  Use TYPE_SINT32 if negative
                              // values are likely.
   TYPE_FIXED64        = 6;
   TYPE_FIXED32        = 7;
   TYPE_BOOL           = 8;
   TYPE_STRING         = 9;
   TYPE_GROUP          = 10;  // Tag-delimited aggregate.
   TYPE_MESSAGE        = 11;  // Length-delimited aggregate.

   // New in version 2.
   TYPE_BYTES          = 12;
   TYPE_UINT32         = 13;
   TYPE_ENUM           = 14;
   TYPE_SFIXED32       = 15;
   TYPE_SFIXED64       = 16;
   TYPE_SINT32         = 17;  // Uses ZigZag encoding.
   TYPE_SINT64         = 18;  // Uses ZigZag encoding.

Constructors

FieldType
Fields getFieldType :: Int

Instances

Bounded FieldType #
Methods minBound :: FieldType # maxBound :: FieldType #
Enum FieldType #
Methods succ :: FieldType -> FieldType # pred :: FieldType -> FieldType # toEnum :: Int -> FieldType # fromEnum :: FieldType -> Int # enumFrom :: FieldType -> [FieldType] # enumFromThen :: FieldType -> FieldType -> [FieldType] # enumFromTo :: FieldType -> FieldType -> [FieldType] # enumFromThenTo :: FieldType -> FieldType -> FieldType -> [FieldType] #
Eq FieldType #
Methods (==) :: FieldType -> FieldType -> Bool # (/=) :: FieldType -> FieldType -> Bool #
Data FieldType #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldType -> c FieldType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldType # toConstr :: FieldType -> Constr # dataTypeOf :: FieldType -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c FieldType) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType) # gmapT :: (forall b. Data b => b -> b) -> FieldType -> FieldType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldType -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldType -> r # gmapQ :: (forall d. Data d => d -> u) -> FieldType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldType -> m FieldType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldType -> m FieldType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldType -> m FieldType #
Num FieldType #
Methods (+) :: FieldType -> FieldType -> FieldType # (-) :: FieldType -> FieldType -> FieldType # (*) :: FieldType -> FieldType -> FieldType # negate :: FieldType -> FieldType # abs :: FieldType -> FieldType # signum :: FieldType -> FieldType # fromInteger :: Integer -> FieldType #
Ord FieldType #
Methods compare :: FieldType -> FieldType -> Ordering # (<) :: FieldType -> FieldType -> Bool # (<=) :: FieldType -> FieldType -> Bool # (>) :: FieldType -> FieldType -> Bool # (>=) :: FieldType -> FieldType -> Bool # max :: FieldType -> FieldType -> FieldType # min :: FieldType -> FieldType -> FieldType #
Read FieldType #
Methods readsPrec :: Int -> ReadS FieldType # readList :: ReadS [FieldType] # readPrec :: ReadPrec FieldType # readListPrec :: ReadPrec [FieldType] #
Show FieldType #
Methods showsPrec :: Int -> FieldType -> ShowS # show :: FieldType -> String # showList :: [FieldType] -> ShowS #

newtype EnumCode #

EnumCode is the Int32 assoicated with a EnumValueDescriptorProto and is in the range 0 to 2^31-1.

Constructors

EnumCode
Fields getEnumCode :: Int32

Instances

Bounded EnumCode #
Methods minBound :: EnumCode # maxBound :: EnumCode #
Eq EnumCode #
Methods (==) :: EnumCode -> EnumCode -> Bool # (/=) :: EnumCode -> EnumCode -> Bool #
Data EnumCode #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EnumCode -> c EnumCode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EnumCode # toConstr :: EnumCode -> Constr # dataTypeOf :: EnumCode -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c EnumCode) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode) # gmapT :: (forall b. Data b => b -> b) -> EnumCode -> EnumCode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnumCode -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnumCode -> r # gmapQ :: (forall d. Data d => d -> u) -> EnumCode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumCode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode #
Num EnumCode #
Methods (+) :: EnumCode -> EnumCode -> EnumCode # (-) :: EnumCode -> EnumCode -> EnumCode # (*) :: EnumCode -> EnumCode -> EnumCode # negate :: EnumCode -> EnumCode # abs :: EnumCode -> EnumCode # signum :: EnumCode -> EnumCode # fromInteger :: Integer -> EnumCode #
Ord EnumCode #
Methods compare :: EnumCode -> EnumCode -> Ordering # (<) :: EnumCode -> EnumCode -> Bool # (<=) :: EnumCode -> EnumCode -> Bool # (>) :: EnumCode -> EnumCode -> Bool # (>=) :: EnumCode -> EnumCode -> Bool # max :: EnumCode -> EnumCode -> EnumCode # min :: EnumCode -> EnumCode -> EnumCode #
Read EnumCode #
Methods readsPrec :: Int -> ReadS EnumCode # readList :: ReadS [EnumCode] # readPrec :: ReadPrec EnumCode # readListPrec :: ReadPrec [EnumCode] #
Show EnumCode #
Methods showsPrec :: Int -> EnumCode -> ShowS # show :: EnumCode -> String # showList :: [EnumCode] -> ShowS #

type WireSize = Int64 #

WireSize is the Int64 size type associated with the lazy bytestrings used in the Put and Get monads.

Some of the type classes implemented messages and fields

class Default a => Mergeable a where #

The Mergeable class is not a Monoid, mergeEmpty is not a left or right unit like mempty. The default mergeAppend is to take the second parameter and discard the first one. The mergeConcat defaults to foldl associativity.

NOTE: mergeEmpty has been removed in protocol buffers version 2. Use defaultValue instead. New strict fields would mean that required fields in messages will be automatic errors with mergeEmpty.

Methods

mergeAppend :: a -> a -> a #

mergeAppend is the right-biased merge of two values. A message (or group) is merged recursively. Required field are always taken from the second message. Optional field values are taken from the most defined message or the second message if both are set. Repeated fields have the sequences concatenated. Note that strings and bytes are NOT concatenated.

mergeConcat :: Foldable t => t a -> a #

mergeConcat is F.foldl mergeAppend defaultValue and this default definition is not overridden in any of the code except for the (Seq a) instance.

Instances

Mergeable Bool #
Methods mergeAppend :: Bool -> Bool -> Bool # mergeConcat :: Foldable t => t Bool -> Bool #
Mergeable Double #
Methods mergeAppend :: Double -> Double -> Double # mergeConcat :: Foldable t => t Double -> Double #
Mergeable Float #
Methods mergeAppend :: Float -> Float -> Float # mergeConcat :: Foldable t => t Float -> Float #
Mergeable Int32 #
Methods mergeAppend :: Int32 -> Int32 -> Int32 # mergeConcat :: Foldable t => t Int32 -> Int32 #
Mergeable Int64 #
Methods mergeAppend :: Int64 -> Int64 -> Int64 # mergeConcat :: Foldable t => t Int64 -> Int64 #
Mergeable Word32 #
Methods mergeAppend :: Word32 -> Word32 -> Word32 # mergeConcat :: Foldable t => t Word32 -> Word32 #
Mergeable Word64 #
Methods mergeAppend :: Word64 -> Word64 -> Word64 # mergeConcat :: Foldable t => t Word64 -> Word64 #
Mergeable ByteString #
Methods mergeAppend :: ByteString -> ByteString -> ByteString # mergeConcat :: Foldable t => t ByteString -> ByteString #
Mergeable Utf8 #
Methods mergeAppend :: Utf8 -> Utf8 -> Utf8 # mergeConcat :: Foldable t => t Utf8 -> Utf8 #
Mergeable UnknownField #
Methods mergeAppend :: UnknownField -> UnknownField -> UnknownField # mergeConcat :: Foldable t => t UnknownField -> UnknownField #
Mergeable ExtField #
Methods mergeAppend :: ExtField -> ExtField -> ExtField # mergeConcat :: Foldable t => t ExtField -> ExtField #
Mergeable a => Mergeable (Maybe a) #
Methods mergeAppend :: Maybe a -> Maybe a -> Maybe a # mergeConcat :: Foldable t => t (Maybe a) -> Maybe a #
Mergeable (Seq a) #
Methods mergeAppend :: Seq a -> Seq a -> Seq a # mergeConcat :: Foldable t => t (Seq a) -> Seq a #

class Default a where #

The Default class has the default-default values of types. See http://code.google.com/apis/protocolbuffers/docs/proto.html#optional and also note that Enum types have a defaultValue that is the first one in the .proto file (there is always at least one value). Instances of this for messages hold any default value defined in the .proto file. defaultValue is where the MessageAPI function getVal looks when an optional field is not set.

Minimal complete definition

defaultValue

Methods

defaultValue :: a #

The defaultValue is never undefined or an error to evalute. This makes it much more useful compared to mergeEmpty. In a default message all Optional field values are set to Nothing and Repeated field values are empty.

Instances

Default Bool #
Methods defaultValue :: Bool #
Default Double #
Methods defaultValue :: Double #
Default Float #
Methods defaultValue :: Float #
Default Int32 #
Methods defaultValue :: Int32 #
Default Int64 #
Methods defaultValue :: Int64 #
Default Word32 #
Methods defaultValue :: Word32 #
Default Word64 #
Methods defaultValue :: Word64 #
Default ByteString #
Methods defaultValue :: ByteString #
Default Utf8 #
Methods defaultValue :: Utf8 #
Default UnknownField #
Methods defaultValue :: UnknownField #
Default ExtField #
Methods defaultValue :: ExtField #
Default (Maybe a) #
Methods defaultValue :: Maybe a #
Default (Seq a) #
Methods defaultValue :: Seq a #

isValidUTF8 :: ByteString -> Maybe Int #

toUtf8 :: ByteString -> Either Int Utf8 #

utf8 :: Utf8 -> ByteString #

uToString :: Utf8 -> String #

uFromString :: String -> Utf8 #