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
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
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
Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
RealFloat Double
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
Methods formatArg :: Double -> FieldFormatter # parseFormat :: Double -> ModifierParser #
Storable Double
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 # 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
MessageAPI msg (msg -> Double) Double #
Methods getVal :: msg -> (msg -> Double) -> Double # isSet :: msg -> (msg -> Double) -> Bool #
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) #
Generic1 (URec Double)
Associated Types type Rep1 (URec Double :: * -> ) :: -> * # Methods from1 :: URec Double a -> Rep1 (URec Double) a # to1 :: Rep1 (URec Double) a -> URec Double a #
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 ()
Eq (URec Double p)
Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Ord (URec Double p)
Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
Show (URec Double p)
Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Generic (URec Double p)
Associated Types type Rep (URec Double p) :: * -> * # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
data URec Double	Used for marking occurrences of `Double#`
data URec Double = UDouble { uDouble# :: Double# }
type Rep1 (URec Double)
type Rep1 (URec Double) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))
type Rep (URec Double p)
type Rep (URec 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
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
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
Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
RealFloat Float
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
Methods formatArg :: Float -> FieldFormatter # parseFormat :: Float -> ModifierParser #
Storable Float
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 # 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
MessageAPI msg (msg -> Float) Float #
Methods getVal :: msg -> (msg -> Float) -> Float # isSet :: msg -> (msg -> Float) -> Bool #
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) #
Generic1 (URec Float)
Associated Types type Rep1 (URec Float :: * -> ) :: -> * # Methods from1 :: URec Float a -> Rep1 (URec Float) a # to1 :: Rep1 (URec Float) a -> URec Float a #
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 ()
Eq (URec Float p)
Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Ord (URec Float p)
Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
Show (URec Float p)
Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Generic (URec Float p)
Associated Types type Rep (URec Float p) :: * -> * # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
data URec Float	Used for marking occurrences of `Float#`
data URec Float = UFloat { uFloat# :: Float# }
type Rep1 (URec Float)
type Rep1 (URec Float) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))
type Rep (URec Float p)
type Rep (URec 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
Methods minBound :: Bool # maxBound :: Bool #
Enum Bool
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
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
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
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 #
Storable Bool
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
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
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 # 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
Methods sing :: Sing False a
SingI Bool True
Methods sing :: Sing True a
SingKind Bool (KProxy Bool)
Associated Types type DemoteRep (KProxy Bool) (kparam :: KProxy (KProxy Bool)) :: * Methods fromSing :: Sing (KProxy Bool) a -> DemoteRep (KProxy Bool) kparam
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 (==) Bool a b
type (==) Bool a b = EqBool a b
type DemoteRep Bool (KProxy Bool)
type DemoteRep Bool (KProxy Bool) = Bool

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
Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a # fail :: String -> Maybe a #
Functor Maybe
Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Applicative Maybe
Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Foldable Maybe
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
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) #
Generic1 Maybe
Associated Types type Rep1 (Maybe :: * -> ) :: -> * # Methods from1 :: Maybe a -> Rep1 Maybe a # to1 :: Rep1 Maybe a -> Maybe a #
Eq1 Maybe
Methods liftEq :: (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool #
Ord1 Maybe
Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering #
Read1 Maybe
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] #
Show1 Maybe
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Maybe a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Maybe a] -> ShowS #
Alternative Maybe
Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
MonadPlus Maybe
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 #
(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)
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)
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)
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 = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead.
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> 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) #
SingI (Maybe a) (Nothing a)
Methods sing :: Sing (Nothing a) a
SingKind a (KProxy a) => SingKind (Maybe a) (KProxy (Maybe a))
Associated Types type DemoteRep (KProxy (Maybe a)) (kparam :: KProxy (KProxy (Maybe a))) :: * Methods fromSing :: Sing (KProxy (Maybe a)) a -> DemoteRep (KProxy (Maybe a)) kparam
SingI a a1 => SingI (Maybe a) (Just a a1)
Methods sing :: Sing (Just a a1) 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 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 (==) (Maybe k) a b
type (==) (Maybe k) a b = EqMaybe k a b
type DemoteRep (Maybe a) (KProxy (Maybe a))
type DemoteRep (Maybe a) (KProxy (Maybe a)) = Maybe (DemoteRep a (KProxy a))

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 # (>) :: 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) #
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 #
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 #
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 # 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 # 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
Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32
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
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Integral Int32
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
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
Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Ord Int32
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
Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Real Int32
Methods toRational :: Int32 -> Rational #
Show Int32
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Ix Int32
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
Methods formatArg :: Int32 -> FieldFormatter # parseFormat :: Int32 -> ModifierParser #
Storable Int32
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
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
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 # 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
Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64
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
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Integral Int64
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
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
Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Ord Int64
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
Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Real Int64
Methods toRational :: Int64 -> Rational #
Show Int64
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Ix Int64
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
Methods formatArg :: Int64 -> FieldFormatter # parseFormat :: Int64 -> ModifierParser #
Storable Int64
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
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
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 # 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
Methods minBound :: Word32 # maxBound :: Word32 #
Enum Word32
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
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Integral Word32
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
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
Methods (+) :: Word32 -> Word32 -> Word32 # (-) :: Word32 -> Word32 -> Word32 # (*) :: Word32 -> Word32 -> Word32 # negate :: Word32 -> Word32 # abs :: Word32 -> Word32 # signum :: Word32 -> Word32 # fromInteger :: Integer -> Word32 #
Ord Word32
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
Methods readsPrec :: Int -> ReadS Word32 # readList :: ReadS [Word32] # readPrec :: ReadPrec Word32 # readListPrec :: ReadPrec [Word32] #
Real Word32
Methods toRational :: Word32 -> Rational #
Show Word32
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Ix Word32
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
Methods formatArg :: Word32 -> FieldFormatter # parseFormat :: Word32 -> ModifierParser #
Storable Word32
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
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
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 # 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
Methods minBound :: Word64 # maxBound :: Word64 #
Enum Word64
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
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Integral Word64
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
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
Methods (+) :: Word64 -> Word64 -> Word64 # (-) :: Word64 -> Word64 -> Word64 # (*) :: Word64 -> Word64 -> Word64 # negate :: Word64 -> Word64 # abs :: Word64 -> Word64 # signum :: Word64 -> Word64 # fromInteger :: Integer -> Word64 #
Ord Word64
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
Methods readsPrec :: Int -> ReadS Word64 # readList :: ReadS [Word64] # readPrec :: ReadPrec Word64 # readListPrec :: ReadPrec [Word64] #
Real Word64
Methods toRational :: Word64 -> Rational #
Show Word64
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Ix Word64
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
Methods formatArg :: Word64 -> FieldFormatter # parseFormat :: Word64 -> ModifierParser #
Storable Word64
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
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
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 # 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 ExtField #
Methods mergeAppend :: ExtField -> ExtField -> ExtField # mergeConcat :: Foldable t => t ExtField -> ExtField #
Mergeable UnknownField #
Methods mergeAppend :: UnknownField -> UnknownField -> UnknownField # mergeConcat :: Foldable t => t UnknownField -> UnknownField #
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 ExtField #
Methods defaultValue :: ExtField #
Default UnknownField #
Methods defaultValue :: UnknownField #
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 #