{-# LANGUAGE DeriveDataTypeable,GeneralizedNewtypeDeriving,CPP #-}
module Text.ProtocolBuffers.Basic
(
Double,Float,Bool,Maybe,Seq,Utf8(Utf8),ByteString,Int32,Int64,Word32,Word64
, WireTag(..),FieldId(..),WireType(..),FieldType(..),EnumCode(..),WireSize
, Mergeable(..),Default(..)
, isValidUTF8, toUtf8, utf8, uToString, uFromString
) where
import Data.Aeson
import Data.Bits(Bits)
import Data.ByteString.Lazy(ByteString)
import Data.Foldable as F(Foldable(foldl))
import Data.Generics(Data(..))
import Data.Int(Int32,Int64)
import Data.Ix(Ix)
import Data.Semigroup (Semigroup(..))
import Data.Sequence(Seq,(><))
import Data.String (IsString(..))
import Data.Typeable(Typeable)
import Data.Word(Word8,Word32,Word64)
import qualified Data.ByteString.Lazy as L(unpack)
import Data.ByteString.Lazy.UTF8 as U (toString,fromString)
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Encoding as TL
newtype Utf8 = Utf8 ByteString deriving (Typeable Utf8
DataType
Constr
Typeable Utf8
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8)
-> (Utf8 -> Constr)
-> (Utf8 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Utf8))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8))
-> ((forall b. Data b => b -> b) -> Utf8 -> Utf8)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Utf8 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Utf8 -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8)
-> Data Utf8
Utf8 -> DataType
Utf8 -> Constr
(forall b. Data b => b -> b) -> Utf8 -> Utf8
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Utf8 -> u
forall u. (forall d. Data d => d -> u) -> Utf8 -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Utf8)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8)
$cUtf8 :: Constr
$tUtf8 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Utf8 -> m Utf8
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
gmapMp :: (forall d. Data d => d -> m d) -> Utf8 -> m Utf8
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
gmapM :: (forall d. Data d => d -> m d) -> Utf8 -> m Utf8
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Utf8 -> m Utf8
gmapQi :: Int -> (forall d. Data d => d -> u) -> Utf8 -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Utf8 -> u
gmapQ :: (forall d. Data d => d -> u) -> Utf8 -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Utf8 -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Utf8 -> r
gmapT :: (forall b. Data b => b -> b) -> Utf8 -> Utf8
$cgmapT :: (forall b. Data b => b -> b) -> Utf8 -> Utf8
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Utf8)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Utf8)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Utf8)
dataTypeOf :: Utf8 -> DataType
$cdataTypeOf :: Utf8 -> DataType
toConstr :: Utf8 -> Constr
$ctoConstr :: Utf8 -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Utf8
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Utf8 -> c Utf8
$cp1Data :: Typeable Utf8
Data,Typeable,Utf8 -> Utf8 -> Bool
(Utf8 -> Utf8 -> Bool) -> (Utf8 -> Utf8 -> Bool) -> Eq Utf8
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Utf8 -> Utf8 -> Bool
$c/= :: Utf8 -> Utf8 -> Bool
== :: Utf8 -> Utf8 -> Bool
$c== :: Utf8 -> Utf8 -> Bool
Eq,Eq Utf8
Eq Utf8
-> (Utf8 -> Utf8 -> Ordering)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Bool)
-> (Utf8 -> Utf8 -> Utf8)
-> (Utf8 -> Utf8 -> Utf8)
-> Ord Utf8
Utf8 -> Utf8 -> Bool
Utf8 -> Utf8 -> Ordering
Utf8 -> Utf8 -> Utf8
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Utf8 -> Utf8 -> Utf8
$cmin :: Utf8 -> Utf8 -> Utf8
max :: Utf8 -> Utf8 -> Utf8
$cmax :: Utf8 -> Utf8 -> Utf8
>= :: Utf8 -> Utf8 -> Bool
$c>= :: Utf8 -> Utf8 -> Bool
> :: Utf8 -> Utf8 -> Bool
$c> :: Utf8 -> Utf8 -> Bool
<= :: Utf8 -> Utf8 -> Bool
$c<= :: Utf8 -> Utf8 -> Bool
< :: Utf8 -> Utf8 -> Bool
$c< :: Utf8 -> Utf8 -> Bool
compare :: Utf8 -> Utf8 -> Ordering
$ccompare :: Utf8 -> Utf8 -> Ordering
$cp1Ord :: Eq Utf8
Ord)
utf8 :: Utf8 -> ByteString
utf8 :: Utf8 -> ByteString
utf8 (Utf8 ByteString
bs) = ByteString
bs
instance Read Utf8 where
readsPrec :: Int -> ReadS Utf8
readsPrec Int
d String
xs = let r :: Int -> ReadS String
r :: Int -> ReadS String
r = Int -> ReadS String
forall a. Read a => Int -> ReadS a
readsPrec
f :: (String,String) -> (Utf8,String)
f :: (String, String) -> (Utf8, String)
f (String
a,String
b) = (ByteString -> Utf8
Utf8 (String -> ByteString
U.fromString String
a),String
b)
in ((String, String) -> (Utf8, String))
-> [(String, String)] -> [(Utf8, String)]
forall a b. (a -> b) -> [a] -> [b]
map (String, String) -> (Utf8, String)
f ([(String, String)] -> [(Utf8, String)])
-> ReadS String -> ReadS Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ReadS String
r Int
d ReadS Utf8 -> ReadS Utf8
forall a b. (a -> b) -> a -> b
$ String
xs
instance Show Utf8 where
showsPrec :: Int -> Utf8 -> ShowS
showsPrec Int
d (Utf8 ByteString
bs) = let s :: Int -> String -> ShowS
s :: Int -> String -> ShowS
s = Int -> String -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec
in Int -> String -> ShowS
s Int
d (ByteString -> String
U.toString ByteString
bs)
instance IsString Utf8 where
fromString :: String -> Utf8
fromString = String -> Utf8
uFromString
instance Semigroup Utf8 where
<> :: Utf8 -> Utf8 -> Utf8
(<>) (Utf8 ByteString
x) (Utf8 ByteString
y) = ByteString -> Utf8
Utf8 (ByteString
x ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
y)
instance Monoid Utf8 where
mempty :: Utf8
mempty = ByteString -> Utf8
Utf8 ByteString
forall a. Monoid a => a
mempty
mappend :: Utf8 -> Utf8 -> Utf8
mappend = Utf8 -> Utf8 -> Utf8
forall a. Semigroup a => a -> a -> a
(<>)
instance ToJSON Utf8 where
toJSON :: Utf8 -> Value
toJSON (Utf8 ByteString
t) = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (ByteString -> Text
TL.decodeUtf8 ByteString
t)
instance FromJSON Utf8 where
parseJSON :: Value -> Parser Utf8
parseJSON Value
value =
case Value
value of
String Text
t -> Utf8 -> Parser Utf8
forall (m :: * -> *) a. Monad m => a -> m a
return (Utf8 -> Parser Utf8) -> (Text -> Utf8) -> Text -> Parser Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Utf8
Utf8 (ByteString -> Utf8) -> (Text -> ByteString) -> Text -> Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
TL.encodeUtf8 (Text -> ByteString) -> (Text -> Text) -> Text -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
TL.fromStrict (Text -> Parser Utf8) -> Text -> Parser Utf8
forall a b. (a -> b) -> a -> b
$ Text
t
Value
_ -> String -> Parser Utf8
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Value " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Value -> String
forall a. Show a => a -> String
show Value
value String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" is not a UTF-8 string")
newtype WireTag = WireTag { WireTag -> Word32
getWireTag :: Word32 }
deriving (WireTag -> WireTag -> Bool
(WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool) -> Eq WireTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WireTag -> WireTag -> Bool
$c/= :: WireTag -> WireTag -> Bool
== :: WireTag -> WireTag -> Bool
$c== :: WireTag -> WireTag -> Bool
Eq,Eq WireTag
Eq WireTag
-> (WireTag -> WireTag -> Ordering)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> Bool)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> Ord WireTag
WireTag -> WireTag -> Bool
WireTag -> WireTag -> Ordering
WireTag -> WireTag -> WireTag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: WireTag -> WireTag -> WireTag
$cmin :: WireTag -> WireTag -> WireTag
max :: WireTag -> WireTag -> WireTag
$cmax :: WireTag -> WireTag -> WireTag
>= :: WireTag -> WireTag -> Bool
$c>= :: WireTag -> WireTag -> Bool
> :: WireTag -> WireTag -> Bool
$c> :: WireTag -> WireTag -> Bool
<= :: WireTag -> WireTag -> Bool
$c<= :: WireTag -> WireTag -> Bool
< :: WireTag -> WireTag -> Bool
$c< :: WireTag -> WireTag -> Bool
compare :: WireTag -> WireTag -> Ordering
$ccompare :: WireTag -> WireTag -> Ordering
$cp1Ord :: Eq WireTag
Ord,Int -> WireTag
WireTag -> Int
WireTag -> [WireTag]
WireTag -> WireTag
WireTag -> WireTag -> [WireTag]
WireTag -> WireTag -> WireTag -> [WireTag]
(WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (Int -> WireTag)
-> (WireTag -> Int)
-> (WireTag -> [WireTag])
-> (WireTag -> WireTag -> [WireTag])
-> (WireTag -> WireTag -> [WireTag])
-> (WireTag -> WireTag -> WireTag -> [WireTag])
-> Enum WireTag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: WireTag -> WireTag -> WireTag -> [WireTag]
$cenumFromThenTo :: WireTag -> WireTag -> WireTag -> [WireTag]
enumFromTo :: WireTag -> WireTag -> [WireTag]
$cenumFromTo :: WireTag -> WireTag -> [WireTag]
enumFromThen :: WireTag -> WireTag -> [WireTag]
$cenumFromThen :: WireTag -> WireTag -> [WireTag]
enumFrom :: WireTag -> [WireTag]
$cenumFrom :: WireTag -> [WireTag]
fromEnum :: WireTag -> Int
$cfromEnum :: WireTag -> Int
toEnum :: Int -> WireTag
$ctoEnum :: Int -> WireTag
pred :: WireTag -> WireTag
$cpred :: WireTag -> WireTag
succ :: WireTag -> WireTag
$csucc :: WireTag -> WireTag
Enum,ReadPrec [WireTag]
ReadPrec WireTag
Int -> ReadS WireTag
ReadS [WireTag]
(Int -> ReadS WireTag)
-> ReadS [WireTag]
-> ReadPrec WireTag
-> ReadPrec [WireTag]
-> Read WireTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WireTag]
$creadListPrec :: ReadPrec [WireTag]
readPrec :: ReadPrec WireTag
$creadPrec :: ReadPrec WireTag
readList :: ReadS [WireTag]
$creadList :: ReadS [WireTag]
readsPrec :: Int -> ReadS WireTag
$creadsPrec :: Int -> ReadS WireTag
Read,Int -> WireTag -> ShowS
[WireTag] -> ShowS
WireTag -> String
(Int -> WireTag -> ShowS)
-> (WireTag -> String) -> ([WireTag] -> ShowS) -> Show WireTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WireTag] -> ShowS
$cshowList :: [WireTag] -> ShowS
show :: WireTag -> String
$cshow :: WireTag -> String
showsPrec :: Int -> WireTag -> ShowS
$cshowsPrec :: Int -> WireTag -> ShowS
Show,Integer -> WireTag
WireTag -> WireTag
WireTag -> WireTag -> WireTag
(WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (Integer -> WireTag)
-> Num WireTag
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> WireTag
$cfromInteger :: Integer -> WireTag
signum :: WireTag -> WireTag
$csignum :: WireTag -> WireTag
abs :: WireTag -> WireTag
$cabs :: WireTag -> WireTag
negate :: WireTag -> WireTag
$cnegate :: WireTag -> WireTag
* :: WireTag -> WireTag -> WireTag
$c* :: WireTag -> WireTag -> WireTag
- :: WireTag -> WireTag -> WireTag
$c- :: WireTag -> WireTag -> WireTag
+ :: WireTag -> WireTag -> WireTag
$c+ :: WireTag -> WireTag -> WireTag
Num,Eq WireTag
WireTag
Eq WireTag
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag -> WireTag)
-> (WireTag -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> WireTag
-> (Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> Bool)
-> (WireTag -> Maybe Int)
-> (WireTag -> Int)
-> (WireTag -> Bool)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int -> WireTag)
-> (WireTag -> Int)
-> Bits WireTag
Int -> WireTag
WireTag -> Bool
WireTag -> Int
WireTag -> Maybe Int
WireTag -> WireTag
WireTag -> Int -> Bool
WireTag -> Int -> WireTag
WireTag -> WireTag -> WireTag
forall a.
Eq a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> a
-> (Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> Bool)
-> (a -> Maybe Int)
-> (a -> Int)
-> (a -> Bool)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int -> a)
-> (a -> Int)
-> Bits a
popCount :: WireTag -> Int
$cpopCount :: WireTag -> Int
rotateR :: WireTag -> Int -> WireTag
$crotateR :: WireTag -> Int -> WireTag
rotateL :: WireTag -> Int -> WireTag
$crotateL :: WireTag -> Int -> WireTag
unsafeShiftR :: WireTag -> Int -> WireTag
$cunsafeShiftR :: WireTag -> Int -> WireTag
shiftR :: WireTag -> Int -> WireTag
$cshiftR :: WireTag -> Int -> WireTag
unsafeShiftL :: WireTag -> Int -> WireTag
$cunsafeShiftL :: WireTag -> Int -> WireTag
shiftL :: WireTag -> Int -> WireTag
$cshiftL :: WireTag -> Int -> WireTag
isSigned :: WireTag -> Bool
$cisSigned :: WireTag -> Bool
bitSize :: WireTag -> Int
$cbitSize :: WireTag -> Int
bitSizeMaybe :: WireTag -> Maybe Int
$cbitSizeMaybe :: WireTag -> Maybe Int
testBit :: WireTag -> Int -> Bool
$ctestBit :: WireTag -> Int -> Bool
complementBit :: WireTag -> Int -> WireTag
$ccomplementBit :: WireTag -> Int -> WireTag
clearBit :: WireTag -> Int -> WireTag
$cclearBit :: WireTag -> Int -> WireTag
setBit :: WireTag -> Int -> WireTag
$csetBit :: WireTag -> Int -> WireTag
bit :: Int -> WireTag
$cbit :: Int -> WireTag
zeroBits :: WireTag
$czeroBits :: WireTag
rotate :: WireTag -> Int -> WireTag
$crotate :: WireTag -> Int -> WireTag
shift :: WireTag -> Int -> WireTag
$cshift :: WireTag -> Int -> WireTag
complement :: WireTag -> WireTag
$ccomplement :: WireTag -> WireTag
xor :: WireTag -> WireTag -> WireTag
$cxor :: WireTag -> WireTag -> WireTag
.|. :: WireTag -> WireTag -> WireTag
$c.|. :: WireTag -> WireTag -> WireTag
.&. :: WireTag -> WireTag -> WireTag
$c.&. :: WireTag -> WireTag -> WireTag
$cp1Bits :: Eq WireTag
Bits,WireTag
WireTag -> WireTag -> Bounded WireTag
forall a. a -> a -> Bounded a
maxBound :: WireTag
$cmaxBound :: WireTag
minBound :: WireTag
$cminBound :: WireTag
Bounded,Typeable WireTag
DataType
Constr
Typeable WireTag
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag)
-> (WireTag -> Constr)
-> (WireTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag))
-> ((forall b. Data b => b -> b) -> WireTag -> WireTag)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r)
-> (forall u. (forall d. Data d => d -> u) -> WireTag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> WireTag -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag)
-> Data WireTag
WireTag -> DataType
WireTag -> Constr
(forall b. Data b => b -> b) -> WireTag -> WireTag
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> WireTag -> u
forall u. (forall d. Data d => d -> u) -> WireTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag)
$cWireTag :: Constr
$tWireTag :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> WireTag -> m WireTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
gmapMp :: (forall d. Data d => d -> m d) -> WireTag -> m WireTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
gmapM :: (forall d. Data d => d -> m d) -> WireTag -> m WireTag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireTag -> m WireTag
gmapQi :: Int -> (forall d. Data d => d -> u) -> WireTag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WireTag -> u
gmapQ :: (forall d. Data d => d -> u) -> WireTag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WireTag -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireTag -> r
gmapT :: (forall b. Data b => b -> b) -> WireTag -> WireTag
$cgmapT :: (forall b. Data b => b -> b) -> WireTag -> WireTag
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireTag)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c WireTag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireTag)
dataTypeOf :: WireTag -> DataType
$cdataTypeOf :: WireTag -> DataType
toConstr :: WireTag -> Constr
$ctoConstr :: WireTag -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireTag
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireTag -> c WireTag
$cp1Data :: Typeable WireTag
Data,Typeable)
newtype FieldId = FieldId { FieldId -> Int32
getFieldId :: Int32 }
deriving (FieldId -> FieldId -> Bool
(FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool) -> Eq FieldId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldId -> FieldId -> Bool
$c/= :: FieldId -> FieldId -> Bool
== :: FieldId -> FieldId -> Bool
$c== :: FieldId -> FieldId -> Bool
Eq,Eq FieldId
Eq FieldId
-> (FieldId -> FieldId -> Ordering)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> Bool)
-> (FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId -> FieldId)
-> Ord FieldId
FieldId -> FieldId -> Bool
FieldId -> FieldId -> Ordering
FieldId -> FieldId -> FieldId
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FieldId -> FieldId -> FieldId
$cmin :: FieldId -> FieldId -> FieldId
max :: FieldId -> FieldId -> FieldId
$cmax :: FieldId -> FieldId -> FieldId
>= :: FieldId -> FieldId -> Bool
$c>= :: FieldId -> FieldId -> Bool
> :: FieldId -> FieldId -> Bool
$c> :: FieldId -> FieldId -> Bool
<= :: FieldId -> FieldId -> Bool
$c<= :: FieldId -> FieldId -> Bool
< :: FieldId -> FieldId -> Bool
$c< :: FieldId -> FieldId -> Bool
compare :: FieldId -> FieldId -> Ordering
$ccompare :: FieldId -> FieldId -> Ordering
$cp1Ord :: Eq FieldId
Ord,Int -> FieldId
FieldId -> Int
FieldId -> [FieldId]
FieldId -> FieldId
FieldId -> FieldId -> [FieldId]
FieldId -> FieldId -> FieldId -> [FieldId]
(FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (Int -> FieldId)
-> (FieldId -> Int)
-> (FieldId -> [FieldId])
-> (FieldId -> FieldId -> [FieldId])
-> (FieldId -> FieldId -> [FieldId])
-> (FieldId -> FieldId -> FieldId -> [FieldId])
-> Enum FieldId
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FieldId -> FieldId -> FieldId -> [FieldId]
$cenumFromThenTo :: FieldId -> FieldId -> FieldId -> [FieldId]
enumFromTo :: FieldId -> FieldId -> [FieldId]
$cenumFromTo :: FieldId -> FieldId -> [FieldId]
enumFromThen :: FieldId -> FieldId -> [FieldId]
$cenumFromThen :: FieldId -> FieldId -> [FieldId]
enumFrom :: FieldId -> [FieldId]
$cenumFrom :: FieldId -> [FieldId]
fromEnum :: FieldId -> Int
$cfromEnum :: FieldId -> Int
toEnum :: Int -> FieldId
$ctoEnum :: Int -> FieldId
pred :: FieldId -> FieldId
$cpred :: FieldId -> FieldId
succ :: FieldId -> FieldId
$csucc :: FieldId -> FieldId
Enum,ReadPrec [FieldId]
ReadPrec FieldId
Int -> ReadS FieldId
ReadS [FieldId]
(Int -> ReadS FieldId)
-> ReadS [FieldId]
-> ReadPrec FieldId
-> ReadPrec [FieldId]
-> Read FieldId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldId]
$creadListPrec :: ReadPrec [FieldId]
readPrec :: ReadPrec FieldId
$creadPrec :: ReadPrec FieldId
readList :: ReadS [FieldId]
$creadList :: ReadS [FieldId]
readsPrec :: Int -> ReadS FieldId
$creadsPrec :: Int -> ReadS FieldId
Read,Int -> FieldId -> ShowS
[FieldId] -> ShowS
FieldId -> String
(Int -> FieldId -> ShowS)
-> (FieldId -> String) -> ([FieldId] -> ShowS) -> Show FieldId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldId] -> ShowS
$cshowList :: [FieldId] -> ShowS
show :: FieldId -> String
$cshow :: FieldId -> String
showsPrec :: Int -> FieldId -> ShowS
$cshowsPrec :: Int -> FieldId -> ShowS
Show,Integer -> FieldId
FieldId -> FieldId
FieldId -> FieldId -> FieldId
(FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (FieldId -> FieldId)
-> (Integer -> FieldId)
-> Num FieldId
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> FieldId
$cfromInteger :: Integer -> FieldId
signum :: FieldId -> FieldId
$csignum :: FieldId -> FieldId
abs :: FieldId -> FieldId
$cabs :: FieldId -> FieldId
negate :: FieldId -> FieldId
$cnegate :: FieldId -> FieldId
* :: FieldId -> FieldId -> FieldId
$c* :: FieldId -> FieldId -> FieldId
- :: FieldId -> FieldId -> FieldId
$c- :: FieldId -> FieldId -> FieldId
+ :: FieldId -> FieldId -> FieldId
$c+ :: FieldId -> FieldId -> FieldId
Num,Typeable FieldId
DataType
Constr
Typeable FieldId
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId)
-> (FieldId -> Constr)
-> (FieldId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId))
-> ((forall b. Data b => b -> b) -> FieldId -> FieldId)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId)
-> Data FieldId
FieldId -> DataType
FieldId -> Constr
(forall b. Data b => b -> b) -> FieldId -> FieldId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u
forall u. (forall d. Data d => d -> u) -> FieldId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
$cFieldId :: Constr
$tFieldId :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapMp :: (forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapM :: (forall d. Data d => d -> m d) -> FieldId -> m FieldId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldId -> m FieldId
gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldId -> u
gmapQ :: (forall d. Data d => d -> u) -> FieldId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldId -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldId -> r
gmapT :: (forall b. Data b => b -> b) -> FieldId -> FieldId
$cgmapT :: (forall b. Data b => b -> b) -> FieldId -> FieldId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FieldId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldId)
dataTypeOf :: FieldId -> DataType
$cdataTypeOf :: FieldId -> DataType
toConstr :: FieldId -> Constr
$ctoConstr :: FieldId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldId -> c FieldId
$cp1Data :: Typeable FieldId
Data,Typeable,Ord FieldId
Ord FieldId
-> ((FieldId, FieldId) -> [FieldId])
-> ((FieldId, FieldId) -> FieldId -> Int)
-> ((FieldId, FieldId) -> FieldId -> Int)
-> ((FieldId, FieldId) -> FieldId -> Bool)
-> ((FieldId, FieldId) -> Int)
-> ((FieldId, FieldId) -> Int)
-> Ix FieldId
(FieldId, FieldId) -> Int
(FieldId, FieldId) -> [FieldId]
(FieldId, FieldId) -> FieldId -> Bool
(FieldId, FieldId) -> FieldId -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (FieldId, FieldId) -> Int
$cunsafeRangeSize :: (FieldId, FieldId) -> Int
rangeSize :: (FieldId, FieldId) -> Int
$crangeSize :: (FieldId, FieldId) -> Int
inRange :: (FieldId, FieldId) -> FieldId -> Bool
$cinRange :: (FieldId, FieldId) -> FieldId -> Bool
unsafeIndex :: (FieldId, FieldId) -> FieldId -> Int
$cunsafeIndex :: (FieldId, FieldId) -> FieldId -> Int
index :: (FieldId, FieldId) -> FieldId -> Int
$cindex :: (FieldId, FieldId) -> FieldId -> Int
range :: (FieldId, FieldId) -> [FieldId]
$crange :: (FieldId, FieldId) -> [FieldId]
$cp1Ix :: Ord FieldId
Ix)
instance Bounded FieldId where
minBound :: FieldId
minBound = FieldId
1
maxBound :: FieldId
maxBound = FieldId
536870911
newtype WireType = WireType { WireType -> Word32
getWireType :: Word32 }
deriving (WireType -> WireType -> Bool
(WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool) -> Eq WireType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WireType -> WireType -> Bool
$c/= :: WireType -> WireType -> Bool
== :: WireType -> WireType -> Bool
$c== :: WireType -> WireType -> Bool
Eq,Eq WireType
Eq WireType
-> (WireType -> WireType -> Ordering)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> Bool)
-> (WireType -> WireType -> WireType)
-> (WireType -> WireType -> WireType)
-> Ord WireType
WireType -> WireType -> Bool
WireType -> WireType -> Ordering
WireType -> WireType -> WireType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: WireType -> WireType -> WireType
$cmin :: WireType -> WireType -> WireType
max :: WireType -> WireType -> WireType
$cmax :: WireType -> WireType -> WireType
>= :: WireType -> WireType -> Bool
$c>= :: WireType -> WireType -> Bool
> :: WireType -> WireType -> Bool
$c> :: WireType -> WireType -> Bool
<= :: WireType -> WireType -> Bool
$c<= :: WireType -> WireType -> Bool
< :: WireType -> WireType -> Bool
$c< :: WireType -> WireType -> Bool
compare :: WireType -> WireType -> Ordering
$ccompare :: WireType -> WireType -> Ordering
$cp1Ord :: Eq WireType
Ord,Int -> WireType
WireType -> Int
WireType -> [WireType]
WireType -> WireType
WireType -> WireType -> [WireType]
WireType -> WireType -> WireType -> [WireType]
(WireType -> WireType)
-> (WireType -> WireType)
-> (Int -> WireType)
-> (WireType -> Int)
-> (WireType -> [WireType])
-> (WireType -> WireType -> [WireType])
-> (WireType -> WireType -> [WireType])
-> (WireType -> WireType -> WireType -> [WireType])
-> Enum WireType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: WireType -> WireType -> WireType -> [WireType]
$cenumFromThenTo :: WireType -> WireType -> WireType -> [WireType]
enumFromTo :: WireType -> WireType -> [WireType]
$cenumFromTo :: WireType -> WireType -> [WireType]
enumFromThen :: WireType -> WireType -> [WireType]
$cenumFromThen :: WireType -> WireType -> [WireType]
enumFrom :: WireType -> [WireType]
$cenumFrom :: WireType -> [WireType]
fromEnum :: WireType -> Int
$cfromEnum :: WireType -> Int
toEnum :: Int -> WireType
$ctoEnum :: Int -> WireType
pred :: WireType -> WireType
$cpred :: WireType -> WireType
succ :: WireType -> WireType
$csucc :: WireType -> WireType
Enum,ReadPrec [WireType]
ReadPrec WireType
Int -> ReadS WireType
ReadS [WireType]
(Int -> ReadS WireType)
-> ReadS [WireType]
-> ReadPrec WireType
-> ReadPrec [WireType]
-> Read WireType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WireType]
$creadListPrec :: ReadPrec [WireType]
readPrec :: ReadPrec WireType
$creadPrec :: ReadPrec WireType
readList :: ReadS [WireType]
$creadList :: ReadS [WireType]
readsPrec :: Int -> ReadS WireType
$creadsPrec :: Int -> ReadS WireType
Read,Int -> WireType -> ShowS
[WireType] -> ShowS
WireType -> String
(Int -> WireType -> ShowS)
-> (WireType -> String) -> ([WireType] -> ShowS) -> Show WireType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WireType] -> ShowS
$cshowList :: [WireType] -> ShowS
show :: WireType -> String
$cshow :: WireType -> String
showsPrec :: Int -> WireType -> ShowS
$cshowsPrec :: Int -> WireType -> ShowS
Show,Integer -> WireType
WireType -> WireType
WireType -> WireType -> WireType
(WireType -> WireType -> WireType)
-> (WireType -> WireType -> WireType)
-> (WireType -> WireType -> WireType)
-> (WireType -> WireType)
-> (WireType -> WireType)
-> (WireType -> WireType)
-> (Integer -> WireType)
-> Num WireType
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> WireType
$cfromInteger :: Integer -> WireType
signum :: WireType -> WireType
$csignum :: WireType -> WireType
abs :: WireType -> WireType
$cabs :: WireType -> WireType
negate :: WireType -> WireType
$cnegate :: WireType -> WireType
* :: WireType -> WireType -> WireType
$c* :: WireType -> WireType -> WireType
- :: WireType -> WireType -> WireType
$c- :: WireType -> WireType -> WireType
+ :: WireType -> WireType -> WireType
$c+ :: WireType -> WireType -> WireType
Num,Typeable WireType
DataType
Constr
Typeable WireType
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType)
-> (WireType -> Constr)
-> (WireType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType))
-> ((forall b. Data b => b -> b) -> WireType -> WireType)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r)
-> (forall u. (forall d. Data d => d -> u) -> WireType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> WireType -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType)
-> Data WireType
WireType -> DataType
WireType -> Constr
(forall b. Data b => b -> b) -> WireType -> WireType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> WireType -> u
forall u. (forall d. Data d => d -> u) -> WireType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType)
$cWireType :: Constr
$tWireType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> WireType -> m WireType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
gmapMp :: (forall d. Data d => d -> m d) -> WireType -> m WireType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
gmapM :: (forall d. Data d => d -> m d) -> WireType -> m WireType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireType -> m WireType
gmapQi :: Int -> (forall d. Data d => d -> u) -> WireType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WireType -> u
gmapQ :: (forall d. Data d => d -> u) -> WireType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WireType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireType -> r
gmapT :: (forall b. Data b => b -> b) -> WireType -> WireType
$cgmapT :: (forall b. Data b => b -> b) -> WireType -> WireType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c WireType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireType)
dataTypeOf :: WireType -> DataType
$cdataTypeOf :: WireType -> DataType
toConstr :: WireType -> Constr
$ctoConstr :: WireType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireType -> c WireType
$cp1Data :: Typeable WireType
Data,Typeable)
instance Bounded WireType where
minBound :: WireType
minBound = WireType
0
maxBound :: WireType
maxBound = WireType
5
newtype FieldType = FieldType { FieldType -> Int
getFieldType :: Int }
deriving (FieldType -> FieldType -> Bool
(FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool) -> Eq FieldType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldType -> FieldType -> Bool
$c/= :: FieldType -> FieldType -> Bool
== :: FieldType -> FieldType -> Bool
$c== :: FieldType -> FieldType -> Bool
Eq,Eq FieldType
Eq FieldType
-> (FieldType -> FieldType -> Ordering)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> Bool)
-> (FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType -> FieldType)
-> Ord FieldType
FieldType -> FieldType -> Bool
FieldType -> FieldType -> Ordering
FieldType -> FieldType -> FieldType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FieldType -> FieldType -> FieldType
$cmin :: FieldType -> FieldType -> FieldType
max :: FieldType -> FieldType -> FieldType
$cmax :: FieldType -> FieldType -> FieldType
>= :: FieldType -> FieldType -> Bool
$c>= :: FieldType -> FieldType -> Bool
> :: FieldType -> FieldType -> Bool
$c> :: FieldType -> FieldType -> Bool
<= :: FieldType -> FieldType -> Bool
$c<= :: FieldType -> FieldType -> Bool
< :: FieldType -> FieldType -> Bool
$c< :: FieldType -> FieldType -> Bool
compare :: FieldType -> FieldType -> Ordering
$ccompare :: FieldType -> FieldType -> Ordering
$cp1Ord :: Eq FieldType
Ord,Int -> FieldType
FieldType -> Int
FieldType -> [FieldType]
FieldType -> FieldType
FieldType -> FieldType -> [FieldType]
FieldType -> FieldType -> FieldType -> [FieldType]
(FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (Int -> FieldType)
-> (FieldType -> Int)
-> (FieldType -> [FieldType])
-> (FieldType -> FieldType -> [FieldType])
-> (FieldType -> FieldType -> [FieldType])
-> (FieldType -> FieldType -> FieldType -> [FieldType])
-> Enum FieldType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FieldType -> FieldType -> FieldType -> [FieldType]
$cenumFromThenTo :: FieldType -> FieldType -> FieldType -> [FieldType]
enumFromTo :: FieldType -> FieldType -> [FieldType]
$cenumFromTo :: FieldType -> FieldType -> [FieldType]
enumFromThen :: FieldType -> FieldType -> [FieldType]
$cenumFromThen :: FieldType -> FieldType -> [FieldType]
enumFrom :: FieldType -> [FieldType]
$cenumFrom :: FieldType -> [FieldType]
fromEnum :: FieldType -> Int
$cfromEnum :: FieldType -> Int
toEnum :: Int -> FieldType
$ctoEnum :: Int -> FieldType
pred :: FieldType -> FieldType
$cpred :: FieldType -> FieldType
succ :: FieldType -> FieldType
$csucc :: FieldType -> FieldType
Enum,ReadPrec [FieldType]
ReadPrec FieldType
Int -> ReadS FieldType
ReadS [FieldType]
(Int -> ReadS FieldType)
-> ReadS [FieldType]
-> ReadPrec FieldType
-> ReadPrec [FieldType]
-> Read FieldType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldType]
$creadListPrec :: ReadPrec [FieldType]
readPrec :: ReadPrec FieldType
$creadPrec :: ReadPrec FieldType
readList :: ReadS [FieldType]
$creadList :: ReadS [FieldType]
readsPrec :: Int -> ReadS FieldType
$creadsPrec :: Int -> ReadS FieldType
Read,Int -> FieldType -> ShowS
[FieldType] -> ShowS
FieldType -> String
(Int -> FieldType -> ShowS)
-> (FieldType -> String)
-> ([FieldType] -> ShowS)
-> Show FieldType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldType] -> ShowS
$cshowList :: [FieldType] -> ShowS
show :: FieldType -> String
$cshow :: FieldType -> String
showsPrec :: Int -> FieldType -> ShowS
$cshowsPrec :: Int -> FieldType -> ShowS
Show,Integer -> FieldType
FieldType -> FieldType
FieldType -> FieldType -> FieldType
(FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (FieldType -> FieldType)
-> (Integer -> FieldType)
-> Num FieldType
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> FieldType
$cfromInteger :: Integer -> FieldType
signum :: FieldType -> FieldType
$csignum :: FieldType -> FieldType
abs :: FieldType -> FieldType
$cabs :: FieldType -> FieldType
negate :: FieldType -> FieldType
$cnegate :: FieldType -> FieldType
* :: FieldType -> FieldType -> FieldType
$c* :: FieldType -> FieldType -> FieldType
- :: FieldType -> FieldType -> FieldType
$c- :: FieldType -> FieldType -> FieldType
+ :: FieldType -> FieldType -> FieldType
$c+ :: FieldType -> FieldType -> FieldType
Num,Typeable FieldType
DataType
Constr
Typeable FieldType
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType)
-> (FieldType -> Constr)
-> (FieldType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType))
-> ((forall b. Data b => b -> b) -> FieldType -> FieldType)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldType -> [u])
-> (forall u.
Int -> (forall d. Data d => d -> u) -> FieldType -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType)
-> Data FieldType
FieldType -> DataType
FieldType -> Constr
(forall b. Data b => b -> b) -> FieldType -> FieldType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FieldType -> u
forall u. (forall d. Data d => d -> u) -> FieldType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType)
$cFieldType :: Constr
$tFieldType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FieldType -> m FieldType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
gmapMp :: (forall d. Data d => d -> m d) -> FieldType -> m FieldType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
gmapM :: (forall d. Data d => d -> m d) -> FieldType -> m FieldType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldType -> m FieldType
gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldType -> u
gmapQ :: (forall d. Data d => d -> u) -> FieldType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldType -> r
gmapT :: (forall b. Data b => b -> b) -> FieldType -> FieldType
$cgmapT :: (forall b. Data b => b -> b) -> FieldType -> FieldType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FieldType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldType)
dataTypeOf :: FieldType -> DataType
$cdataTypeOf :: FieldType -> DataType
toConstr :: FieldType -> Constr
$ctoConstr :: FieldType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldType -> c FieldType
$cp1Data :: Typeable FieldType
Data,Typeable)
instance Bounded FieldType where
minBound :: FieldType
minBound = FieldType
1
maxBound :: FieldType
maxBound = FieldType
18
newtype EnumCode = EnumCode { EnumCode -> Int32
getEnumCode :: Int32 }
deriving (EnumCode -> EnumCode -> Bool
(EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool) -> Eq EnumCode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnumCode -> EnumCode -> Bool
$c/= :: EnumCode -> EnumCode -> Bool
== :: EnumCode -> EnumCode -> Bool
$c== :: EnumCode -> EnumCode -> Bool
Eq,Eq EnumCode
Eq EnumCode
-> (EnumCode -> EnumCode -> Ordering)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> Bool)
-> (EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode -> EnumCode)
-> Ord EnumCode
EnumCode -> EnumCode -> Bool
EnumCode -> EnumCode -> Ordering
EnumCode -> EnumCode -> EnumCode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: EnumCode -> EnumCode -> EnumCode
$cmin :: EnumCode -> EnumCode -> EnumCode
max :: EnumCode -> EnumCode -> EnumCode
$cmax :: EnumCode -> EnumCode -> EnumCode
>= :: EnumCode -> EnumCode -> Bool
$c>= :: EnumCode -> EnumCode -> Bool
> :: EnumCode -> EnumCode -> Bool
$c> :: EnumCode -> EnumCode -> Bool
<= :: EnumCode -> EnumCode -> Bool
$c<= :: EnumCode -> EnumCode -> Bool
< :: EnumCode -> EnumCode -> Bool
$c< :: EnumCode -> EnumCode -> Bool
compare :: EnumCode -> EnumCode -> Ordering
$ccompare :: EnumCode -> EnumCode -> Ordering
$cp1Ord :: Eq EnumCode
Ord,ReadPrec [EnumCode]
ReadPrec EnumCode
Int -> ReadS EnumCode
ReadS [EnumCode]
(Int -> ReadS EnumCode)
-> ReadS [EnumCode]
-> ReadPrec EnumCode
-> ReadPrec [EnumCode]
-> Read EnumCode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnumCode]
$creadListPrec :: ReadPrec [EnumCode]
readPrec :: ReadPrec EnumCode
$creadPrec :: ReadPrec EnumCode
readList :: ReadS [EnumCode]
$creadList :: ReadS [EnumCode]
readsPrec :: Int -> ReadS EnumCode
$creadsPrec :: Int -> ReadS EnumCode
Read,Int -> EnumCode -> ShowS
[EnumCode] -> ShowS
EnumCode -> String
(Int -> EnumCode -> ShowS)
-> (EnumCode -> String) -> ([EnumCode] -> ShowS) -> Show EnumCode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnumCode] -> ShowS
$cshowList :: [EnumCode] -> ShowS
show :: EnumCode -> String
$cshow :: EnumCode -> String
showsPrec :: Int -> EnumCode -> ShowS
$cshowsPrec :: Int -> EnumCode -> ShowS
Show,Integer -> EnumCode
EnumCode -> EnumCode
EnumCode -> EnumCode -> EnumCode
(EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode -> EnumCode)
-> (EnumCode -> EnumCode)
-> (EnumCode -> EnumCode)
-> (EnumCode -> EnumCode)
-> (Integer -> EnumCode)
-> Num EnumCode
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> EnumCode
$cfromInteger :: Integer -> EnumCode
signum :: EnumCode -> EnumCode
$csignum :: EnumCode -> EnumCode
abs :: EnumCode -> EnumCode
$cabs :: EnumCode -> EnumCode
negate :: EnumCode -> EnumCode
$cnegate :: EnumCode -> EnumCode
* :: EnumCode -> EnumCode -> EnumCode
$c* :: EnumCode -> EnumCode -> EnumCode
- :: EnumCode -> EnumCode -> EnumCode
$c- :: EnumCode -> EnumCode -> EnumCode
+ :: EnumCode -> EnumCode -> EnumCode
$c+ :: EnumCode -> EnumCode -> EnumCode
Num,Typeable EnumCode
DataType
Constr
Typeable EnumCode
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode)
-> (EnumCode -> Constr)
-> (EnumCode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumCode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode))
-> ((forall b. Data b => b -> b) -> EnumCode -> EnumCode)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r)
-> (forall u. (forall d. Data d => d -> u) -> EnumCode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> EnumCode -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode)
-> Data EnumCode
EnumCode -> DataType
EnumCode -> Constr
(forall b. Data b => b -> b) -> EnumCode -> EnumCode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
forall a.
Typeable a
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> EnumCode -> u
forall u. (forall d. Data d => d -> u) -> EnumCode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumCode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode)
$cEnumCode :: Constr
$tEnumCode :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
gmapMp :: (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
gmapM :: (forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumCode -> m EnumCode
gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumCode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumCode -> u
gmapQ :: (forall d. Data d => d -> u) -> EnumCode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnumCode -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumCode -> r
gmapT :: (forall b. Data b => b -> b) -> EnumCode -> EnumCode
$cgmapT :: (forall b. Data b => b -> b) -> EnumCode -> EnumCode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumCode)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EnumCode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumCode)
dataTypeOf :: EnumCode -> DataType
$cdataTypeOf :: EnumCode -> DataType
toConstr :: EnumCode -> Constr
$ctoConstr :: EnumCode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumCode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumCode -> c EnumCode
$cp1Data :: Typeable EnumCode
Data,Typeable)
instance Bounded EnumCode where
minBound :: EnumCode
minBound = EnumCode
0
maxBound :: EnumCode
maxBound = EnumCode
2147483647
type WireSize = Int64
class Default a => Mergeable a where
mergeAppend :: a -> a -> a
mergeAppend a
_a a
b = a
b
mergeConcat :: F.Foldable t => t a -> a
mergeConcat = (a -> a -> a) -> a -> t a -> a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
F.foldl a -> a -> a
forall a. Mergeable a => a -> a -> a
mergeAppend a
forall a. Default a => a
defaultValue
class Default a where
defaultValue :: a
isValidUTF8 :: ByteString -> Maybe Int
isValidUTF8 :: ByteString -> Maybe Int
isValidUTF8 ByteString
bs = Int -> [Word8] -> Int -> Maybe Int
go Int
0 (ByteString -> [Word8]
L.unpack ByteString
bs) Int
0 where
go :: Int -> [Word8] -> Int -> Maybe Int
go :: Int -> [Word8] -> Int -> Maybe Int
go Int
0 [] Int
_ = Maybe Int
forall a. Maybe a
Nothing
go Int
0 (Word8
x:[Word8]
xs) Int
n | Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
127 = Int -> [Word8] -> Int -> Maybe Int
go Int
0 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
| Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
193 = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
| Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
223 = Int -> [Word8] -> Int -> Maybe Int
go Int
1 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
| Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
239 = Int -> [Word8] -> Int -> Maybe Int
go Int
2 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
| Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
243 = Int -> [Word8] -> Int -> Maybe Int
go Int
3 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
| Word8
x Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
244 = [Word8] -> Int -> Maybe Int
high [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
| Bool
otherwise = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
go Int
i (Word8
x:[Word8]
xs) Int
n | Word8
128 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
x Bool -> Bool -> Bool
&& Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
191 = Int -> [Word8] -> Int -> Maybe Int
go (Int -> Int
forall a. Enum a => a -> a
pred Int
i) [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
go Int
_ [Word8]
_ Int
n = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
high :: [Word8] -> Int -> Maybe Int
high (Word8
x:[Word8]
xs) Int
n | Word8
128 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
x Bool -> Bool -> Bool
&& Word8
x Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
143 = Int -> [Word8] -> Int -> Maybe Int
go Int
2 [Word8]
xs (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$! Int -> Int
forall a. Enum a => a -> a
succ Int
n
| Bool
otherwise = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
high [] Int
n = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
n
toUtf8 :: ByteString -> Either Int Utf8
toUtf8 :: ByteString -> Either Int Utf8
toUtf8 ByteString
bs = Either Int Utf8
-> (Int -> Either Int Utf8) -> Maybe Int -> Either Int Utf8
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Utf8 -> Either Int Utf8
forall a b. b -> Either a b
Right (ByteString -> Utf8
Utf8 ByteString
bs)) Int -> Either Int Utf8
forall a b. a -> Either a b
Left (ByteString -> Maybe Int
isValidUTF8 ByteString
bs)
uToString :: Utf8 -> String
uToString :: Utf8 -> String
uToString (Utf8 ByteString
bs) = ByteString -> String
U.toString ByteString
bs
uFromString :: String -> Utf8
uFromString :: String -> Utf8
uFromString String
s = ByteString -> Utf8
Utf8 (String -> ByteString
U.fromString String
s)
instance Mergeable a => Mergeable (Maybe a) where
mergeAppend :: Maybe a -> Maybe a -> Maybe a
mergeAppend = Maybe a -> Maybe a -> Maybe a
forall a. Mergeable a => Maybe a -> Maybe a -> Maybe a
mayMerge
{-# INLINE mayMerge #-}
mayMerge :: (Mergeable b) => Maybe b -> Maybe b -> Maybe b
mayMerge :: Maybe b -> Maybe b -> Maybe b
mayMerge Maybe b
Nothing Maybe b
y = Maybe b
y
mayMerge Maybe b
x Maybe b
Nothing = Maybe b
x
mayMerge (Just b
x) (Just b
y) = b -> Maybe b
forall a. a -> Maybe a
Just (b -> b -> b
forall a. Mergeable a => a -> a -> a
mergeAppend b
x b
y)
instance Mergeable (Seq a) where
mergeAppend :: Seq a -> Seq a -> Seq a
mergeAppend = Seq a -> Seq a -> Seq a
forall a. Seq a -> Seq a -> Seq a
(><)
instance Mergeable Bool
instance Mergeable Utf8
instance Mergeable ByteString
instance Mergeable Double
instance Mergeable Float
instance Mergeable Int32
instance Mergeable Int64
instance Mergeable Word32
instance Mergeable Word64
instance Default Word64 where defaultValue :: Word64
defaultValue = Word64
0
instance Default Word32 where defaultValue :: Word32
defaultValue = Word32
0
instance Default Int64 where defaultValue :: Int64
defaultValue = Int64
0
instance Default Int32 where defaultValue :: Int32
defaultValue = Int32
0
instance Default Float where defaultValue :: Float
defaultValue = Float
0
instance Default Double where defaultValue :: Double
defaultValue = Double
0
instance Default Bool where defaultValue :: Bool
defaultValue = Bool
False
instance Default (Maybe a) where defaultValue :: Maybe a
defaultValue = Maybe a
forall a. Maybe a
Nothing
instance Default (Seq a) where defaultValue :: Seq a
defaultValue = Seq a
forall a. Monoid a => a
mempty
instance Default ByteString where defaultValue :: ByteString
defaultValue = ByteString
forall a. Monoid a => a
mempty
instance Default Utf8 where defaultValue :: Utf8
defaultValue = Utf8
forall a. Monoid a => a
mempty