    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveFoldable #-}
    {-# LANGUAGE DeriveFunctor #-}
    {-# LANGUAGE DeriveTraversable #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE TypeFamilies #-}

    module Data.ProtocolBuffers.Types
      ( Field(..)
      , HasField(..)
      , Required
      , RequiredField(..)
      , Optional
      , OptionalField(..)
      , Repeated
      , RepeatedField(..)
      , Packed
      , Value(..)
      , Enumeration(..)
      , Fixed(..)
      , Signed(..)
      , Always(..)
      , PackedList(..)
      , PackedField(..)
      ) where

    import Control.DeepSeq (NFData)
    import Data.Bits
    import Data.Foldable as Fold
    import Data.Monoid hiding ((<>))
    import Data.Semigroup (Semigroup(..))
    import Data.Traversable
    import Data.Typeable

    import GHC.TypeLits

    -- |
    -- 'Value' selects the normal/typical way for encoding scalar (primitive) values.
    newtype Value a       = Value       {forall a. Value a -> a
    runValue       :: a}
      deriving (Value a
    Value a -> Value a -> Bounded (Value a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Value a
    $cminBound :: forall a. Bounded a => Value a
    minBound :: Value a
    $cmaxBound :: forall a. Bounded a => Value a
    maxBound :: Value a
    Bounded, Value a -> Value a -> Bool
    (Value a -> Value a -> Bool)
    -> (Value a -> Value a -> Bool) -> Eq (Value a)
    forall a. Eq a => Value a -> Value a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Value a -> Value a -> Bool
    == :: Value a -> Value a -> Bool
    $c/= :: forall a. Eq a => Value a -> Value a -> Bool
    /= :: Value a -> Value a -> Bool
    Eq, Int -> Value a
    Value a -> Int
    Value a -> [Value a]
    Value a -> Value a
    Value a -> Value a -> [Value a]
    Value a -> Value a -> Value a -> [Value a]
    (Value a -> Value a)
    -> (Value a -> Value a)
    -> (Int -> Value a)
    -> (Value a -> Int)
    -> (Value a -> [Value a])
    -> (Value a -> Value a -> [Value a])
    -> (Value a -> Value a -> [Value a])
    -> (Value a -> Value a -> Value a -> [Value a])
    -> Enum (Value a)
    forall a. Enum a => Int -> Value a
    forall a. Enum a => Value a -> Int
    forall a. Enum a => Value a -> [Value a]
    forall a. Enum a => Value a -> Value a
    forall a. Enum a => Value a -> Value a -> [Value a]
    forall a. Enum a => Value a -> Value a -> Value a -> [Value a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => Value a -> Value a
    succ :: Value a -> Value a
    $cpred :: forall a. Enum a => Value a -> Value a
    pred :: Value a -> Value a
    $ctoEnum :: forall a. Enum a => Int -> Value a
    toEnum :: Int -> Value a
    $cfromEnum :: forall a. Enum a => Value a -> Int
    fromEnum :: Value a -> Int
    $cenumFrom :: forall a. Enum a => Value a -> [Value a]
    enumFrom :: Value a -> [Value a]
    $cenumFromThen :: forall a. Enum a => Value a -> Value a -> [Value a]
    enumFromThen :: Value a -> Value a -> [Value a]
    $cenumFromTo :: forall a. Enum a => Value a -> Value a -> [Value a]
    enumFromTo :: Value a -> Value a -> [Value a]
    $cenumFromThenTo :: forall a. Enum a => Value a -> Value a -> Value a -> [Value a]
    enumFromThenTo :: Value a -> Value a -> Value a -> [Value a]
    Enum, (forall m. Monoid m => Value m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Value a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Value a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Value a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Value a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Value a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Value a -> b)
    -> (forall a. (a -> a -> a) -> Value a -> a)
    -> (forall a. (a -> a -> a) -> Value a -> a)
    -> (forall a. Value a -> [a])
    -> (forall a. Value a -> Bool)
    -> (forall a. Value a -> Int)
    -> (forall a. Eq a => a -> Value a -> Bool)
    -> (forall a. Ord a => Value a -> a)
    -> (forall a. Ord a => Value a -> a)
    -> (forall a. Num a => Value a -> a)
    -> (forall a. Num a => Value a -> a)
    -> Foldable Value
    forall a. Eq a => a -> Value a -> Bool
    forall a. Num a => Value a -> a
    forall a. Ord a => Value a -> a
    forall m. Monoid m => Value m -> m
    forall a. Value a -> Bool
    forall a. Value a -> Int
    forall a. Value a -> [a]
    forall a. (a -> a -> a) -> Value a -> a
    forall m a. Monoid m => (a -> m) -> Value a -> m
    forall b a. (b -> a -> b) -> b -> Value a -> b
    forall a b. (a -> b -> b) -> b -> Value a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Value m -> m
    fold :: forall m. Monoid m => Value m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Value a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Value a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Value a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Value a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Value a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Value a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Value a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Value a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Value a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Value a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Value a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Value a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Value a -> a
    foldr1 :: forall a. (a -> a -> a) -> Value a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Value a -> a
    foldl1 :: forall a. (a -> a -> a) -> Value a -> a
    $ctoList :: forall a. Value a -> [a]
    toList :: forall a. Value a -> [a]
    $cnull :: forall a. Value a -> Bool
    null :: forall a. Value a -> Bool
    $clength :: forall a. Value a -> Int
    length :: forall a. Value a -> Int
    $celem :: forall a. Eq a => a -> Value a -> Bool
    elem :: forall a. Eq a => a -> Value a -> Bool
    $cmaximum :: forall a. Ord a => Value a -> a
    maximum :: forall a. Ord a => Value a -> a
    $cminimum :: forall a. Ord a => Value a -> a
    minimum :: forall a. Ord a => Value a -> a
    $csum :: forall a. Num a => Value a -> a
    sum :: forall a. Num a => Value a -> a
    $cproduct :: forall a. Num a => Value a -> a
    product :: forall a. Num a => Value a -> a
    Foldable, (forall a b. (a -> b) -> Value a -> Value b)
    -> (forall a b. a -> Value b -> Value a) -> Functor Value
    forall a b. a -> Value b -> Value a
    forall a b. (a -> b) -> Value a -> Value b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Value a -> Value b
    fmap :: forall a b. (a -> b) -> Value a -> Value b
    $c<$ :: forall a b. a -> Value b -> Value a
    <$ :: forall a b. a -> Value b -> Value a
    Functor, NonEmpty (Value a) -> Value a
    Value a -> Value a -> Value a
    (Value a -> Value a -> Value a)
    -> (NonEmpty (Value a) -> Value a)
    -> (forall b. Integral b => b -> Value a -> Value a)
    -> Semigroup (Value a)
    forall b. Integral b => b -> Value a -> Value a
    forall a. Semigroup a => NonEmpty (Value a) -> Value a
    forall a. Semigroup a => Value a -> Value a -> Value a
    forall a b. (Semigroup a, Integral b) => b -> Value a -> Value a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a. Semigroup a => Value a -> Value a -> Value a
    <> :: Value a -> Value a -> Value a
    $csconcat :: forall a. Semigroup a => NonEmpty (Value a) -> Value a
    sconcat :: NonEmpty (Value a) -> Value a
    $cstimes :: forall a b. (Semigroup a, Integral b) => b -> Value a -> Value a
    stimes :: forall b. Integral b => b -> Value a -> Value a
    Semigroup, Semigroup (Value a)
    Value a
    Semigroup (Value a) =>
    Value a
    -> (Value a -> Value a -> Value a)
    -> ([Value a] -> Value a)
    -> Monoid (Value a)
    [Value a] -> Value a
    Value a -> Value a -> Value a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (Value a)
    forall a. Monoid a => Value a
    forall a. Monoid a => [Value a] -> Value a
    forall a. Monoid a => Value a -> Value a -> Value a
    $cmempty :: forall a. Monoid a => Value a
    mempty :: Value a
    $cmappend :: forall a. Monoid a => Value a -> Value a -> Value a
    mappend :: Value a -> Value a -> Value a
    $cmconcat :: forall a. Monoid a => [Value a] -> Value a
    mconcat :: [Value a] -> Value a
    Monoid, Eq (Value a)
    Eq (Value a) =>
    (Value a -> Value a -> Ordering)
    -> (Value a -> Value a -> Bool)
    -> (Value a -> Value a -> Bool)
    -> (Value a -> Value a -> Bool)
    -> (Value a -> Value a -> Bool)
    -> (Value a -> Value a -> Value a)
    -> (Value a -> Value a -> Value a)
    -> Ord (Value a)
    Value a -> Value a -> Bool
    Value a -> Value a -> Ordering
    Value a -> Value a -> Value a
    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
    forall a. Ord a => Eq (Value a)
    forall a. Ord a => Value a -> Value a -> Bool
    forall a. Ord a => Value a -> Value a -> Ordering
    forall a. Ord a => Value a -> Value a -> Value a
    $ccompare :: forall a. Ord a => Value a -> Value a -> Ordering
    compare :: Value a -> Value a -> Ordering
    $c< :: forall a. Ord a => Value a -> Value a -> Bool
    < :: Value a -> Value a -> Bool
    $c<= :: forall a. Ord a => Value a -> Value a -> Bool
    <= :: Value a -> Value a -> Bool
    $c> :: forall a. Ord a => Value a -> Value a -> Bool
    > :: Value a -> Value a -> Bool
    $c>= :: forall a. Ord a => Value a -> Value a -> Bool
    >= :: Value a -> Value a -> Bool
    $cmax :: forall a. Ord a => Value a -> Value a -> Value a
    max :: Value a -> Value a -> Value a
    $cmin :: forall a. Ord a => Value a -> Value a -> Value a
    min :: Value a -> Value a -> Value a
    Ord, Value a -> ()
    (Value a -> ()) -> NFData (Value a)
    forall a. NFData a => Value a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => Value a -> ()
    rnf :: Value a -> ()
    NFData, Int -> Value a -> ShowS
    [Value a] -> ShowS
    Value a -> String
    (Int -> Value a -> ShowS)
    -> (Value a -> String) -> ([Value a] -> ShowS) -> Show (Value a)
    forall a. Show a => Int -> Value a -> ShowS
    forall a. Show a => [Value a] -> ShowS
    forall a. Show a => Value a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Value a -> ShowS
    showsPrec :: Int -> Value a -> ShowS
    $cshow :: forall a. Show a => Value a -> String
    show :: Value a -> String
    $cshowList :: forall a. Show a => [Value a] -> ShowS
    showList :: [Value a] -> ShowS
    Show, Functor Value
    Foldable Value
    (Functor Value, Foldable Value) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Value a -> f (Value b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Value (f a) -> f (Value a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Value a -> m (Value b))
    -> (forall (m :: * -> *) a. Monad m => Value (m a) -> m (Value a))
    -> Traversable Value
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Value (m a) -> m (Value a)
    forall (f :: * -> *) a. Applicative f => Value (f a) -> f (Value a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Value a -> m (Value b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Value a -> f (Value b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Value a -> f (Value b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Value a -> f (Value b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Value (f a) -> f (Value a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Value (f a) -> f (Value a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Value a -> m (Value b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Value a -> m (Value b)
    $csequence :: forall (m :: * -> *) a. Monad m => Value (m a) -> m (Value a)
    sequence :: forall (m :: * -> *) a. Monad m => Value (m a) -> m (Value a)
    Traversable, Typeable)

    -- |
    -- 'RequiredField' is a newtype wrapped used to break overlapping instances
    -- for encoding and decoding values
    newtype RequiredField a    = Required    {forall a. RequiredField a -> a
    runRequired    :: a}
      deriving (RequiredField a
    RequiredField a -> RequiredField a -> Bounded (RequiredField a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => RequiredField a
    $cminBound :: forall a. Bounded a => RequiredField a
    minBound :: RequiredField a
    $cmaxBound :: forall a. Bounded a => RequiredField a
    maxBound :: RequiredField a
    Bounded, RequiredField a -> RequiredField a -> Bool
    (RequiredField a -> RequiredField a -> Bool)
    -> (RequiredField a -> RequiredField a -> Bool)
    -> Eq (RequiredField a)
    forall a. Eq a => RequiredField a -> RequiredField a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => RequiredField a -> RequiredField a -> Bool
    == :: RequiredField a -> RequiredField a -> Bool
    $c/= :: forall a. Eq a => RequiredField a -> RequiredField a -> Bool
    /= :: RequiredField a -> RequiredField a -> Bool
    Eq, Int -> RequiredField a
    RequiredField a -> Int
    RequiredField a -> [RequiredField a]
    RequiredField a -> RequiredField a
    RequiredField a -> RequiredField a -> [RequiredField a]
    RequiredField a
    -> RequiredField a -> RequiredField a -> [RequiredField a]
    (RequiredField a -> RequiredField a)
    -> (RequiredField a -> RequiredField a)
    -> (Int -> RequiredField a)
    -> (RequiredField a -> Int)
    -> (RequiredField a -> [RequiredField a])
    -> (RequiredField a -> RequiredField a -> [RequiredField a])
    -> (RequiredField a -> RequiredField a -> [RequiredField a])
    -> (RequiredField a
        -> RequiredField a -> RequiredField a -> [RequiredField a])
    -> Enum (RequiredField a)
    forall a. Enum a => Int -> RequiredField a
    forall a. Enum a => RequiredField a -> Int
    forall a. Enum a => RequiredField a -> [RequiredField a]
    forall a. Enum a => RequiredField a -> RequiredField a
    forall a.
    Enum a =>
    RequiredField a -> RequiredField a -> [RequiredField a]
    forall a.
    Enum a =>
    RequiredField a
    -> RequiredField a -> RequiredField a -> [RequiredField a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => RequiredField a -> RequiredField a
    succ :: RequiredField a -> RequiredField a
    $cpred :: forall a. Enum a => RequiredField a -> RequiredField a
    pred :: RequiredField a -> RequiredField a
    $ctoEnum :: forall a. Enum a => Int -> RequiredField a
    toEnum :: Int -> RequiredField a
    $cfromEnum :: forall a. Enum a => RequiredField a -> Int
    fromEnum :: RequiredField a -> Int
    $cenumFrom :: forall a. Enum a => RequiredField a -> [RequiredField a]
    enumFrom :: RequiredField a -> [RequiredField a]
    $cenumFromThen :: forall a.
    Enum a =>
    RequiredField a -> RequiredField a -> [RequiredField a]
    enumFromThen :: RequiredField a -> RequiredField a -> [RequiredField a]
    $cenumFromTo :: forall a.
    Enum a =>
    RequiredField a -> RequiredField a -> [RequiredField a]
    enumFromTo :: RequiredField a -> RequiredField a -> [RequiredField a]
    $cenumFromThenTo :: forall a.
    Enum a =>
    RequiredField a
    -> RequiredField a -> RequiredField a -> [RequiredField a]
    enumFromThenTo :: RequiredField a
    -> RequiredField a -> RequiredField a -> [RequiredField a]
    Enum, (forall m. Monoid m => RequiredField m -> m)
    -> (forall m a. Monoid m => (a -> m) -> RequiredField a -> m)
    -> (forall m a. Monoid m => (a -> m) -> RequiredField a -> m)
    -> (forall a b. (a -> b -> b) -> b -> RequiredField a -> b)
    -> (forall a b. (a -> b -> b) -> b -> RequiredField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RequiredField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RequiredField a -> b)
    -> (forall a. (a -> a -> a) -> RequiredField a -> a)
    -> (forall a. (a -> a -> a) -> RequiredField a -> a)
    -> (forall a. RequiredField a -> [a])
    -> (forall a. RequiredField a -> Bool)
    -> (forall a. RequiredField a -> Int)
    -> (forall a. Eq a => a -> RequiredField a -> Bool)
    -> (forall a. Ord a => RequiredField a -> a)
    -> (forall a. Ord a => RequiredField a -> a)
    -> (forall a. Num a => RequiredField a -> a)
    -> (forall a. Num a => RequiredField a -> a)
    -> Foldable RequiredField
    forall a. Eq a => a -> RequiredField a -> Bool
    forall a. Num a => RequiredField a -> a
    forall a. Ord a => RequiredField a -> a
    forall m. Monoid m => RequiredField m -> m
    forall a. RequiredField a -> Bool
    forall a. RequiredField a -> Int
    forall a. RequiredField a -> [a]
    forall a. (a -> a -> a) -> RequiredField a -> a
    forall m a. Monoid m => (a -> m) -> RequiredField a -> m
    forall b a. (b -> a -> b) -> b -> RequiredField a -> b
    forall a b. (a -> b -> b) -> b -> RequiredField a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => RequiredField m -> m
    fold :: forall m. Monoid m => RequiredField m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> RequiredField a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> RequiredField a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> RequiredField a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> RequiredField a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> RequiredField a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> RequiredField a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> RequiredField a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> RequiredField a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> RequiredField a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> RequiredField a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> RequiredField a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> RequiredField a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> RequiredField a -> a
    foldr1 :: forall a. (a -> a -> a) -> RequiredField a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> RequiredField a -> a
    foldl1 :: forall a. (a -> a -> a) -> RequiredField a -> a
    $ctoList :: forall a. RequiredField a -> [a]
    toList :: forall a. RequiredField a -> [a]
    $cnull :: forall a. RequiredField a -> Bool
    null :: forall a. RequiredField a -> Bool
    $clength :: forall a. RequiredField a -> Int
    length :: forall a. RequiredField a -> Int
    $celem :: forall a. Eq a => a -> RequiredField a -> Bool
    elem :: forall a. Eq a => a -> RequiredField a -> Bool
    $cmaximum :: forall a. Ord a => RequiredField a -> a
    maximum :: forall a. Ord a => RequiredField a -> a
    $cminimum :: forall a. Ord a => RequiredField a -> a
    minimum :: forall a. Ord a => RequiredField a -> a
    $csum :: forall a. Num a => RequiredField a -> a
    sum :: forall a. Num a => RequiredField a -> a
    $cproduct :: forall a. Num a => RequiredField a -> a
    product :: forall a. Num a => RequiredField a -> a
    Foldable, (forall a b. (a -> b) -> RequiredField a -> RequiredField b)
    -> (forall a b. a -> RequiredField b -> RequiredField a)
    -> Functor RequiredField
    forall a b. a -> RequiredField b -> RequiredField a
    forall a b. (a -> b) -> RequiredField a -> RequiredField b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> RequiredField a -> RequiredField b
    fmap :: forall a b. (a -> b) -> RequiredField a -> RequiredField b
    $c<$ :: forall a b. a -> RequiredField b -> RequiredField a
    <$ :: forall a b. a -> RequiredField b -> RequiredField a
    Functor, NonEmpty (RequiredField a) -> RequiredField a
    RequiredField a -> RequiredField a -> RequiredField a
    (RequiredField a -> RequiredField a -> RequiredField a)
    -> (NonEmpty (RequiredField a) -> RequiredField a)
    -> (forall b.
        Integral b =>
        b -> RequiredField a -> RequiredField a)
    -> Semigroup (RequiredField a)
    forall b. Integral b => b -> RequiredField a -> RequiredField a
    forall a.
    Semigroup a =>
    NonEmpty (RequiredField a) -> RequiredField a
    forall a.
    Semigroup a =>
    RequiredField a -> RequiredField a -> RequiredField a
    forall a b.
    (Semigroup a, Integral b) =>
    b -> RequiredField a -> RequiredField a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a.
    Semigroup a =>
    RequiredField a -> RequiredField a -> RequiredField a
    <> :: RequiredField a -> RequiredField a -> RequiredField a
    $csconcat :: forall a.
    Semigroup a =>
    NonEmpty (RequiredField a) -> RequiredField a
    sconcat :: NonEmpty (RequiredField a) -> RequiredField a
    $cstimes :: forall a b.
    (Semigroup a, Integral b) =>
    b -> RequiredField a -> RequiredField a
    stimes :: forall b. Integral b => b -> RequiredField a -> RequiredField a
    Semigroup, Semigroup (RequiredField a)
    RequiredField a
    Semigroup (RequiredField a) =>
    RequiredField a
    -> (RequiredField a -> RequiredField a -> RequiredField a)
    -> ([RequiredField a] -> RequiredField a)
    -> Monoid (RequiredField a)
    [RequiredField a] -> RequiredField a
    RequiredField a -> RequiredField a -> RequiredField a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (RequiredField a)
    forall a. Monoid a => RequiredField a
    forall a. Monoid a => [RequiredField a] -> RequiredField a
    forall a.
    Monoid a =>
    RequiredField a -> RequiredField a -> RequiredField a
    $cmempty :: forall a. Monoid a => RequiredField a
    mempty :: RequiredField a
    $cmappend :: forall a.
    Monoid a =>
    RequiredField a -> RequiredField a -> RequiredField a
    mappend :: RequiredField a -> RequiredField a -> RequiredField a
    $cmconcat :: forall a. Monoid a => [RequiredField a] -> RequiredField a
    mconcat :: [RequiredField a] -> RequiredField a
    Monoid, Eq (RequiredField a)
    Eq (RequiredField a) =>
    (RequiredField a -> RequiredField a -> Ordering)
    -> (RequiredField a -> RequiredField a -> Bool)
    -> (RequiredField a -> RequiredField a -> Bool)
    -> (RequiredField a -> RequiredField a -> Bool)
    -> (RequiredField a -> RequiredField a -> Bool)
    -> (RequiredField a -> RequiredField a -> RequiredField a)
    -> (RequiredField a -> RequiredField a -> RequiredField a)
    -> Ord (RequiredField a)
    RequiredField a -> RequiredField a -> Bool
    RequiredField a -> RequiredField a -> Ordering
    RequiredField a -> RequiredField a -> RequiredField a
    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
    forall a. Ord a => Eq (RequiredField a)
    forall a. Ord a => RequiredField a -> RequiredField a -> Bool
    forall a. Ord a => RequiredField a -> RequiredField a -> Ordering
    forall a.
    Ord a =>
    RequiredField a -> RequiredField a -> RequiredField a
    $ccompare :: forall a. Ord a => RequiredField a -> RequiredField a -> Ordering
    compare :: RequiredField a -> RequiredField a -> Ordering
    $c< :: forall a. Ord a => RequiredField a -> RequiredField a -> Bool
    < :: RequiredField a -> RequiredField a -> Bool
    $c<= :: forall a. Ord a => RequiredField a -> RequiredField a -> Bool
    <= :: RequiredField a -> RequiredField a -> Bool
    $c> :: forall a. Ord a => RequiredField a -> RequiredField a -> Bool
    > :: RequiredField a -> RequiredField a -> Bool
    $c>= :: forall a. Ord a => RequiredField a -> RequiredField a -> Bool
    >= :: RequiredField a -> RequiredField a -> Bool
    $cmax :: forall a.
    Ord a =>
    RequiredField a -> RequiredField a -> RequiredField a
    max :: RequiredField a -> RequiredField a -> RequiredField a
    $cmin :: forall a.
    Ord a =>
    RequiredField a -> RequiredField a -> RequiredField a
    min :: RequiredField a -> RequiredField a -> RequiredField a
    Ord, RequiredField a -> ()
    (RequiredField a -> ()) -> NFData (RequiredField a)
    forall a. NFData a => RequiredField a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => RequiredField a -> ()
    rnf :: RequiredField a -> ()
    NFData, Int -> RequiredField a -> ShowS
    [RequiredField a] -> ShowS
    RequiredField a -> String
    (Int -> RequiredField a -> ShowS)
    -> (RequiredField a -> String)
    -> ([RequiredField a] -> ShowS)
    -> Show (RequiredField a)
    forall a. Show a => Int -> RequiredField a -> ShowS
    forall a. Show a => [RequiredField a] -> ShowS
    forall a. Show a => RequiredField a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> RequiredField a -> ShowS
    showsPrec :: Int -> RequiredField a -> ShowS
    $cshow :: forall a. Show a => RequiredField a -> String
    show :: RequiredField a -> String
    $cshowList :: forall a. Show a => [RequiredField a] -> ShowS
    showList :: [RequiredField a] -> ShowS
    Show, Functor RequiredField
    Foldable RequiredField
    (Functor RequiredField, Foldable RequiredField) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> RequiredField a -> f (RequiredField b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        RequiredField (f a) -> f (RequiredField a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> RequiredField a -> m (RequiredField b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        RequiredField (m a) -> m (RequiredField a))
    -> Traversable RequiredField
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    RequiredField (m a) -> m (RequiredField a)
    forall (f :: * -> *) a.
    Applicative f =>
    RequiredField (f a) -> f (RequiredField a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RequiredField a -> m (RequiredField b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RequiredField a -> f (RequiredField b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RequiredField a -> f (RequiredField b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RequiredField a -> f (RequiredField b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RequiredField (f a) -> f (RequiredField a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RequiredField (f a) -> f (RequiredField a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RequiredField a -> m (RequiredField b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RequiredField a -> m (RequiredField b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    RequiredField (m a) -> m (RequiredField a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    RequiredField (m a) -> m (RequiredField a)
    Traversable, Typeable)

    -- |
    -- 'OptionalField' is a newtype wrapped used to break overlapping instances
    -- for encoding and decoding values
    newtype OptionalField a    = Optional    {forall a. OptionalField a -> a
    runOptional    :: a}
      deriving (OptionalField a
    OptionalField a -> OptionalField a -> Bounded (OptionalField a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => OptionalField a
    $cminBound :: forall a. Bounded a => OptionalField a
    minBound :: OptionalField a
    $cmaxBound :: forall a. Bounded a => OptionalField a
    maxBound :: OptionalField a
    Bounded, OptionalField a -> OptionalField a -> Bool
    (OptionalField a -> OptionalField a -> Bool)
    -> (OptionalField a -> OptionalField a -> Bool)
    -> Eq (OptionalField a)
    forall a. Eq a => OptionalField a -> OptionalField a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => OptionalField a -> OptionalField a -> Bool
    == :: OptionalField a -> OptionalField a -> Bool
    $c/= :: forall a. Eq a => OptionalField a -> OptionalField a -> Bool
    /= :: OptionalField a -> OptionalField a -> Bool
    Eq, Int -> OptionalField a
    OptionalField a -> Int
    OptionalField a -> [OptionalField a]
    OptionalField a -> OptionalField a
    OptionalField a -> OptionalField a -> [OptionalField a]
    OptionalField a
    -> OptionalField a -> OptionalField a -> [OptionalField a]
    (OptionalField a -> OptionalField a)
    -> (OptionalField a -> OptionalField a)
    -> (Int -> OptionalField a)
    -> (OptionalField a -> Int)
    -> (OptionalField a -> [OptionalField a])
    -> (OptionalField a -> OptionalField a -> [OptionalField a])
    -> (OptionalField a -> OptionalField a -> [OptionalField a])
    -> (OptionalField a
        -> OptionalField a -> OptionalField a -> [OptionalField a])
    -> Enum (OptionalField a)
    forall a. Enum a => Int -> OptionalField a
    forall a. Enum a => OptionalField a -> Int
    forall a. Enum a => OptionalField a -> [OptionalField a]
    forall a. Enum a => OptionalField a -> OptionalField a
    forall a.
    Enum a =>
    OptionalField a -> OptionalField a -> [OptionalField a]
    forall a.
    Enum a =>
    OptionalField a
    -> OptionalField a -> OptionalField a -> [OptionalField a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => OptionalField a -> OptionalField a
    succ :: OptionalField a -> OptionalField a
    $cpred :: forall a. Enum a => OptionalField a -> OptionalField a
    pred :: OptionalField a -> OptionalField a
    $ctoEnum :: forall a. Enum a => Int -> OptionalField a
    toEnum :: Int -> OptionalField a
    $cfromEnum :: forall a. Enum a => OptionalField a -> Int
    fromEnum :: OptionalField a -> Int
    $cenumFrom :: forall a. Enum a => OptionalField a -> [OptionalField a]
    enumFrom :: OptionalField a -> [OptionalField a]
    $cenumFromThen :: forall a.
    Enum a =>
    OptionalField a -> OptionalField a -> [OptionalField a]
    enumFromThen :: OptionalField a -> OptionalField a -> [OptionalField a]
    $cenumFromTo :: forall a.
    Enum a =>
    OptionalField a -> OptionalField a -> [OptionalField a]
    enumFromTo :: OptionalField a -> OptionalField a -> [OptionalField a]
    $cenumFromThenTo :: forall a.
    Enum a =>
    OptionalField a
    -> OptionalField a -> OptionalField a -> [OptionalField a]
    enumFromThenTo :: OptionalField a
    -> OptionalField a -> OptionalField a -> [OptionalField a]
    Enum, (forall m. Monoid m => OptionalField m -> m)
    -> (forall m a. Monoid m => (a -> m) -> OptionalField a -> m)
    -> (forall m a. Monoid m => (a -> m) -> OptionalField a -> m)
    -> (forall a b. (a -> b -> b) -> b -> OptionalField a -> b)
    -> (forall a b. (a -> b -> b) -> b -> OptionalField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> OptionalField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> OptionalField a -> b)
    -> (forall a. (a -> a -> a) -> OptionalField a -> a)
    -> (forall a. (a -> a -> a) -> OptionalField a -> a)
    -> (forall a. OptionalField a -> [a])
    -> (forall a. OptionalField a -> Bool)
    -> (forall a. OptionalField a -> Int)
    -> (forall a. Eq a => a -> OptionalField a -> Bool)
    -> (forall a. Ord a => OptionalField a -> a)
    -> (forall a. Ord a => OptionalField a -> a)
    -> (forall a. Num a => OptionalField a -> a)
    -> (forall a. Num a => OptionalField a -> a)
    -> Foldable OptionalField
    forall a. Eq a => a -> OptionalField a -> Bool
    forall a. Num a => OptionalField a -> a
    forall a. Ord a => OptionalField a -> a
    forall m. Monoid m => OptionalField m -> m
    forall a. OptionalField a -> Bool
    forall a. OptionalField a -> Int
    forall a. OptionalField a -> [a]
    forall a. (a -> a -> a) -> OptionalField a -> a
    forall m a. Monoid m => (a -> m) -> OptionalField a -> m
    forall b a. (b -> a -> b) -> b -> OptionalField a -> b
    forall a b. (a -> b -> b) -> b -> OptionalField a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => OptionalField m -> m
    fold :: forall m. Monoid m => OptionalField m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> OptionalField a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> OptionalField a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> OptionalField a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> OptionalField a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> OptionalField a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> OptionalField a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> OptionalField a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> OptionalField a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> OptionalField a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> OptionalField a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> OptionalField a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> OptionalField a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> OptionalField a -> a
    foldr1 :: forall a. (a -> a -> a) -> OptionalField a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> OptionalField a -> a
    foldl1 :: forall a. (a -> a -> a) -> OptionalField a -> a
    $ctoList :: forall a. OptionalField a -> [a]
    toList :: forall a. OptionalField a -> [a]
    $cnull :: forall a. OptionalField a -> Bool
    null :: forall a. OptionalField a -> Bool
    $clength :: forall a. OptionalField a -> Int
    length :: forall a. OptionalField a -> Int
    $celem :: forall a. Eq a => a -> OptionalField a -> Bool
    elem :: forall a. Eq a => a -> OptionalField a -> Bool
    $cmaximum :: forall a. Ord a => OptionalField a -> a
    maximum :: forall a. Ord a => OptionalField a -> a
    $cminimum :: forall a. Ord a => OptionalField a -> a
    minimum :: forall a. Ord a => OptionalField a -> a
    $csum :: forall a. Num a => OptionalField a -> a
    sum :: forall a. Num a => OptionalField a -> a
    $cproduct :: forall a. Num a => OptionalField a -> a
    product :: forall a. Num a => OptionalField a -> a
    Foldable, (forall a b. (a -> b) -> OptionalField a -> OptionalField b)
    -> (forall a b. a -> OptionalField b -> OptionalField a)
    -> Functor OptionalField
    forall a b. a -> OptionalField b -> OptionalField a
    forall a b. (a -> b) -> OptionalField a -> OptionalField b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> OptionalField a -> OptionalField b
    fmap :: forall a b. (a -> b) -> OptionalField a -> OptionalField b
    $c<$ :: forall a b. a -> OptionalField b -> OptionalField a
    <$ :: forall a b. a -> OptionalField b -> OptionalField a
    Functor, NonEmpty (OptionalField a) -> OptionalField a
    OptionalField a -> OptionalField a -> OptionalField a
    (OptionalField a -> OptionalField a -> OptionalField a)
    -> (NonEmpty (OptionalField a) -> OptionalField a)
    -> (forall b.
        Integral b =>
        b -> OptionalField a -> OptionalField a)
    -> Semigroup (OptionalField a)
    forall b. Integral b => b -> OptionalField a -> OptionalField a
    forall a.
    Semigroup a =>
    NonEmpty (OptionalField a) -> OptionalField a
    forall a.
    Semigroup a =>
    OptionalField a -> OptionalField a -> OptionalField a
    forall a b.
    (Semigroup a, Integral b) =>
    b -> OptionalField a -> OptionalField a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a.
    Semigroup a =>
    OptionalField a -> OptionalField a -> OptionalField a
    <> :: OptionalField a -> OptionalField a -> OptionalField a
    $csconcat :: forall a.
    Semigroup a =>
    NonEmpty (OptionalField a) -> OptionalField a
    sconcat :: NonEmpty (OptionalField a) -> OptionalField a
    $cstimes :: forall a b.
    (Semigroup a, Integral b) =>
    b -> OptionalField a -> OptionalField a
    stimes :: forall b. Integral b => b -> OptionalField a -> OptionalField a
    Semigroup, Semigroup (OptionalField a)
    OptionalField a
    Semigroup (OptionalField a) =>
    OptionalField a
    -> (OptionalField a -> OptionalField a -> OptionalField a)
    -> ([OptionalField a] -> OptionalField a)
    -> Monoid (OptionalField a)
    [OptionalField a] -> OptionalField a
    OptionalField a -> OptionalField a -> OptionalField a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (OptionalField a)
    forall a. Monoid a => OptionalField a
    forall a. Monoid a => [OptionalField a] -> OptionalField a
    forall a.
    Monoid a =>
    OptionalField a -> OptionalField a -> OptionalField a
    $cmempty :: forall a. Monoid a => OptionalField a
    mempty :: OptionalField a
    $cmappend :: forall a.
    Monoid a =>
    OptionalField a -> OptionalField a -> OptionalField a
    mappend :: OptionalField a -> OptionalField a -> OptionalField a
    $cmconcat :: forall a. Monoid a => [OptionalField a] -> OptionalField a
    mconcat :: [OptionalField a] -> OptionalField a
    Monoid, Eq (OptionalField a)
    Eq (OptionalField a) =>
    (OptionalField a -> OptionalField a -> Ordering)
    -> (OptionalField a -> OptionalField a -> Bool)
    -> (OptionalField a -> OptionalField a -> Bool)
    -> (OptionalField a -> OptionalField a -> Bool)
    -> (OptionalField a -> OptionalField a -> Bool)
    -> (OptionalField a -> OptionalField a -> OptionalField a)
    -> (OptionalField a -> OptionalField a -> OptionalField a)
    -> Ord (OptionalField a)
    OptionalField a -> OptionalField a -> Bool
    OptionalField a -> OptionalField a -> Ordering
    OptionalField a -> OptionalField a -> OptionalField a
    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
    forall a. Ord a => Eq (OptionalField a)
    forall a. Ord a => OptionalField a -> OptionalField a -> Bool
    forall a. Ord a => OptionalField a -> OptionalField a -> Ordering
    forall a.
    Ord a =>
    OptionalField a -> OptionalField a -> OptionalField a
    $ccompare :: forall a. Ord a => OptionalField a -> OptionalField a -> Ordering
    compare :: OptionalField a -> OptionalField a -> Ordering
    $c< :: forall a. Ord a => OptionalField a -> OptionalField a -> Bool
    < :: OptionalField a -> OptionalField a -> Bool
    $c<= :: forall a. Ord a => OptionalField a -> OptionalField a -> Bool
    <= :: OptionalField a -> OptionalField a -> Bool
    $c> :: forall a. Ord a => OptionalField a -> OptionalField a -> Bool
    > :: OptionalField a -> OptionalField a -> Bool
    $c>= :: forall a. Ord a => OptionalField a -> OptionalField a -> Bool
    >= :: OptionalField a -> OptionalField a -> Bool
    $cmax :: forall a.
    Ord a =>
    OptionalField a -> OptionalField a -> OptionalField a
    max :: OptionalField a -> OptionalField a -> OptionalField a
    $cmin :: forall a.
    Ord a =>
    OptionalField a -> OptionalField a -> OptionalField a
    min :: OptionalField a -> OptionalField a -> OptionalField a
    Ord, OptionalField a -> ()
    (OptionalField a -> ()) -> NFData (OptionalField a)
    forall a. NFData a => OptionalField a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => OptionalField a -> ()
    rnf :: OptionalField a -> ()
    NFData, Int -> OptionalField a -> ShowS
    [OptionalField a] -> ShowS
    OptionalField a -> String
    (Int -> OptionalField a -> ShowS)
    -> (OptionalField a -> String)
    -> ([OptionalField a] -> ShowS)
    -> Show (OptionalField a)
    forall a. Show a => Int -> OptionalField a -> ShowS
    forall a. Show a => [OptionalField a] -> ShowS
    forall a. Show a => OptionalField a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> OptionalField a -> ShowS
    showsPrec :: Int -> OptionalField a -> ShowS
    $cshow :: forall a. Show a => OptionalField a -> String
    show :: OptionalField a -> String
    $cshowList :: forall a. Show a => [OptionalField a] -> ShowS
    showList :: [OptionalField a] -> ShowS
    Show, Functor OptionalField
    Foldable OptionalField
    (Functor OptionalField, Foldable OptionalField) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> OptionalField a -> f (OptionalField b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        OptionalField (f a) -> f (OptionalField a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> OptionalField a -> m (OptionalField b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        OptionalField (m a) -> m (OptionalField a))
    -> Traversable OptionalField
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    OptionalField (m a) -> m (OptionalField a)
    forall (f :: * -> *) a.
    Applicative f =>
    OptionalField (f a) -> f (OptionalField a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> OptionalField a -> m (OptionalField b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> OptionalField a -> f (OptionalField b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> OptionalField a -> f (OptionalField b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> OptionalField a -> f (OptionalField b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    OptionalField (f a) -> f (OptionalField a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    OptionalField (f a) -> f (OptionalField a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> OptionalField a -> m (OptionalField b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> OptionalField a -> m (OptionalField b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    OptionalField (m a) -> m (OptionalField a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    OptionalField (m a) -> m (OptionalField a)
    Traversable, Typeable)

    -- |
    -- 'RepeatedField' is a newtype wrapped used to break overlapping instances
    -- for encoding and decoding values
    newtype RepeatedField a    = Repeated    {forall a. RepeatedField a -> a
    runRepeated    :: a}
      deriving (RepeatedField a
    RepeatedField a -> RepeatedField a -> Bounded (RepeatedField a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => RepeatedField a
    $cminBound :: forall a. Bounded a => RepeatedField a
    minBound :: RepeatedField a
    $cmaxBound :: forall a. Bounded a => RepeatedField a
    maxBound :: RepeatedField a
    Bounded, RepeatedField a -> RepeatedField a -> Bool
    (RepeatedField a -> RepeatedField a -> Bool)
    -> (RepeatedField a -> RepeatedField a -> Bool)
    -> Eq (RepeatedField a)
    forall a. Eq a => RepeatedField a -> RepeatedField a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => RepeatedField a -> RepeatedField a -> Bool
    == :: RepeatedField a -> RepeatedField a -> Bool
    $c/= :: forall a. Eq a => RepeatedField a -> RepeatedField a -> Bool
    /= :: RepeatedField a -> RepeatedField a -> Bool
    Eq, Int -> RepeatedField a
    RepeatedField a -> Int
    RepeatedField a -> [RepeatedField a]
    RepeatedField a -> RepeatedField a
    RepeatedField a -> RepeatedField a -> [RepeatedField a]
    RepeatedField a
    -> RepeatedField a -> RepeatedField a -> [RepeatedField a]
    (RepeatedField a -> RepeatedField a)
    -> (RepeatedField a -> RepeatedField a)
    -> (Int -> RepeatedField a)
    -> (RepeatedField a -> Int)
    -> (RepeatedField a -> [RepeatedField a])
    -> (RepeatedField a -> RepeatedField a -> [RepeatedField a])
    -> (RepeatedField a -> RepeatedField a -> [RepeatedField a])
    -> (RepeatedField a
        -> RepeatedField a -> RepeatedField a -> [RepeatedField a])
    -> Enum (RepeatedField a)
    forall a. Enum a => Int -> RepeatedField a
    forall a. Enum a => RepeatedField a -> Int
    forall a. Enum a => RepeatedField a -> [RepeatedField a]
    forall a. Enum a => RepeatedField a -> RepeatedField a
    forall a.
    Enum a =>
    RepeatedField a -> RepeatedField a -> [RepeatedField a]
    forall a.
    Enum a =>
    RepeatedField a
    -> RepeatedField a -> RepeatedField a -> [RepeatedField a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => RepeatedField a -> RepeatedField a
    succ :: RepeatedField a -> RepeatedField a
    $cpred :: forall a. Enum a => RepeatedField a -> RepeatedField a
    pred :: RepeatedField a -> RepeatedField a
    $ctoEnum :: forall a. Enum a => Int -> RepeatedField a
    toEnum :: Int -> RepeatedField a
    $cfromEnum :: forall a. Enum a => RepeatedField a -> Int
    fromEnum :: RepeatedField a -> Int
    $cenumFrom :: forall a. Enum a => RepeatedField a -> [RepeatedField a]
    enumFrom :: RepeatedField a -> [RepeatedField a]
    $cenumFromThen :: forall a.
    Enum a =>
    RepeatedField a -> RepeatedField a -> [RepeatedField a]
    enumFromThen :: RepeatedField a -> RepeatedField a -> [RepeatedField a]
    $cenumFromTo :: forall a.
    Enum a =>
    RepeatedField a -> RepeatedField a -> [RepeatedField a]
    enumFromTo :: RepeatedField a -> RepeatedField a -> [RepeatedField a]
    $cenumFromThenTo :: forall a.
    Enum a =>
    RepeatedField a
    -> RepeatedField a -> RepeatedField a -> [RepeatedField a]
    enumFromThenTo :: RepeatedField a
    -> RepeatedField a -> RepeatedField a -> [RepeatedField a]
    Enum, (forall m. Monoid m => RepeatedField m -> m)
    -> (forall m a. Monoid m => (a -> m) -> RepeatedField a -> m)
    -> (forall m a. Monoid m => (a -> m) -> RepeatedField a -> m)
    -> (forall a b. (a -> b -> b) -> b -> RepeatedField a -> b)
    -> (forall a b. (a -> b -> b) -> b -> RepeatedField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RepeatedField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> RepeatedField a -> b)
    -> (forall a. (a -> a -> a) -> RepeatedField a -> a)
    -> (forall a. (a -> a -> a) -> RepeatedField a -> a)
    -> (forall a. RepeatedField a -> [a])
    -> (forall a. RepeatedField a -> Bool)
    -> (forall a. RepeatedField a -> Int)
    -> (forall a. Eq a => a -> RepeatedField a -> Bool)
    -> (forall a. Ord a => RepeatedField a -> a)
    -> (forall a. Ord a => RepeatedField a -> a)
    -> (forall a. Num a => RepeatedField a -> a)
    -> (forall a. Num a => RepeatedField a -> a)
    -> Foldable RepeatedField
    forall a. Eq a => a -> RepeatedField a -> Bool
    forall a. Num a => RepeatedField a -> a
    forall a. Ord a => RepeatedField a -> a
    forall m. Monoid m => RepeatedField m -> m
    forall a. RepeatedField a -> Bool
    forall a. RepeatedField a -> Int
    forall a. RepeatedField a -> [a]
    forall a. (a -> a -> a) -> RepeatedField a -> a
    forall m a. Monoid m => (a -> m) -> RepeatedField a -> m
    forall b a. (b -> a -> b) -> b -> RepeatedField a -> b
    forall a b. (a -> b -> b) -> b -> RepeatedField a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => RepeatedField m -> m
    fold :: forall m. Monoid m => RepeatedField m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> RepeatedField a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> RepeatedField a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> RepeatedField a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> RepeatedField a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> RepeatedField a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> RepeatedField a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> RepeatedField a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> RepeatedField a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> RepeatedField a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> RepeatedField a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> RepeatedField a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> RepeatedField a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> RepeatedField a -> a
    foldr1 :: forall a. (a -> a -> a) -> RepeatedField a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> RepeatedField a -> a
    foldl1 :: forall a. (a -> a -> a) -> RepeatedField a -> a
    $ctoList :: forall a. RepeatedField a -> [a]
    toList :: forall a. RepeatedField a -> [a]
    $cnull :: forall a. RepeatedField a -> Bool
    null :: forall a. RepeatedField a -> Bool
    $clength :: forall a. RepeatedField a -> Int
    length :: forall a. RepeatedField a -> Int
    $celem :: forall a. Eq a => a -> RepeatedField a -> Bool
    elem :: forall a. Eq a => a -> RepeatedField a -> Bool
    $cmaximum :: forall a. Ord a => RepeatedField a -> a
    maximum :: forall a. Ord a => RepeatedField a -> a
    $cminimum :: forall a. Ord a => RepeatedField a -> a
    minimum :: forall a. Ord a => RepeatedField a -> a
    $csum :: forall a. Num a => RepeatedField a -> a
    sum :: forall a. Num a => RepeatedField a -> a
    $cproduct :: forall a. Num a => RepeatedField a -> a
    product :: forall a. Num a => RepeatedField a -> a
    Foldable, (forall a b. (a -> b) -> RepeatedField a -> RepeatedField b)
    -> (forall a b. a -> RepeatedField b -> RepeatedField a)
    -> Functor RepeatedField
    forall a b. a -> RepeatedField b -> RepeatedField a
    forall a b. (a -> b) -> RepeatedField a -> RepeatedField b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> RepeatedField a -> RepeatedField b
    fmap :: forall a b. (a -> b) -> RepeatedField a -> RepeatedField b
    $c<$ :: forall a b. a -> RepeatedField b -> RepeatedField a
    <$ :: forall a b. a -> RepeatedField b -> RepeatedField a
    Functor, NonEmpty (RepeatedField a) -> RepeatedField a
    RepeatedField a -> RepeatedField a -> RepeatedField a
    (RepeatedField a -> RepeatedField a -> RepeatedField a)
    -> (NonEmpty (RepeatedField a) -> RepeatedField a)
    -> (forall b.
        Integral b =>
        b -> RepeatedField a -> RepeatedField a)
    -> Semigroup (RepeatedField a)
    forall b. Integral b => b -> RepeatedField a -> RepeatedField a
    forall a.
    Semigroup a =>
    NonEmpty (RepeatedField a) -> RepeatedField a
    forall a.
    Semigroup a =>
    RepeatedField a -> RepeatedField a -> RepeatedField a
    forall a b.
    (Semigroup a, Integral b) =>
    b -> RepeatedField a -> RepeatedField a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a.
    Semigroup a =>
    RepeatedField a -> RepeatedField a -> RepeatedField a
    <> :: RepeatedField a -> RepeatedField a -> RepeatedField a
    $csconcat :: forall a.
    Semigroup a =>
    NonEmpty (RepeatedField a) -> RepeatedField a
    sconcat :: NonEmpty (RepeatedField a) -> RepeatedField a
    $cstimes :: forall a b.
    (Semigroup a, Integral b) =>
    b -> RepeatedField a -> RepeatedField a
    stimes :: forall b. Integral b => b -> RepeatedField a -> RepeatedField a
    Semigroup, Semigroup (RepeatedField a)
    RepeatedField a
    Semigroup (RepeatedField a) =>
    RepeatedField a
    -> (RepeatedField a -> RepeatedField a -> RepeatedField a)
    -> ([RepeatedField a] -> RepeatedField a)
    -> Monoid (RepeatedField a)
    [RepeatedField a] -> RepeatedField a
    RepeatedField a -> RepeatedField a -> RepeatedField a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (RepeatedField a)
    forall a. Monoid a => RepeatedField a
    forall a. Monoid a => [RepeatedField a] -> RepeatedField a
    forall a.
    Monoid a =>
    RepeatedField a -> RepeatedField a -> RepeatedField a
    $cmempty :: forall a. Monoid a => RepeatedField a
    mempty :: RepeatedField a
    $cmappend :: forall a.
    Monoid a =>
    RepeatedField a -> RepeatedField a -> RepeatedField a
    mappend :: RepeatedField a -> RepeatedField a -> RepeatedField a
    $cmconcat :: forall a. Monoid a => [RepeatedField a] -> RepeatedField a
    mconcat :: [RepeatedField a] -> RepeatedField a
    Monoid, Eq (RepeatedField a)
    Eq (RepeatedField a) =>
    (RepeatedField a -> RepeatedField a -> Ordering)
    -> (RepeatedField a -> RepeatedField a -> Bool)
    -> (RepeatedField a -> RepeatedField a -> Bool)
    -> (RepeatedField a -> RepeatedField a -> Bool)
    -> (RepeatedField a -> RepeatedField a -> Bool)
    -> (RepeatedField a -> RepeatedField a -> RepeatedField a)
    -> (RepeatedField a -> RepeatedField a -> RepeatedField a)
    -> Ord (RepeatedField a)
    RepeatedField a -> RepeatedField a -> Bool
    RepeatedField a -> RepeatedField a -> Ordering
    RepeatedField a -> RepeatedField a -> RepeatedField a
    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
    forall a. Ord a => Eq (RepeatedField a)
    forall a. Ord a => RepeatedField a -> RepeatedField a -> Bool
    forall a. Ord a => RepeatedField a -> RepeatedField a -> Ordering
    forall a.
    Ord a =>
    RepeatedField a -> RepeatedField a -> RepeatedField a
    $ccompare :: forall a. Ord a => RepeatedField a -> RepeatedField a -> Ordering
    compare :: RepeatedField a -> RepeatedField a -> Ordering
    $c< :: forall a. Ord a => RepeatedField a -> RepeatedField a -> Bool
    < :: RepeatedField a -> RepeatedField a -> Bool
    $c<= :: forall a. Ord a => RepeatedField a -> RepeatedField a -> Bool
    <= :: RepeatedField a -> RepeatedField a -> Bool
    $c> :: forall a. Ord a => RepeatedField a -> RepeatedField a -> Bool
    > :: RepeatedField a -> RepeatedField a -> Bool
    $c>= :: forall a. Ord a => RepeatedField a -> RepeatedField a -> Bool
    >= :: RepeatedField a -> RepeatedField a -> Bool
    $cmax :: forall a.
    Ord a =>
    RepeatedField a -> RepeatedField a -> RepeatedField a
    max :: RepeatedField a -> RepeatedField a -> RepeatedField a
    $cmin :: forall a.
    Ord a =>
    RepeatedField a -> RepeatedField a -> RepeatedField a
    min :: RepeatedField a -> RepeatedField a -> RepeatedField a
    Ord, RepeatedField a -> ()
    (RepeatedField a -> ()) -> NFData (RepeatedField a)
    forall a. NFData a => RepeatedField a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => RepeatedField a -> ()
    rnf :: RepeatedField a -> ()
    NFData, Int -> RepeatedField a -> ShowS
    [RepeatedField a] -> ShowS
    RepeatedField a -> String
    (Int -> RepeatedField a -> ShowS)
    -> (RepeatedField a -> String)
    -> ([RepeatedField a] -> ShowS)
    -> Show (RepeatedField a)
    forall a. Show a => Int -> RepeatedField a -> ShowS
    forall a. Show a => [RepeatedField a] -> ShowS
    forall a. Show a => RepeatedField a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> RepeatedField a -> ShowS
    showsPrec :: Int -> RepeatedField a -> ShowS
    $cshow :: forall a. Show a => RepeatedField a -> String
    show :: RepeatedField a -> String
    $cshowList :: forall a. Show a => [RepeatedField a] -> ShowS
    showList :: [RepeatedField a] -> ShowS
    Show, Functor RepeatedField
    Foldable RepeatedField
    (Functor RepeatedField, Foldable RepeatedField) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> RepeatedField a -> f (RepeatedField b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        RepeatedField (f a) -> f (RepeatedField a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> RepeatedField a -> m (RepeatedField b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        RepeatedField (m a) -> m (RepeatedField a))
    -> Traversable RepeatedField
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    RepeatedField (m a) -> m (RepeatedField a)
    forall (f :: * -> *) a.
    Applicative f =>
    RepeatedField (f a) -> f (RepeatedField a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RepeatedField a -> m (RepeatedField b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RepeatedField a -> f (RepeatedField b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RepeatedField a -> f (RepeatedField b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RepeatedField a -> f (RepeatedField b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RepeatedField (f a) -> f (RepeatedField a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    RepeatedField (f a) -> f (RepeatedField a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RepeatedField a -> m (RepeatedField b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RepeatedField a -> m (RepeatedField b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    RepeatedField (m a) -> m (RepeatedField a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    RepeatedField (m a) -> m (RepeatedField a)
    Traversable, Typeable)

    -- |
    -- Fields are merely a way to hold a field tag along with its type, this shouldn't normally be referenced directly.
    --
    -- This provides better error messages than older versions which used 'Data.Tagged.Tagged'
    --
    newtype Field (n :: Nat) a = Field {forall (n :: Nat) a. Field n a -> a
    runField :: a}
      deriving (Field n a
    Field n a -> Field n a -> Bounded (Field n a)
    forall (n :: Nat) a. Bounded a => Field n a
    forall a. a -> a -> Bounded a
    $cminBound :: forall (n :: Nat) a. Bounded a => Field n a
    minBound :: Field n a
    $cmaxBound :: forall (n :: Nat) a. Bounded a => Field n a
    maxBound :: Field n a
    Bounded, Field n a -> Field n a -> Bool
    (Field n a -> Field n a -> Bool)
    -> (Field n a -> Field n a -> Bool) -> Eq (Field n a)
    forall (n :: Nat) a. Eq a => Field n a -> Field n a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall (n :: Nat) a. Eq a => Field n a -> Field n a -> Bool
    == :: Field n a -> Field n a -> Bool
    $c/= :: forall (n :: Nat) a. Eq a => Field n a -> Field n a -> Bool
    /= :: Field n a -> Field n a -> Bool
    Eq, Int -> Field n a
    Field n a -> Int
    Field n a -> [Field n a]
    Field n a -> Field n a
    Field n a -> Field n a -> [Field n a]
    Field n a -> Field n a -> Field n a -> [Field n a]
    (Field n a -> Field n a)
    -> (Field n a -> Field n a)
    -> (Int -> Field n a)
    -> (Field n a -> Int)
    -> (Field n a -> [Field n a])
    -> (Field n a -> Field n a -> [Field n a])
    -> (Field n a -> Field n a -> [Field n a])
    -> (Field n a -> Field n a -> Field n a -> [Field n a])
    -> Enum (Field n a)
    forall (n :: Nat) a. Enum a => Int -> Field n a
    forall (n :: Nat) a. Enum a => Field n a -> Int
    forall (n :: Nat) a. Enum a => Field n a -> [Field n a]
    forall (n :: Nat) a. Enum a => Field n a -> Field n a
    forall (n :: Nat) a.
    Enum a =>
    Field n a -> Field n a -> [Field n a]
    forall (n :: Nat) a.
    Enum a =>
    Field n a -> Field n a -> Field n a -> [Field n a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall (n :: Nat) a. Enum a => Field n a -> Field n a
    succ :: Field n a -> Field n a
    $cpred :: forall (n :: Nat) a. Enum a => Field n a -> Field n a
    pred :: Field n a -> Field n a
    $ctoEnum :: forall (n :: Nat) a. Enum a => Int -> Field n a
    toEnum :: Int -> Field n a
    $cfromEnum :: forall (n :: Nat) a. Enum a => Field n a -> Int
    fromEnum :: Field n a -> Int
    $cenumFrom :: forall (n :: Nat) a. Enum a => Field n a -> [Field n a]
    enumFrom :: Field n a -> [Field n a]
    $cenumFromThen :: forall (n :: Nat) a.
    Enum a =>
    Field n a -> Field n a -> [Field n a]
    enumFromThen :: Field n a -> Field n a -> [Field n a]
    $cenumFromTo :: forall (n :: Nat) a.
    Enum a =>
    Field n a -> Field n a -> [Field n a]
    enumFromTo :: Field n a -> Field n a -> [Field n a]
    $cenumFromThenTo :: forall (n :: Nat) a.
    Enum a =>
    Field n a -> Field n a -> Field n a -> [Field n a]
    enumFromThenTo :: Field n a -> Field n a -> Field n a -> [Field n a]
    Enum, (forall m. Monoid m => Field n m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Field n a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Field n a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Field n a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Field n a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Field n a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Field n a -> b)
    -> (forall a. (a -> a -> a) -> Field n a -> a)
    -> (forall a. (a -> a -> a) -> Field n a -> a)
    -> (forall a. Field n a -> [a])
    -> (forall a. Field n a -> Bool)
    -> (forall a. Field n a -> Int)
    -> (forall a. Eq a => a -> Field n a -> Bool)
    -> (forall a. Ord a => Field n a -> a)
    -> (forall a. Ord a => Field n a -> a)
    -> (forall a. Num a => Field n a -> a)
    -> (forall a. Num a => Field n a -> a)
    -> Foldable (Field n)
    forall (n :: Nat) a. Eq a => a -> Field n a -> Bool
    forall (n :: Nat) a. Num a => Field n a -> a
    forall (n :: Nat) a. Ord a => Field n a -> a
    forall (n :: Nat) m. Monoid m => Field n m -> m
    forall (n :: Nat) a. Field n a -> Bool
    forall (n :: Nat) a. Field n a -> Int
    forall (n :: Nat) a. Field n a -> [a]
    forall (n :: Nat) a. (a -> a -> a) -> Field n a -> a
    forall (n :: Nat) m a. Monoid m => (a -> m) -> Field n a -> m
    forall (n :: Nat) b a. (b -> a -> b) -> b -> Field n a -> b
    forall (n :: Nat) a b. (a -> b -> b) -> b -> Field n a -> b
    forall a. Eq a => a -> Field n a -> Bool
    forall a. Num a => Field n a -> a
    forall a. Ord a => Field n a -> a
    forall m. Monoid m => Field n m -> m
    forall a. Field n a -> Bool
    forall a. Field n a -> Int
    forall a. Field n a -> [a]
    forall a. (a -> a -> a) -> Field n a -> a
    forall m a. Monoid m => (a -> m) -> Field n a -> m
    forall b a. (b -> a -> b) -> b -> Field n a -> b
    forall a b. (a -> b -> b) -> b -> Field n a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall (n :: Nat) m. Monoid m => Field n m -> m
    fold :: forall m. Monoid m => Field n m -> m
    $cfoldMap :: forall (n :: Nat) m a. Monoid m => (a -> m) -> Field n a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Field n a -> m
    $cfoldMap' :: forall (n :: Nat) m a. Monoid m => (a -> m) -> Field n a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Field n a -> m
    $cfoldr :: forall (n :: Nat) a b. (a -> b -> b) -> b -> Field n a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Field n a -> b
    $cfoldr' :: forall (n :: Nat) a b. (a -> b -> b) -> b -> Field n a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Field n a -> b
    $cfoldl :: forall (n :: Nat) b a. (b -> a -> b) -> b -> Field n a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Field n a -> b
    $cfoldl' :: forall (n :: Nat) b a. (b -> a -> b) -> b -> Field n a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Field n a -> b
    $cfoldr1 :: forall (n :: Nat) a. (a -> a -> a) -> Field n a -> a
    foldr1 :: forall a. (a -> a -> a) -> Field n a -> a
    $cfoldl1 :: forall (n :: Nat) a. (a -> a -> a) -> Field n a -> a
    foldl1 :: forall a. (a -> a -> a) -> Field n a -> a
    $ctoList :: forall (n :: Nat) a. Field n a -> [a]
    toList :: forall a. Field n a -> [a]
    $cnull :: forall (n :: Nat) a. Field n a -> Bool
    null :: forall a. Field n a -> Bool
    $clength :: forall (n :: Nat) a. Field n a -> Int
    length :: forall a. Field n a -> Int
    $celem :: forall (n :: Nat) a. Eq a => a -> Field n a -> Bool
    elem :: forall a. Eq a => a -> Field n a -> Bool
    $cmaximum :: forall (n :: Nat) a. Ord a => Field n a -> a
    maximum :: forall a. Ord a => Field n a -> a
    $cminimum :: forall (n :: Nat) a. Ord a => Field n a -> a
    minimum :: forall a. Ord a => Field n a -> a
    $csum :: forall (n :: Nat) a. Num a => Field n a -> a
    sum :: forall a. Num a => Field n a -> a
    $cproduct :: forall (n :: Nat) a. Num a => Field n a -> a
    product :: forall a. Num a => Field n a -> a
    Foldable, (forall a b. (a -> b) -> Field n a -> Field n b)
    -> (forall a b. a -> Field n b -> Field n a) -> Functor (Field n)
    forall (n :: Nat) a b. a -> Field n b -> Field n a
    forall (n :: Nat) a b. (a -> b) -> Field n a -> Field n b
    forall a b. a -> Field n b -> Field n a
    forall a b. (a -> b) -> Field n a -> Field n b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall (n :: Nat) a b. (a -> b) -> Field n a -> Field n b
    fmap :: forall a b. (a -> b) -> Field n a -> Field n b
    $c<$ :: forall (n :: Nat) a b. a -> Field n b -> Field n a
    <$ :: forall a b. a -> Field n b -> Field n a
    Functor, NonEmpty (Field n a) -> Field n a
    Field n a -> Field n a -> Field n a
    (Field n a -> Field n a -> Field n a)
    -> (NonEmpty (Field n a) -> Field n a)
    -> (forall b. Integral b => b -> Field n a -> Field n a)
    -> Semigroup (Field n a)
    forall (n :: Nat) a.
    Semigroup a =>
    NonEmpty (Field n a) -> Field n a
    forall (n :: Nat) a.
    Semigroup a =>
    Field n a -> Field n a -> Field n a
    forall (n :: Nat) a b.
    (Semigroup a, Integral b) =>
    b -> Field n a -> Field n a
    forall b. Integral b => b -> Field n a -> Field n a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall (n :: Nat) a.
    Semigroup a =>
    Field n a -> Field n a -> Field n a
    <> :: Field n a -> Field n a -> Field n a
    $csconcat :: forall (n :: Nat) a.
    Semigroup a =>
    NonEmpty (Field n a) -> Field n a
    sconcat :: NonEmpty (Field n a) -> Field n a
    $cstimes :: forall (n :: Nat) a b.
    (Semigroup a, Integral b) =>
    b -> Field n a -> Field n a
    stimes :: forall b. Integral b => b -> Field n a -> Field n a
    Semigroup, Semigroup (Field n a)
    Field n a
    Semigroup (Field n a) =>
    Field n a
    -> (Field n a -> Field n a -> Field n a)
    -> ([Field n a] -> Field n a)
    -> Monoid (Field n a)
    [Field n a] -> Field n a
    Field n a -> Field n a -> Field n a
    forall (n :: Nat) a. Monoid a => Semigroup (Field n a)
    forall (n :: Nat) a. Monoid a => Field n a
    forall (n :: Nat) a. Monoid a => [Field n a] -> Field n a
    forall (n :: Nat) a.
    Monoid a =>
    Field n a -> Field n a -> Field n a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    $cmempty :: forall (n :: Nat) a. Monoid a => Field n a
    mempty :: Field n a
    $cmappend :: forall (n :: Nat) a.
    Monoid a =>
    Field n a -> Field n a -> Field n a
    mappend :: Field n a -> Field n a -> Field n a
    $cmconcat :: forall (n :: Nat) a. Monoid a => [Field n a] -> Field n a
    mconcat :: [Field n a] -> Field n a
    Monoid, Eq (Field n a)
    Eq (Field n a) =>
    (Field n a -> Field n a -> Ordering)
    -> (Field n a -> Field n a -> Bool)
    -> (Field n a -> Field n a -> Bool)
    -> (Field n a -> Field n a -> Bool)
    -> (Field n a -> Field n a -> Bool)
    -> (Field n a -> Field n a -> Field n a)
    -> (Field n a -> Field n a -> Field n a)
    -> Ord (Field n a)
    Field n a -> Field n a -> Bool
    Field n a -> Field n a -> Ordering
    Field n a -> Field n a -> Field n a
    forall (n :: Nat) a. Ord a => Eq (Field n a)
    forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Bool
    forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Ordering
    forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Field n a
    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
    $ccompare :: forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Ordering
    compare :: Field n a -> Field n a -> Ordering
    $c< :: forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Bool
    < :: Field n a -> Field n a -> Bool
    $c<= :: forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Bool
    <= :: Field n a -> Field n a -> Bool
    $c> :: forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Bool
    > :: Field n a -> Field n a -> Bool
    $c>= :: forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Bool
    >= :: Field n a -> Field n a -> Bool
    $cmax :: forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Field n a
    max :: Field n a -> Field n a -> Field n a
    $cmin :: forall (n :: Nat) a. Ord a => Field n a -> Field n a -> Field n a
    min :: Field n a -> Field n a -> Field n a
    Ord, Field n a -> ()
    (Field n a -> ()) -> NFData (Field n a)
    forall (n :: Nat) a. NFData a => Field n a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall (n :: Nat) a. NFData a => Field n a -> ()
    rnf :: Field n a -> ()
    NFData, Int -> Field n a -> ShowS
    [Field n a] -> ShowS
    Field n a -> String
    (Int -> Field n a -> ShowS)
    -> (Field n a -> String)
    -> ([Field n a] -> ShowS)
    -> Show (Field n a)
    forall (n :: Nat) a. Show a => Int -> Field n a -> ShowS
    forall (n :: Nat) a. Show a => [Field n a] -> ShowS
    forall (n :: Nat) a. Show a => Field n a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall (n :: Nat) a. Show a => Int -> Field n a -> ShowS
    showsPrec :: Int -> Field n a -> ShowS
    $cshow :: forall (n :: Nat) a. Show a => Field n a -> String
    show :: Field n a -> String
    $cshowList :: forall (n :: Nat) a. Show a => [Field n a] -> ShowS
    showList :: [Field n a] -> ShowS
    Show, Functor (Field n)
    Foldable (Field n)
    (Functor (Field n), Foldable (Field n)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Field n a -> f (Field n b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Field n (f a) -> f (Field n a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Field n a -> m (Field n b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Field n (m a) -> m (Field n a))
    -> Traversable (Field n)
    forall (n :: Nat). Functor (Field n)
    forall (n :: Nat). Foldable (Field n)
    forall (n :: Nat) (m :: * -> *) a.
    Monad m =>
    Field n (m a) -> m (Field n a)
    forall (n :: Nat) (f :: * -> *) a.
    Applicative f =>
    Field n (f a) -> f (Field n a)
    forall (n :: Nat) (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Field n a -> m (Field n b)
    forall (n :: Nat) (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Field n a -> f (Field n b)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Field n (m a) -> m (Field n a)
    forall (f :: * -> *) a.
    Applicative f =>
    Field n (f a) -> f (Field n a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Field n a -> m (Field n b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Field n a -> f (Field n b)
    $ctraverse :: forall (n :: Nat) (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Field n a -> f (Field n b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Field n a -> f (Field n b)
    $csequenceA :: forall (n :: Nat) (f :: * -> *) a.
    Applicative f =>
    Field n (f a) -> f (Field n a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Field n (f a) -> f (Field n a)
    $cmapM :: forall (n :: Nat) (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Field n a -> m (Field n b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Field n a -> m (Field n b)
    $csequence :: forall (n :: Nat) (m :: * -> *) a.
    Monad m =>
    Field n (m a) -> m (Field n a)
    sequence :: forall (m :: * -> *) a. Monad m => Field n (m a) -> m (Field n a)
    Traversable, Typeable)

    -- |
    -- To provide consistent instances for serialization a 'Traversable' 'Functor' is needed to
    -- make 'Required' fields have the same shape as 'Optional', 'Repeated' and 'Packed'.
    --
    -- This is the 'Data.Functor.Identity.Identity' 'Functor' with a 'Show' instance.
    newtype Always a = Always {forall a. Always a -> a
    runAlways :: a}
      deriving (Always a
    Always a -> Always a -> Bounded (Always a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Always a
    $cminBound :: forall a. Bounded a => Always a
    minBound :: Always a
    $cmaxBound :: forall a. Bounded a => Always a
    maxBound :: Always a
    Bounded, Always a -> Always a -> Bool
    (Always a -> Always a -> Bool)
    -> (Always a -> Always a -> Bool) -> Eq (Always a)
    forall a. Eq a => Always a -> Always a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Always a -> Always a -> Bool
    == :: Always a -> Always a -> Bool
    $c/= :: forall a. Eq a => Always a -> Always a -> Bool
    /= :: Always a -> Always a -> Bool
    Eq, Int -> Always a
    Always a -> Int
    Always a -> [Always a]
    Always a -> Always a
    Always a -> Always a -> [Always a]
    Always a -> Always a -> Always a -> [Always a]
    (Always a -> Always a)
    -> (Always a -> Always a)
    -> (Int -> Always a)
    -> (Always a -> Int)
    -> (Always a -> [Always a])
    -> (Always a -> Always a -> [Always a])
    -> (Always a -> Always a -> [Always a])
    -> (Always a -> Always a -> Always a -> [Always a])
    -> Enum (Always a)
    forall a. Enum a => Int -> Always a
    forall a. Enum a => Always a -> Int
    forall a. Enum a => Always a -> [Always a]
    forall a. Enum a => Always a -> Always a
    forall a. Enum a => Always a -> Always a -> [Always a]
    forall a. Enum a => Always a -> Always a -> Always a -> [Always a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => Always a -> Always a
    succ :: Always a -> Always a
    $cpred :: forall a. Enum a => Always a -> Always a
    pred :: Always a -> Always a
    $ctoEnum :: forall a. Enum a => Int -> Always a
    toEnum :: Int -> Always a
    $cfromEnum :: forall a. Enum a => Always a -> Int
    fromEnum :: Always a -> Int
    $cenumFrom :: forall a. Enum a => Always a -> [Always a]
    enumFrom :: Always a -> [Always a]
    $cenumFromThen :: forall a. Enum a => Always a -> Always a -> [Always a]
    enumFromThen :: Always a -> Always a -> [Always a]
    $cenumFromTo :: forall a. Enum a => Always a -> Always a -> [Always a]
    enumFromTo :: Always a -> Always a -> [Always a]
    $cenumFromThenTo :: forall a. Enum a => Always a -> Always a -> Always a -> [Always a]
    enumFromThenTo :: Always a -> Always a -> Always a -> [Always a]
    Enum, (forall m. Monoid m => Always m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Always a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Always a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Always a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Always a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Always a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Always a -> b)
    -> (forall a. (a -> a -> a) -> Always a -> a)
    -> (forall a. (a -> a -> a) -> Always a -> a)
    -> (forall a. Always a -> [a])
    -> (forall a. Always a -> Bool)
    -> (forall a. Always a -> Int)
    -> (forall a. Eq a => a -> Always a -> Bool)
    -> (forall a. Ord a => Always a -> a)
    -> (forall a. Ord a => Always a -> a)
    -> (forall a. Num a => Always a -> a)
    -> (forall a. Num a => Always a -> a)
    -> Foldable Always
    forall a. Eq a => a -> Always a -> Bool
    forall a. Num a => Always a -> a
    forall a. Ord a => Always a -> a
    forall m. Monoid m => Always m -> m
    forall a. Always a -> Bool
    forall a. Always a -> Int
    forall a. Always a -> [a]
    forall a. (a -> a -> a) -> Always a -> a
    forall m a. Monoid m => (a -> m) -> Always a -> m
    forall b a. (b -> a -> b) -> b -> Always a -> b
    forall a b. (a -> b -> b) -> b -> Always a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Always m -> m
    fold :: forall m. Monoid m => Always m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Always a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Always a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Always a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Always a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Always a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Always a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Always a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Always a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Always a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Always a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Always a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Always a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Always a -> a
    foldr1 :: forall a. (a -> a -> a) -> Always a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Always a -> a
    foldl1 :: forall a. (a -> a -> a) -> Always a -> a
    $ctoList :: forall a. Always a -> [a]
    toList :: forall a. Always a -> [a]
    $cnull :: forall a. Always a -> Bool
    null :: forall a. Always a -> Bool
    $clength :: forall a. Always a -> Int
    length :: forall a. Always a -> Int
    $celem :: forall a. Eq a => a -> Always a -> Bool
    elem :: forall a. Eq a => a -> Always a -> Bool
    $cmaximum :: forall a. Ord a => Always a -> a
    maximum :: forall a. Ord a => Always a -> a
    $cminimum :: forall a. Ord a => Always a -> a
    minimum :: forall a. Ord a => Always a -> a
    $csum :: forall a. Num a => Always a -> a
    sum :: forall a. Num a => Always a -> a
    $cproduct :: forall a. Num a => Always a -> a
    product :: forall a. Num a => Always a -> a
    Foldable, (forall a b. (a -> b) -> Always a -> Always b)
    -> (forall a b. a -> Always b -> Always a) -> Functor Always
    forall a b. a -> Always b -> Always a
    forall a b. (a -> b) -> Always a -> Always b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Always a -> Always b
    fmap :: forall a b. (a -> b) -> Always a -> Always b
    $c<$ :: forall a b. a -> Always b -> Always a
    <$ :: forall a b. a -> Always b -> Always a
    Functor, Eq (Always a)
    Eq (Always a) =>
    (Always a -> Always a -> Ordering)
    -> (Always a -> Always a -> Bool)
    -> (Always a -> Always a -> Bool)
    -> (Always a -> Always a -> Bool)
    -> (Always a -> Always a -> Bool)
    -> (Always a -> Always a -> Always a)
    -> (Always a -> Always a -> Always a)
    -> Ord (Always a)
    Always a -> Always a -> Bool
    Always a -> Always a -> Ordering
    Always a -> Always a -> Always a
    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
    forall a. Ord a => Eq (Always a)
    forall a. Ord a => Always a -> Always a -> Bool
    forall a. Ord a => Always a -> Always a -> Ordering
    forall a. Ord a => Always a -> Always a -> Always a
    $ccompare :: forall a. Ord a => Always a -> Always a -> Ordering
    compare :: Always a -> Always a -> Ordering
    $c< :: forall a. Ord a => Always a -> Always a -> Bool
    < :: Always a -> Always a -> Bool
    $c<= :: forall a. Ord a => Always a -> Always a -> Bool
    <= :: Always a -> Always a -> Bool
    $c> :: forall a. Ord a => Always a -> Always a -> Bool
    > :: Always a -> Always a -> Bool
    $c>= :: forall a. Ord a => Always a -> Always a -> Bool
    >= :: Always a -> Always a -> Bool
    $cmax :: forall a. Ord a => Always a -> Always a -> Always a
    max :: Always a -> Always a -> Always a
    $cmin :: forall a. Ord a => Always a -> Always a -> Always a
    min :: Always a -> Always a -> Always a
    Ord, Always a -> ()
    (Always a -> ()) -> NFData (Always a)
    forall a. NFData a => Always a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => Always a -> ()
    rnf :: Always a -> ()
    NFData, Int -> Always a -> ShowS
    [Always a] -> ShowS
    Always a -> String
    (Int -> Always a -> ShowS)
    -> (Always a -> String) -> ([Always a] -> ShowS) -> Show (Always a)
    forall a. Show a => Int -> Always a -> ShowS
    forall a. Show a => [Always a] -> ShowS
    forall a. Show a => Always a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Always a -> ShowS
    showsPrec :: Int -> Always a -> ShowS
    $cshow :: forall a. Show a => Always a -> String
    show :: Always a -> String
    $cshowList :: forall a. Show a => [Always a] -> ShowS
    showList :: [Always a] -> ShowS
    Show, Functor Always
    Foldable Always
    (Functor Always, Foldable Always) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Always a -> f (Always b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Always (f a) -> f (Always a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Always a -> m (Always b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Always (m a) -> m (Always a))
    -> Traversable Always
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Always (m a) -> m (Always a)
    forall (f :: * -> *) a.
    Applicative f =>
    Always (f a) -> f (Always a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Always a -> m (Always b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Always a -> f (Always b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Always a -> f (Always b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Always a -> f (Always b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Always (f a) -> f (Always a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Always (f a) -> f (Always a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Always a -> m (Always b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Always a -> m (Always b)
    $csequence :: forall (m :: * -> *) a. Monad m => Always (m a) -> m (Always a)
    sequence :: forall (m :: * -> *) a. Monad m => Always (m a) -> m (Always a)
    Traversable, Typeable)

    instance Semigroup (Always a) where
      Always a
    _ <> :: Always a -> Always a -> Always a
    <> Always a
    y = Always a
    y

    instance Monoid (Always a) where
      mempty :: Always a
    mempty = String -> Always a
    forall a. HasCallStack => String -> a
    error String
    "Always is not a Monoid"
      mappend :: Always a -> Always a -> Always a
    mappend = Always a -> Always a -> Always a
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- |
    -- Functions for wrapping and unwrapping record fields.
    -- When applied they will have types similar to these:
    --
    -- @
    --'getField' :: 'Required' '1' ('Value' 'Data.Text.Text') -> 'Data.Text.Text'
    --'putField' :: 'Data.Text.Text' -> 'Required' '1' ('Value' 'Data.Text.Text')
    --
    --'getField' :: 'Optional' '2' ('Value' 'Data.Int.Int32') -> 'Maybe' 'Data.Int.Int32'
    --'putField' :: 'Maybe' 'Data.Int.Int32' -> 'Optional' '2' ('Value' 'Data.Int.Int32')
    --
    --'getField' :: 'Repeated' '3' ('Value' 'Double') -> ['Double']
    --'putField' :: ['Double'] -> 'Repeated' '3' ('Value' 'Double')
    --
    --'getField' :: 'Packed' '4' ('Value' 'Data.Word.Word64') -> ['Data.Word.Word64']
    --'putField' :: ['Data.Word.Word64'] -> 'Packed' '4' ('Value' 'Data.Word.Word64')
    -- @
    class HasField a where
      type FieldType a :: *

      -- | Extract a value from it's 'Field' representation.
      getField :: a -> FieldType a

      -- | Wrap it back up again.
      putField :: FieldType a -> a

      -- | An isomorphism lens compatible with the lens package
      field :: Functor f => (FieldType a -> f (FieldType a)) -> a -> f a
      field FieldType a -> f (FieldType a)
    f = (FieldType a -> a) -> f (FieldType a) -> f a
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap FieldType a -> a
    forall a. HasField a => FieldType a -> a
    putField (f (FieldType a) -> f a) -> (a -> f (FieldType a)) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FieldType a -> f (FieldType a)
    f (FieldType a -> f (FieldType a))
    -> (a -> FieldType a) -> a -> f (FieldType a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> FieldType a
    forall a. HasField a => a -> FieldType a
    getField

    -- | Iso: @ 'FieldType' ('Required' n ('Value' a)) = a @
    instance HasField (Field n (RequiredField (Always (Value a)))) where
      type FieldType (Field n (RequiredField (Always (Value a)))) = a
      getField :: Field n (RequiredField (Always (Value a)))
    -> FieldType (Field n (RequiredField (Always (Value a))))
    getField = Value a -> a
    forall a. Value a -> a
    runValue (Value a -> a)
    -> (Field n (RequiredField (Always (Value a))) -> Value a)
    -> Field n (RequiredField (Always (Value a)))
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Always (Value a) -> Value a
    forall a. Always a -> a
    runAlways (Always (Value a) -> Value a)
    -> (Field n (RequiredField (Always (Value a))) -> Always (Value a))
    -> Field n (RequiredField (Always (Value a)))
    -> Value a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RequiredField (Always (Value a)) -> Always (Value a)
    forall a. RequiredField a -> a
    runRequired (RequiredField (Always (Value a)) -> Always (Value a))
    -> (Field n (RequiredField (Always (Value a)))
        -> RequiredField (Always (Value a)))
    -> Field n (RequiredField (Always (Value a)))
    -> Always (Value a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (RequiredField (Always (Value a)))
    -> RequiredField (Always (Value a))
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (RequiredField (Always (Value a))))
    -> Field n (RequiredField (Always (Value a)))
    putField = RequiredField (Always (Value a))
    -> Field n (RequiredField (Always (Value a)))
    forall (n :: Nat) a. a -> Field n a
    Field (RequiredField (Always (Value a))
     -> Field n (RequiredField (Always (Value a))))
    -> (a -> RequiredField (Always (Value a)))
    -> a
    -> Field n (RequiredField (Always (Value a)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Always (Value a) -> RequiredField (Always (Value a))
    forall a. a -> RequiredField a
    Required (Always (Value a) -> RequiredField (Always (Value a)))
    -> (a -> Always (Value a)) -> a -> RequiredField (Always (Value a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Value a -> Always (Value a)
    forall a. a -> Always a
    Always (Value a -> Always (Value a))
    -> (a -> Value a) -> a -> Always (Value a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Value a
    forall a. a -> Value a
    Value

    -- | Iso: @ 'FieldType' ('Required' n ('Enumeration' a)) = a @
    instance HasField (Field n (RequiredField (Always (Enumeration a)))) where
      type FieldType (Field n (RequiredField (Always (Enumeration a)))) = a
      getField :: Field n (RequiredField (Always (Enumeration a)))
    -> FieldType (Field n (RequiredField (Always (Enumeration a))))
    getField = Enumeration a -> a
    forall a. Enumeration a -> a
    runEnumeration (Enumeration a -> a)
    -> (Field n (RequiredField (Always (Enumeration a)))
        -> Enumeration a)
    -> Field n (RequiredField (Always (Enumeration a)))
    -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Always (Enumeration a) -> Enumeration a
    forall a. Always a -> a
    runAlways (Always (Enumeration a) -> Enumeration a)
    -> (Field n (RequiredField (Always (Enumeration a)))
        -> Always (Enumeration a))
    -> Field n (RequiredField (Always (Enumeration a)))
    -> Enumeration a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RequiredField (Always (Enumeration a)) -> Always (Enumeration a)
    forall a. RequiredField a -> a
    runRequired (RequiredField (Always (Enumeration a)) -> Always (Enumeration a))
    -> (Field n (RequiredField (Always (Enumeration a)))
        -> RequiredField (Always (Enumeration a)))
    -> Field n (RequiredField (Always (Enumeration a)))
    -> Always (Enumeration a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (RequiredField (Always (Enumeration a)))
    -> RequiredField (Always (Enumeration a))
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (RequiredField (Always (Enumeration a))))
    -> Field n (RequiredField (Always (Enumeration a)))
    putField = RequiredField (Always (Enumeration a))
    -> Field n (RequiredField (Always (Enumeration a)))
    forall (n :: Nat) a. a -> Field n a
    Field (RequiredField (Always (Enumeration a))
     -> Field n (RequiredField (Always (Enumeration a))))
    -> (a -> RequiredField (Always (Enumeration a)))
    -> a
    -> Field n (RequiredField (Always (Enumeration a)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Always (Enumeration a) -> RequiredField (Always (Enumeration a))
    forall a. a -> RequiredField a
    Required (Always (Enumeration a) -> RequiredField (Always (Enumeration a)))
    -> (a -> Always (Enumeration a))
    -> a
    -> RequiredField (Always (Enumeration a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Enumeration a -> Always (Enumeration a)
    forall a. a -> Always a
    Always (Enumeration a -> Always (Enumeration a))
    -> (a -> Enumeration a) -> a -> Always (Enumeration a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Enumeration a
    forall a. a -> Enumeration a
    Enumeration

    -- | Iso: @ 'FieldType' ('Optional' n ('Value' a)) = 'Maybe' a @
    instance HasField (Field n (OptionalField (Last (Value a)))) where
      type FieldType (Field n (OptionalField (Last (Value a)))) = Maybe a
      getField :: Field n (OptionalField (Last (Value a)))
    -> FieldType (Field n (OptionalField (Last (Value a))))
    getField = (Value a -> a) -> Maybe (Value a) -> Maybe a
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Value a -> a
    forall a. Value a -> a
    runValue (Maybe (Value a) -> Maybe a)
    -> (Field n (OptionalField (Last (Value a))) -> Maybe (Value a))
    -> Field n (OptionalField (Last (Value a)))
    -> Maybe a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Last (Value a) -> Maybe (Value a)
    forall a. Last a -> Maybe a
    getLast (Last (Value a) -> Maybe (Value a))
    -> (Field n (OptionalField (Last (Value a))) -> Last (Value a))
    -> Field n (OptionalField (Last (Value a)))
    -> Maybe (Value a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OptionalField (Last (Value a)) -> Last (Value a)
    forall a. OptionalField a -> a
    runOptional (OptionalField (Last (Value a)) -> Last (Value a))
    -> (Field n (OptionalField (Last (Value a)))
        -> OptionalField (Last (Value a)))
    -> Field n (OptionalField (Last (Value a)))
    -> Last (Value a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (OptionalField (Last (Value a)))
    -> OptionalField (Last (Value a))
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (OptionalField (Last (Value a))))
    -> Field n (OptionalField (Last (Value a)))
    putField = OptionalField (Last (Value a))
    -> Field n (OptionalField (Last (Value a)))
    forall (n :: Nat) a. a -> Field n a
    Field (OptionalField (Last (Value a))
     -> Field n (OptionalField (Last (Value a))))
    -> (Maybe a -> OptionalField (Last (Value a)))
    -> Maybe a
    -> Field n (OptionalField (Last (Value a)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Last (Value a) -> OptionalField (Last (Value a))
    forall a. a -> OptionalField a
    Optional (Last (Value a) -> OptionalField (Last (Value a)))
    -> (Maybe a -> Last (Value a))
    -> Maybe a
    -> OptionalField (Last (Value a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe (Value a) -> Last (Value a)
    forall a. Maybe a -> Last a
    Last (Maybe (Value a) -> Last (Value a))
    -> (Maybe a -> Maybe (Value a)) -> Maybe a -> Last (Value a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Value a) -> Maybe a -> Maybe (Value a)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Value a
    forall a. a -> Value a
    Value

    -- | Iso: @ 'FieldType' ('Optional' n ('Enumeration' a)) = 'Maybe' a @
    instance HasField (Field n (OptionalField (Last (Enumeration a)))) where
      type FieldType (Field n (OptionalField (Last (Enumeration a)))) = Maybe a
      getField :: Field n (OptionalField (Last (Enumeration a)))
    -> FieldType (Field n (OptionalField (Last (Enumeration a))))
    getField = (Enumeration a -> a) -> Maybe (Enumeration a) -> Maybe a
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Enumeration a -> a
    forall a. Enumeration a -> a
    runEnumeration (Maybe (Enumeration a) -> Maybe a)
    -> (Field n (OptionalField (Last (Enumeration a)))
        -> Maybe (Enumeration a))
    -> Field n (OptionalField (Last (Enumeration a)))
    -> Maybe a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Last (Enumeration a) -> Maybe (Enumeration a)
    forall a. Last a -> Maybe a
    getLast (Last (Enumeration a) -> Maybe (Enumeration a))
    -> (Field n (OptionalField (Last (Enumeration a)))
        -> Last (Enumeration a))
    -> Field n (OptionalField (Last (Enumeration a)))
    -> Maybe (Enumeration a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OptionalField (Last (Enumeration a)) -> Last (Enumeration a)
    forall a. OptionalField a -> a
    runOptional (OptionalField (Last (Enumeration a)) -> Last (Enumeration a))
    -> (Field n (OptionalField (Last (Enumeration a)))
        -> OptionalField (Last (Enumeration a)))
    -> Field n (OptionalField (Last (Enumeration a)))
    -> Last (Enumeration a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (OptionalField (Last (Enumeration a)))
    -> OptionalField (Last (Enumeration a))
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (OptionalField (Last (Enumeration a))))
    -> Field n (OptionalField (Last (Enumeration a)))
    putField = OptionalField (Last (Enumeration a))
    -> Field n (OptionalField (Last (Enumeration a)))
    forall (n :: Nat) a. a -> Field n a
    Field (OptionalField (Last (Enumeration a))
     -> Field n (OptionalField (Last (Enumeration a))))
    -> (Maybe a -> OptionalField (Last (Enumeration a)))
    -> Maybe a
    -> Field n (OptionalField (Last (Enumeration a)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Last (Enumeration a) -> OptionalField (Last (Enumeration a))
    forall a. a -> OptionalField a
    Optional (Last (Enumeration a) -> OptionalField (Last (Enumeration a)))
    -> (Maybe a -> Last (Enumeration a))
    -> Maybe a
    -> OptionalField (Last (Enumeration a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe (Enumeration a) -> Last (Enumeration a)
    forall a. Maybe a -> Last a
    Last (Maybe (Enumeration a) -> Last (Enumeration a))
    -> (Maybe a -> Maybe (Enumeration a))
    -> Maybe a
    -> Last (Enumeration a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Enumeration a) -> Maybe a -> Maybe (Enumeration a)
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Enumeration a
    forall a. a -> Enumeration a
    Enumeration

    -- | Iso: @ 'FieldType' ('Repeated' n ('Value' a)) = [a] @
    instance HasField (Field n (RepeatedField [Value a])) where
      type FieldType (Field n (RepeatedField [Value a])) = [a]
      getField :: Field n (RepeatedField [Value a])
    -> FieldType (Field n (RepeatedField [Value a]))
    getField = (Value a -> a) -> [Value a] -> [a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Value a -> a
    forall a. Value a -> a
    runValue ([Value a] -> [a])
    -> (Field n (RepeatedField [Value a]) -> [Value a])
    -> Field n (RepeatedField [Value a])
    -> [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RepeatedField [Value a] -> [Value a]
    forall a. RepeatedField a -> a
    runRepeated (RepeatedField [Value a] -> [Value a])
    -> (Field n (RepeatedField [Value a]) -> RepeatedField [Value a])
    -> Field n (RepeatedField [Value a])
    -> [Value a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (RepeatedField [Value a]) -> RepeatedField [Value a]
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (RepeatedField [Value a]))
    -> Field n (RepeatedField [Value a])
    putField = RepeatedField [Value a] -> Field n (RepeatedField [Value a])
    forall (n :: Nat) a. a -> Field n a
    Field (RepeatedField [Value a] -> Field n (RepeatedField [Value a]))
    -> ([a] -> RepeatedField [Value a])
    -> [a]
    -> Field n (RepeatedField [Value a])
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Value a] -> RepeatedField [Value a]
    forall a. a -> RepeatedField a
    Repeated ([Value a] -> RepeatedField [Value a])
    -> ([a] -> [Value a]) -> [a] -> RepeatedField [Value a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Value a) -> [a] -> [Value a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Value a
    forall a. a -> Value a
    Value

    -- | Iso: @ 'FieldType' ('Repeated' n ('Enumeration' a)) = [a] @
    instance HasField (Field n (RepeatedField [Enumeration a])) where
      type FieldType (Field n (RepeatedField [Enumeration a])) = [a]
      getField :: Field n (RepeatedField [Enumeration a])
    -> FieldType (Field n (RepeatedField [Enumeration a]))
    getField = (Enumeration a -> a) -> [Enumeration a] -> [a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Enumeration a -> a
    forall a. Enumeration a -> a
    runEnumeration ([Enumeration a] -> [a])
    -> (Field n (RepeatedField [Enumeration a]) -> [Enumeration a])
    -> Field n (RepeatedField [Enumeration a])
    -> [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . RepeatedField [Enumeration a] -> [Enumeration a]
    forall a. RepeatedField a -> a
    runRepeated (RepeatedField [Enumeration a] -> [Enumeration a])
    -> (Field n (RepeatedField [Enumeration a])
        -> RepeatedField [Enumeration a])
    -> Field n (RepeatedField [Enumeration a])
    -> [Enumeration a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (RepeatedField [Enumeration a])
    -> RepeatedField [Enumeration a]
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (RepeatedField [Enumeration a]))
    -> Field n (RepeatedField [Enumeration a])
    putField = RepeatedField [Enumeration a]
    -> Field n (RepeatedField [Enumeration a])
    forall (n :: Nat) a. a -> Field n a
    Field (RepeatedField [Enumeration a]
     -> Field n (RepeatedField [Enumeration a]))
    -> ([a] -> RepeatedField [Enumeration a])
    -> [a]
    -> Field n (RepeatedField [Enumeration a])
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Enumeration a] -> RepeatedField [Enumeration a]
    forall a. a -> RepeatedField a
    Repeated ([Enumeration a] -> RepeatedField [Enumeration a])
    -> ([a] -> [Enumeration a]) -> [a] -> RepeatedField [Enumeration a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Enumeration a) -> [a] -> [Enumeration a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Enumeration a
    forall a. a -> Enumeration a
    Enumeration

    -- | Iso: @ 'FieldType' ('Packed' n ('Value' a)) = [a] @
    instance HasField (Field n (PackedField (PackedList (Value a)))) where
      type FieldType (Field n (PackedField (PackedList (Value a)))) = [a]
      getField :: Field n (PackedField (PackedList (Value a)))
    -> FieldType (Field n (PackedField (PackedList (Value a))))
    getField = (Value a -> a) -> [Value a] -> [a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Value a -> a
    forall a. Value a -> a
    runValue ([Value a] -> [a])
    -> (Field n (PackedField (PackedList (Value a))) -> [Value a])
    -> Field n (PackedField (PackedList (Value a)))
    -> [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackedList (Value a) -> [Value a]
    forall a. PackedList a -> [a]
    unPackedList (PackedList (Value a) -> [Value a])
    -> (Field n (PackedField (PackedList (Value a)))
        -> PackedList (Value a))
    -> Field n (PackedField (PackedList (Value a)))
    -> [Value a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackedField (PackedList (Value a)) -> PackedList (Value a)
    forall a. PackedField a -> a
    runPackedField (PackedField (PackedList (Value a)) -> PackedList (Value a))
    -> (Field n (PackedField (PackedList (Value a)))
        -> PackedField (PackedList (Value a)))
    -> Field n (PackedField (PackedList (Value a)))
    -> PackedList (Value a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (PackedField (PackedList (Value a)))
    -> PackedField (PackedList (Value a))
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (PackedField (PackedList (Value a))))
    -> Field n (PackedField (PackedList (Value a)))
    putField = PackedField (PackedList (Value a))
    -> Field n (PackedField (PackedList (Value a)))
    forall (n :: Nat) a. a -> Field n a
    Field (PackedField (PackedList (Value a))
     -> Field n (PackedField (PackedList (Value a))))
    -> ([a] -> PackedField (PackedList (Value a)))
    -> [a]
    -> Field n (PackedField (PackedList (Value a)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackedList (Value a) -> PackedField (PackedList (Value a))
    forall a. a -> PackedField a
    PackedField (PackedList (Value a) -> PackedField (PackedList (Value a)))
    -> ([a] -> PackedList (Value a))
    -> [a]
    -> PackedField (PackedList (Value a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Value a] -> PackedList (Value a)
    forall a. [a] -> PackedList a
    PackedList ([Value a] -> PackedList (Value a))
    -> ([a] -> [Value a]) -> [a] -> PackedList (Value a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Value a) -> [a] -> [Value a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Value a
    forall a. a -> Value a
    Value

    -- | Iso: @ 'FieldType' ('Packed' n ('Enumeration' a)) = [a] @
    instance HasField (Field n (PackedField (PackedList (Enumeration a)))) where
      type FieldType (Field n (PackedField (PackedList (Enumeration a)))) = [a]
      getField :: Field n (PackedField (PackedList (Enumeration a)))
    -> FieldType (Field n (PackedField (PackedList (Enumeration a))))
    getField = (Enumeration a -> a) -> [Enumeration a] -> [a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Enumeration a -> a
    forall a. Enumeration a -> a
    runEnumeration ([Enumeration a] -> [a])
    -> (Field n (PackedField (PackedList (Enumeration a)))
        -> [Enumeration a])
    -> Field n (PackedField (PackedList (Enumeration a)))
    -> [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackedList (Enumeration a) -> [Enumeration a]
    forall a. PackedList a -> [a]
    unPackedList (PackedList (Enumeration a) -> [Enumeration a])
    -> (Field n (PackedField (PackedList (Enumeration a)))
        -> PackedList (Enumeration a))
    -> Field n (PackedField (PackedList (Enumeration a)))
    -> [Enumeration a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackedField (PackedList (Enumeration a))
    -> PackedList (Enumeration a)
    forall a. PackedField a -> a
    runPackedField (PackedField (PackedList (Enumeration a))
     -> PackedList (Enumeration a))
    -> (Field n (PackedField (PackedList (Enumeration a)))
        -> PackedField (PackedList (Enumeration a)))
    -> Field n (PackedField (PackedList (Enumeration a)))
    -> PackedList (Enumeration a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Field n (PackedField (PackedList (Enumeration a)))
    -> PackedField (PackedList (Enumeration a))
    forall (n :: Nat) a. Field n a -> a
    runField
      putField :: FieldType (Field n (PackedField (PackedList (Enumeration a))))
    -> Field n (PackedField (PackedList (Enumeration a)))
    putField = PackedField (PackedList (Enumeration a))
    -> Field n (PackedField (PackedList (Enumeration a)))
    forall (n :: Nat) a. a -> Field n a
    Field (PackedField (PackedList (Enumeration a))
     -> Field n (PackedField (PackedList (Enumeration a))))
    -> ([a] -> PackedField (PackedList (Enumeration a)))
    -> [a]
    -> Field n (PackedField (PackedList (Enumeration a)))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PackedList (Enumeration a)
    -> PackedField (PackedList (Enumeration a))
    forall a. a -> PackedField a
    PackedField (PackedList (Enumeration a)
     -> PackedField (PackedList (Enumeration a)))
    -> ([a] -> PackedList (Enumeration a))
    -> [a]
    -> PackedField (PackedList (Enumeration a))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Enumeration a] -> PackedList (Enumeration a)
    forall a. [a] -> PackedList a
    PackedList ([Enumeration a] -> PackedList (Enumeration a))
    -> ([a] -> [Enumeration a]) -> [a] -> PackedList (Enumeration a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Enumeration a) -> [a] -> [Enumeration a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Enumeration a
    forall a. a -> Enumeration a
    Enumeration

    -- | Optional fields. Values that are not found will return 'Nothing'.
    type family Optional (n :: Nat) (a :: *) :: *
    type instance Optional n (Value a)       = Field n (OptionalField (Last (Value a)))
    type instance Optional n (Enumeration a) = Field n (OptionalField (Last (Enumeration a)))

    -- | Required fields. Parsing will return 'Control.Alternative.empty' if a 'Required' value is not found while decoding.
    type family Required (n :: Nat) (a :: *) :: *
    type instance Required n (Value a)       = Field n (RequiredField (Always (Value a)))
    type instance Required n (Enumeration a) = Field n (RequiredField (Always (Enumeration a)))

    -- | Lists of values.
    type Repeated n a = Field n (RepeatedField [a])

    -- | Packed values.
    type Packed n a = Field n (PackedField (PackedList a))

    -- |
    -- 'Enumeration' fields use 'Prelude.fromEnum' and 'Prelude.toEnum' when encoding and decoding messages.
    newtype Enumeration a = Enumeration {forall a. Enumeration a -> a
    runEnumeration :: a}
      deriving (Enumeration a
    Enumeration a -> Enumeration a -> Bounded (Enumeration a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Enumeration a
    $cminBound :: forall a. Bounded a => Enumeration a
    minBound :: Enumeration a
    $cmaxBound :: forall a. Bounded a => Enumeration a
    maxBound :: Enumeration a
    Bounded, Enumeration a -> Enumeration a -> Bool
    (Enumeration a -> Enumeration a -> Bool)
    -> (Enumeration a -> Enumeration a -> Bool) -> Eq (Enumeration a)
    forall a. Eq a => Enumeration a -> Enumeration a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Enumeration a -> Enumeration a -> Bool
    == :: Enumeration a -> Enumeration a -> Bool
    $c/= :: forall a. Eq a => Enumeration a -> Enumeration a -> Bool
    /= :: Enumeration a -> Enumeration a -> Bool
    Eq, Int -> Enumeration a
    Enumeration a -> Int
    Enumeration a -> [Enumeration a]
    Enumeration a -> Enumeration a
    Enumeration a -> Enumeration a -> [Enumeration a]
    Enumeration a -> Enumeration a -> Enumeration a -> [Enumeration a]
    (Enumeration a -> Enumeration a)
    -> (Enumeration a -> Enumeration a)
    -> (Int -> Enumeration a)
    -> (Enumeration a -> Int)
    -> (Enumeration a -> [Enumeration a])
    -> (Enumeration a -> Enumeration a -> [Enumeration a])
    -> (Enumeration a -> Enumeration a -> [Enumeration a])
    -> (Enumeration a
        -> Enumeration a -> Enumeration a -> [Enumeration a])
    -> Enum (Enumeration a)
    forall a. Enum a => Int -> Enumeration a
    forall a. Enum a => Enumeration a -> Int
    forall a. Enum a => Enumeration a -> [Enumeration a]
    forall a. Enum a => Enumeration a -> Enumeration a
    forall a.
    Enum a =>
    Enumeration a -> Enumeration a -> [Enumeration a]
    forall a.
    Enum a =>
    Enumeration a -> Enumeration a -> Enumeration a -> [Enumeration a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => Enumeration a -> Enumeration a
    succ :: Enumeration a -> Enumeration a
    $cpred :: forall a. Enum a => Enumeration a -> Enumeration a
    pred :: Enumeration a -> Enumeration a
    $ctoEnum :: forall a. Enum a => Int -> Enumeration a
    toEnum :: Int -> Enumeration a
    $cfromEnum :: forall a. Enum a => Enumeration a -> Int
    fromEnum :: Enumeration a -> Int
    $cenumFrom :: forall a. Enum a => Enumeration a -> [Enumeration a]
    enumFrom :: Enumeration a -> [Enumeration a]
    $cenumFromThen :: forall a.
    Enum a =>
    Enumeration a -> Enumeration a -> [Enumeration a]
    enumFromThen :: Enumeration a -> Enumeration a -> [Enumeration a]
    $cenumFromTo :: forall a.
    Enum a =>
    Enumeration a -> Enumeration a -> [Enumeration a]
    enumFromTo :: Enumeration a -> Enumeration a -> [Enumeration a]
    $cenumFromThenTo :: forall a.
    Enum a =>
    Enumeration a -> Enumeration a -> Enumeration a -> [Enumeration a]
    enumFromThenTo :: Enumeration a -> Enumeration a -> Enumeration a -> [Enumeration a]
    Enum, (forall m. Monoid m => Enumeration m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Enumeration a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Enumeration a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Enumeration a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Enumeration a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Enumeration a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Enumeration a -> b)
    -> (forall a. (a -> a -> a) -> Enumeration a -> a)
    -> (forall a. (a -> a -> a) -> Enumeration a -> a)
    -> (forall a. Enumeration a -> [a])
    -> (forall a. Enumeration a -> Bool)
    -> (forall a. Enumeration a -> Int)
    -> (forall a. Eq a => a -> Enumeration a -> Bool)
    -> (forall a. Ord a => Enumeration a -> a)
    -> (forall a. Ord a => Enumeration a -> a)
    -> (forall a. Num a => Enumeration a -> a)
    -> (forall a. Num a => Enumeration a -> a)
    -> Foldable Enumeration
    forall a. Eq a => a -> Enumeration a -> Bool
    forall a. Num a => Enumeration a -> a
    forall a. Ord a => Enumeration a -> a
    forall m. Monoid m => Enumeration m -> m
    forall a. Enumeration a -> Bool
    forall a. Enumeration a -> Int
    forall a. Enumeration a -> [a]
    forall a. (a -> a -> a) -> Enumeration a -> a
    forall m a. Monoid m => (a -> m) -> Enumeration a -> m
    forall b a. (b -> a -> b) -> b -> Enumeration a -> b
    forall a b. (a -> b -> b) -> b -> Enumeration a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Enumeration m -> m
    fold :: forall m. Monoid m => Enumeration m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Enumeration a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Enumeration a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Enumeration a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Enumeration a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Enumeration a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Enumeration a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Enumeration a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Enumeration a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Enumeration a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Enumeration a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Enumeration a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Enumeration a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Enumeration a -> a
    foldr1 :: forall a. (a -> a -> a) -> Enumeration a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Enumeration a -> a
    foldl1 :: forall a. (a -> a -> a) -> Enumeration a -> a
    $ctoList :: forall a. Enumeration a -> [a]
    toList :: forall a. Enumeration a -> [a]
    $cnull :: forall a. Enumeration a -> Bool
    null :: forall a. Enumeration a -> Bool
    $clength :: forall a. Enumeration a -> Int
    length :: forall a. Enumeration a -> Int
    $celem :: forall a. Eq a => a -> Enumeration a -> Bool
    elem :: forall a. Eq a => a -> Enumeration a -> Bool
    $cmaximum :: forall a. Ord a => Enumeration a -> a
    maximum :: forall a. Ord a => Enumeration a -> a
    $cminimum :: forall a. Ord a => Enumeration a -> a
    minimum :: forall a. Ord a => Enumeration a -> a
    $csum :: forall a. Num a => Enumeration a -> a
    sum :: forall a. Num a => Enumeration a -> a
    $cproduct :: forall a. Num a => Enumeration a -> a
    product :: forall a. Num a => Enumeration a -> a
    Foldable, (forall a b. (a -> b) -> Enumeration a -> Enumeration b)
    -> (forall a b. a -> Enumeration b -> Enumeration a)
    -> Functor Enumeration
    forall a b. a -> Enumeration b -> Enumeration a
    forall a b. (a -> b) -> Enumeration a -> Enumeration b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Enumeration a -> Enumeration b
    fmap :: forall a b. (a -> b) -> Enumeration a -> Enumeration b
    $c<$ :: forall a b. a -> Enumeration b -> Enumeration a
    <$ :: forall a b. a -> Enumeration b -> Enumeration a
    Functor, Eq (Enumeration a)
    Eq (Enumeration a) =>
    (Enumeration a -> Enumeration a -> Ordering)
    -> (Enumeration a -> Enumeration a -> Bool)
    -> (Enumeration a -> Enumeration a -> Bool)
    -> (Enumeration a -> Enumeration a -> Bool)
    -> (Enumeration a -> Enumeration a -> Bool)
    -> (Enumeration a -> Enumeration a -> Enumeration a)
    -> (Enumeration a -> Enumeration a -> Enumeration a)
    -> Ord (Enumeration a)
    Enumeration a -> Enumeration a -> Bool
    Enumeration a -> Enumeration a -> Ordering
    Enumeration a -> Enumeration a -> Enumeration a
    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
    forall a. Ord a => Eq (Enumeration a)
    forall a. Ord a => Enumeration a -> Enumeration a -> Bool
    forall a. Ord a => Enumeration a -> Enumeration a -> Ordering
    forall a. Ord a => Enumeration a -> Enumeration a -> Enumeration a
    $ccompare :: forall a. Ord a => Enumeration a -> Enumeration a -> Ordering
    compare :: Enumeration a -> Enumeration a -> Ordering
    $c< :: forall a. Ord a => Enumeration a -> Enumeration a -> Bool
    < :: Enumeration a -> Enumeration a -> Bool
    $c<= :: forall a. Ord a => Enumeration a -> Enumeration a -> Bool
    <= :: Enumeration a -> Enumeration a -> Bool
    $c> :: forall a. Ord a => Enumeration a -> Enumeration a -> Bool
    > :: Enumeration a -> Enumeration a -> Bool
    $c>= :: forall a. Ord a => Enumeration a -> Enumeration a -> Bool
    >= :: Enumeration a -> Enumeration a -> Bool
    $cmax :: forall a. Ord a => Enumeration a -> Enumeration a -> Enumeration a
    max :: Enumeration a -> Enumeration a -> Enumeration a
    $cmin :: forall a. Ord a => Enumeration a -> Enumeration a -> Enumeration a
    min :: Enumeration a -> Enumeration a -> Enumeration a
    Ord, NonEmpty (Enumeration a) -> Enumeration a
    Enumeration a -> Enumeration a -> Enumeration a
    (Enumeration a -> Enumeration a -> Enumeration a)
    -> (NonEmpty (Enumeration a) -> Enumeration a)
    -> (forall b. Integral b => b -> Enumeration a -> Enumeration a)
    -> Semigroup (Enumeration a)
    forall b. Integral b => b -> Enumeration a -> Enumeration a
    forall a. Semigroup a => NonEmpty (Enumeration a) -> Enumeration a
    forall a.
    Semigroup a =>
    Enumeration a -> Enumeration a -> Enumeration a
    forall a b.
    (Semigroup a, Integral b) =>
    b -> Enumeration a -> Enumeration a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a.
    Semigroup a =>
    Enumeration a -> Enumeration a -> Enumeration a
    <> :: Enumeration a -> Enumeration a -> Enumeration a
    $csconcat :: forall a. Semigroup a => NonEmpty (Enumeration a) -> Enumeration a
    sconcat :: NonEmpty (Enumeration a) -> Enumeration a
    $cstimes :: forall a b.
    (Semigroup a, Integral b) =>
    b -> Enumeration a -> Enumeration a
    stimes :: forall b. Integral b => b -> Enumeration a -> Enumeration a
    Semigroup, Semigroup (Enumeration a)
    Enumeration a
    Semigroup (Enumeration a) =>
    Enumeration a
    -> (Enumeration a -> Enumeration a -> Enumeration a)
    -> ([Enumeration a] -> Enumeration a)
    -> Monoid (Enumeration a)
    [Enumeration a] -> Enumeration a
    Enumeration a -> Enumeration a -> Enumeration a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (Enumeration a)
    forall a. Monoid a => Enumeration a
    forall a. Monoid a => [Enumeration a] -> Enumeration a
    forall a.
    Monoid a =>
    Enumeration a -> Enumeration a -> Enumeration a
    $cmempty :: forall a. Monoid a => Enumeration a
    mempty :: Enumeration a
    $cmappend :: forall a.
    Monoid a =>
    Enumeration a -> Enumeration a -> Enumeration a
    mappend :: Enumeration a -> Enumeration a -> Enumeration a
    $cmconcat :: forall a. Monoid a => [Enumeration a] -> Enumeration a
    mconcat :: [Enumeration a] -> Enumeration a
    Monoid, Enumeration a -> ()
    (Enumeration a -> ()) -> NFData (Enumeration a)
    forall a. NFData a => Enumeration a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => Enumeration a -> ()
    rnf :: Enumeration a -> ()
    NFData, Int -> Enumeration a -> ShowS
    [Enumeration a] -> ShowS
    Enumeration a -> String
    (Int -> Enumeration a -> ShowS)
    -> (Enumeration a -> String)
    -> ([Enumeration a] -> ShowS)
    -> Show (Enumeration a)
    forall a. Show a => Int -> Enumeration a -> ShowS
    forall a. Show a => [Enumeration a] -> ShowS
    forall a. Show a => Enumeration a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Enumeration a -> ShowS
    showsPrec :: Int -> Enumeration a -> ShowS
    $cshow :: forall a. Show a => Enumeration a -> String
    show :: Enumeration a -> String
    $cshowList :: forall a. Show a => [Enumeration a] -> ShowS
    showList :: [Enumeration a] -> ShowS
    Show, Functor Enumeration
    Foldable Enumeration
    (Functor Enumeration, Foldable Enumeration) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Enumeration a -> f (Enumeration b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Enumeration (f a) -> f (Enumeration a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Enumeration a -> m (Enumeration b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Enumeration (m a) -> m (Enumeration a))
    -> Traversable Enumeration
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    Enumeration (m a) -> m (Enumeration a)
    forall (f :: * -> *) a.
    Applicative f =>
    Enumeration (f a) -> f (Enumeration a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Enumeration a -> m (Enumeration b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Enumeration a -> f (Enumeration b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Enumeration a -> f (Enumeration b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Enumeration a -> f (Enumeration b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Enumeration (f a) -> f (Enumeration a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Enumeration (f a) -> f (Enumeration a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Enumeration a -> m (Enumeration b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Enumeration a -> m (Enumeration b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    Enumeration (m a) -> m (Enumeration a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    Enumeration (m a) -> m (Enumeration a)
    Traversable, Typeable)

    -- |
    -- A 'Traversable' 'Functor' used to select packed sequence encoding/decoding.
    newtype PackedField a = PackedField {forall a. PackedField a -> a
    runPackedField :: a}
      deriving (PackedField a -> PackedField a -> Bool
    (PackedField a -> PackedField a -> Bool)
    -> (PackedField a -> PackedField a -> Bool) -> Eq (PackedField a)
    forall a. Eq a => PackedField a -> PackedField a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => PackedField a -> PackedField a -> Bool
    == :: PackedField a -> PackedField a -> Bool
    $c/= :: forall a. Eq a => PackedField a -> PackedField a -> Bool
    /= :: PackedField a -> PackedField a -> Bool
    Eq, (forall m. Monoid m => PackedField m -> m)
    -> (forall m a. Monoid m => (a -> m) -> PackedField a -> m)
    -> (forall m a. Monoid m => (a -> m) -> PackedField a -> m)
    -> (forall a b. (a -> b -> b) -> b -> PackedField a -> b)
    -> (forall a b. (a -> b -> b) -> b -> PackedField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PackedField a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PackedField a -> b)
    -> (forall a. (a -> a -> a) -> PackedField a -> a)
    -> (forall a. (a -> a -> a) -> PackedField a -> a)
    -> (forall a. PackedField a -> [a])
    -> (forall a. PackedField a -> Bool)
    -> (forall a. PackedField a -> Int)
    -> (forall a. Eq a => a -> PackedField a -> Bool)
    -> (forall a. Ord a => PackedField a -> a)
    -> (forall a. Ord a => PackedField a -> a)
    -> (forall a. Num a => PackedField a -> a)
    -> (forall a. Num a => PackedField a -> a)
    -> Foldable PackedField
    forall a. Eq a => a -> PackedField a -> Bool
    forall a. Num a => PackedField a -> a
    forall a. Ord a => PackedField a -> a
    forall m. Monoid m => PackedField m -> m
    forall a. PackedField a -> Bool
    forall a. PackedField a -> Int
    forall a. PackedField a -> [a]
    forall a. (a -> a -> a) -> PackedField a -> a
    forall m a. Monoid m => (a -> m) -> PackedField a -> m
    forall b a. (b -> a -> b) -> b -> PackedField a -> b
    forall a b. (a -> b -> b) -> b -> PackedField a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => PackedField m -> m
    fold :: forall m. Monoid m => PackedField m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> PackedField a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> PackedField a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> PackedField a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> PackedField a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> PackedField a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> PackedField a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> PackedField a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> PackedField a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> PackedField a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> PackedField a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> PackedField a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> PackedField a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> PackedField a -> a
    foldr1 :: forall a. (a -> a -> a) -> PackedField a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> PackedField a -> a
    foldl1 :: forall a. (a -> a -> a) -> PackedField a -> a
    $ctoList :: forall a. PackedField a -> [a]
    toList :: forall a. PackedField a -> [a]
    $cnull :: forall a. PackedField a -> Bool
    null :: forall a. PackedField a -> Bool
    $clength :: forall a. PackedField a -> Int
    length :: forall a. PackedField a -> Int
    $celem :: forall a. Eq a => a -> PackedField a -> Bool
    elem :: forall a. Eq a => a -> PackedField a -> Bool
    $cmaximum :: forall a. Ord a => PackedField a -> a
    maximum :: forall a. Ord a => PackedField a -> a
    $cminimum :: forall a. Ord a => PackedField a -> a
    minimum :: forall a. Ord a => PackedField a -> a
    $csum :: forall a. Num a => PackedField a -> a
    sum :: forall a. Num a => PackedField a -> a
    $cproduct :: forall a. Num a => PackedField a -> a
    product :: forall a. Num a => PackedField a -> a
    Foldable, (forall a b. (a -> b) -> PackedField a -> PackedField b)
    -> (forall a b. a -> PackedField b -> PackedField a)
    -> Functor PackedField
    forall a b. a -> PackedField b -> PackedField a
    forall a b. (a -> b) -> PackedField a -> PackedField b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> PackedField a -> PackedField b
    fmap :: forall a b. (a -> b) -> PackedField a -> PackedField b
    $c<$ :: forall a b. a -> PackedField b -> PackedField a
    <$ :: forall a b. a -> PackedField b -> PackedField a
    Functor, NonEmpty (PackedField a) -> PackedField a
    PackedField a -> PackedField a -> PackedField a
    (PackedField a -> PackedField a -> PackedField a)
    -> (NonEmpty (PackedField a) -> PackedField a)
    -> (forall b. Integral b => b -> PackedField a -> PackedField a)
    -> Semigroup (PackedField a)
    forall b. Integral b => b -> PackedField a -> PackedField a
    forall a. Semigroup a => NonEmpty (PackedField a) -> PackedField a
    forall a.
    Semigroup a =>
    PackedField a -> PackedField a -> PackedField a
    forall a b.
    (Semigroup a, Integral b) =>
    b -> PackedField a -> PackedField a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a.
    Semigroup a =>
    PackedField a -> PackedField a -> PackedField a
    <> :: PackedField a -> PackedField a -> PackedField a
    $csconcat :: forall a. Semigroup a => NonEmpty (PackedField a) -> PackedField a
    sconcat :: NonEmpty (PackedField a) -> PackedField a
    $cstimes :: forall a b.
    (Semigroup a, Integral b) =>
    b -> PackedField a -> PackedField a
    stimes :: forall b. Integral b => b -> PackedField a -> PackedField a
    Semigroup, Semigroup (PackedField a)
    PackedField a
    Semigroup (PackedField a) =>
    PackedField a
    -> (PackedField a -> PackedField a -> PackedField a)
    -> ([PackedField a] -> PackedField a)
    -> Monoid (PackedField a)
    [PackedField a] -> PackedField a
    PackedField a -> PackedField a -> PackedField a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (PackedField a)
    forall a. Monoid a => PackedField a
    forall a. Monoid a => [PackedField a] -> PackedField a
    forall a.
    Monoid a =>
    PackedField a -> PackedField a -> PackedField a
    $cmempty :: forall a. Monoid a => PackedField a
    mempty :: PackedField a
    $cmappend :: forall a.
    Monoid a =>
    PackedField a -> PackedField a -> PackedField a
    mappend :: PackedField a -> PackedField a -> PackedField a
    $cmconcat :: forall a. Monoid a => [PackedField a] -> PackedField a
    mconcat :: [PackedField a] -> PackedField a
    Monoid, PackedField a -> ()
    (PackedField a -> ()) -> NFData (PackedField a)
    forall a. NFData a => PackedField a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => PackedField a -> ()
    rnf :: PackedField a -> ()
    NFData, Eq (PackedField a)
    Eq (PackedField a) =>
    (PackedField a -> PackedField a -> Ordering)
    -> (PackedField a -> PackedField a -> Bool)
    -> (PackedField a -> PackedField a -> Bool)
    -> (PackedField a -> PackedField a -> Bool)
    -> (PackedField a -> PackedField a -> Bool)
    -> (PackedField a -> PackedField a -> PackedField a)
    -> (PackedField a -> PackedField a -> PackedField a)
    -> Ord (PackedField a)
    PackedField a -> PackedField a -> Bool
    PackedField a -> PackedField a -> Ordering
    PackedField a -> PackedField a -> PackedField a
    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
    forall a. Ord a => Eq (PackedField a)
    forall a. Ord a => PackedField a -> PackedField a -> Bool
    forall a. Ord a => PackedField a -> PackedField a -> Ordering
    forall a. Ord a => PackedField a -> PackedField a -> PackedField a
    $ccompare :: forall a. Ord a => PackedField a -> PackedField a -> Ordering
    compare :: PackedField a -> PackedField a -> Ordering
    $c< :: forall a. Ord a => PackedField a -> PackedField a -> Bool
    < :: PackedField a -> PackedField a -> Bool
    $c<= :: forall a. Ord a => PackedField a -> PackedField a -> Bool
    <= :: PackedField a -> PackedField a -> Bool
    $c> :: forall a. Ord a => PackedField a -> PackedField a -> Bool
    > :: PackedField a -> PackedField a -> Bool
    $c>= :: forall a. Ord a => PackedField a -> PackedField a -> Bool
    >= :: PackedField a -> PackedField a -> Bool
    $cmax :: forall a. Ord a => PackedField a -> PackedField a -> PackedField a
    max :: PackedField a -> PackedField a -> PackedField a
    $cmin :: forall a. Ord a => PackedField a -> PackedField a -> PackedField a
    min :: PackedField a -> PackedField a -> PackedField a
    Ord, Int -> PackedField a -> ShowS
    [PackedField a] -> ShowS
    PackedField a -> String
    (Int -> PackedField a -> ShowS)
    -> (PackedField a -> String)
    -> ([PackedField a] -> ShowS)
    -> Show (PackedField a)
    forall a. Show a => Int -> PackedField a -> ShowS
    forall a. Show a => [PackedField a] -> ShowS
    forall a. Show a => PackedField a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> PackedField a -> ShowS
    showsPrec :: Int -> PackedField a -> ShowS
    $cshow :: forall a. Show a => PackedField a -> String
    show :: PackedField a -> String
    $cshowList :: forall a. Show a => [PackedField a] -> ShowS
    showList :: [PackedField a] -> ShowS
    Show, Functor PackedField
    Foldable PackedField
    (Functor PackedField, Foldable PackedField) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> PackedField a -> f (PackedField b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        PackedField (f a) -> f (PackedField a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> PackedField a -> m (PackedField b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        PackedField (m a) -> m (PackedField a))
    -> Traversable PackedField
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    PackedField (m a) -> m (PackedField a)
    forall (f :: * -> *) a.
    Applicative f =>
    PackedField (f a) -> f (PackedField a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PackedField a -> m (PackedField b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PackedField a -> f (PackedField b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PackedField a -> f (PackedField b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PackedField a -> f (PackedField b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PackedField (f a) -> f (PackedField a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PackedField (f a) -> f (PackedField a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PackedField a -> m (PackedField b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PackedField a -> m (PackedField b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    PackedField (m a) -> m (PackedField a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    PackedField (m a) -> m (PackedField a)
    Traversable, Typeable)

    -- |
    -- A list that is stored in a packed format.
    newtype PackedList a = PackedList {forall a. PackedList a -> [a]
    unPackedList :: [a]}
      deriving (PackedList a -> PackedList a -> Bool
    (PackedList a -> PackedList a -> Bool)
    -> (PackedList a -> PackedList a -> Bool) -> Eq (PackedList a)
    forall a. Eq a => PackedList a -> PackedList a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => PackedList a -> PackedList a -> Bool
    == :: PackedList a -> PackedList a -> Bool
    $c/= :: forall a. Eq a => PackedList a -> PackedList a -> Bool
    /= :: PackedList a -> PackedList a -> Bool
    Eq, (forall m. Monoid m => PackedList m -> m)
    -> (forall m a. Monoid m => (a -> m) -> PackedList a -> m)
    -> (forall m a. Monoid m => (a -> m) -> PackedList a -> m)
    -> (forall a b. (a -> b -> b) -> b -> PackedList a -> b)
    -> (forall a b. (a -> b -> b) -> b -> PackedList a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PackedList a -> b)
    -> (forall b a. (b -> a -> b) -> b -> PackedList a -> b)
    -> (forall a. (a -> a -> a) -> PackedList a -> a)
    -> (forall a. (a -> a -> a) -> PackedList a -> a)
    -> (forall a. PackedList a -> [a])
    -> (forall a. PackedList a -> Bool)
    -> (forall a. PackedList a -> Int)
    -> (forall a. Eq a => a -> PackedList a -> Bool)
    -> (forall a. Ord a => PackedList a -> a)
    -> (forall a. Ord a => PackedList a -> a)
    -> (forall a. Num a => PackedList a -> a)
    -> (forall a. Num a => PackedList a -> a)
    -> Foldable PackedList
    forall a. Eq a => a -> PackedList a -> Bool
    forall a. Num a => PackedList a -> a
    forall a. Ord a => PackedList a -> a
    forall m. Monoid m => PackedList m -> m
    forall a. PackedList a -> Bool
    forall a. PackedList a -> Int
    forall a. PackedList a -> [a]
    forall a. (a -> a -> a) -> PackedList a -> a
    forall m a. Monoid m => (a -> m) -> PackedList a -> m
    forall b a. (b -> a -> b) -> b -> PackedList a -> b
    forall a b. (a -> b -> b) -> b -> PackedList a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => PackedList m -> m
    fold :: forall m. Monoid m => PackedList m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> PackedList a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> PackedList a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> PackedList a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> PackedList a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> PackedList a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> PackedList a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> PackedList a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> PackedList a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> PackedList a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> PackedList a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> PackedList a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> PackedList a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> PackedList a -> a
    foldr1 :: forall a. (a -> a -> a) -> PackedList a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> PackedList a -> a
    foldl1 :: forall a. (a -> a -> a) -> PackedList a -> a
    $ctoList :: forall a. PackedList a -> [a]
    toList :: forall a. PackedList a -> [a]
    $cnull :: forall a. PackedList a -> Bool
    null :: forall a. PackedList a -> Bool
    $clength :: forall a. PackedList a -> Int
    length :: forall a. PackedList a -> Int
    $celem :: forall a. Eq a => a -> PackedList a -> Bool
    elem :: forall a. Eq a => a -> PackedList a -> Bool
    $cmaximum :: forall a. Ord a => PackedList a -> a
    maximum :: forall a. Ord a => PackedList a -> a
    $cminimum :: forall a. Ord a => PackedList a -> a
    minimum :: forall a. Ord a => PackedList a -> a
    $csum :: forall a. Num a => PackedList a -> a
    sum :: forall a. Num a => PackedList a -> a
    $cproduct :: forall a. Num a => PackedList a -> a
    product :: forall a. Num a => PackedList a -> a
    Foldable, (forall a b. (a -> b) -> PackedList a -> PackedList b)
    -> (forall a b. a -> PackedList b -> PackedList a)
    -> Functor PackedList
    forall a b. a -> PackedList b -> PackedList a
    forall a b. (a -> b) -> PackedList a -> PackedList b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> PackedList a -> PackedList b
    fmap :: forall a b. (a -> b) -> PackedList a -> PackedList b
    $c<$ :: forall a b. a -> PackedList b -> PackedList a
    <$ :: forall a b. a -> PackedList b -> PackedList a
    Functor, NonEmpty (PackedList a) -> PackedList a
    PackedList a -> PackedList a -> PackedList a
    (PackedList a -> PackedList a -> PackedList a)
    -> (NonEmpty (PackedList a) -> PackedList a)
    -> (forall b. Integral b => b -> PackedList a -> PackedList a)
    -> Semigroup (PackedList a)
    forall b. Integral b => b -> PackedList a -> PackedList a
    forall a. NonEmpty (PackedList a) -> PackedList a
    forall a. PackedList a -> PackedList a -> PackedList a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    forall a b. Integral b => b -> PackedList a -> PackedList a
    $c<> :: forall a. PackedList a -> PackedList a -> PackedList a
    <> :: PackedList a -> PackedList a -> PackedList a
    $csconcat :: forall a. NonEmpty (PackedList a) -> PackedList a
    sconcat :: NonEmpty (PackedList a) -> PackedList a
    $cstimes :: forall a b. Integral b => b -> PackedList a -> PackedList a
    stimes :: forall b. Integral b => b -> PackedList a -> PackedList a
    Semigroup, Semigroup (PackedList a)
    PackedList a
    Semigroup (PackedList a) =>
    PackedList a
    -> (PackedList a -> PackedList a -> PackedList a)
    -> ([PackedList a] -> PackedList a)
    -> Monoid (PackedList a)
    [PackedList a] -> PackedList a
    PackedList a -> PackedList a -> PackedList a
    forall a. Semigroup (PackedList a)
    forall a. PackedList a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. [PackedList a] -> PackedList a
    forall a. PackedList a -> PackedList a -> PackedList a
    $cmempty :: forall a. PackedList a
    mempty :: PackedList a
    $cmappend :: forall a. PackedList a -> PackedList a -> PackedList a
    mappend :: PackedList a -> PackedList a -> PackedList a
    $cmconcat :: forall a. [PackedList a] -> PackedList a
    mconcat :: [PackedList a] -> PackedList a
    Monoid, PackedList a -> ()
    (PackedList a -> ()) -> NFData (PackedList a)
    forall a. NFData a => PackedList a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => PackedList a -> ()
    rnf :: PackedList a -> ()
    NFData, Eq (PackedList a)
    Eq (PackedList a) =>
    (PackedList a -> PackedList a -> Ordering)
    -> (PackedList a -> PackedList a -> Bool)
    -> (PackedList a -> PackedList a -> Bool)
    -> (PackedList a -> PackedList a -> Bool)
    -> (PackedList a -> PackedList a -> Bool)
    -> (PackedList a -> PackedList a -> PackedList a)
    -> (PackedList a -> PackedList a -> PackedList a)
    -> Ord (PackedList a)
    PackedList a -> PackedList a -> Bool
    PackedList a -> PackedList a -> Ordering
    PackedList a -> PackedList a -> PackedList a
    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
    forall a. Ord a => Eq (PackedList a)
    forall a. Ord a => PackedList a -> PackedList a -> Bool
    forall a. Ord a => PackedList a -> PackedList a -> Ordering
    forall a. Ord a => PackedList a -> PackedList a -> PackedList a
    $ccompare :: forall a. Ord a => PackedList a -> PackedList a -> Ordering
    compare :: PackedList a -> PackedList a -> Ordering
    $c< :: forall a. Ord a => PackedList a -> PackedList a -> Bool
    < :: PackedList a -> PackedList a -> Bool
    $c<= :: forall a. Ord a => PackedList a -> PackedList a -> Bool
    <= :: PackedList a -> PackedList a -> Bool
    $c> :: forall a. Ord a => PackedList a -> PackedList a -> Bool
    > :: PackedList a -> PackedList a -> Bool
    $c>= :: forall a. Ord a => PackedList a -> PackedList a -> Bool
    >= :: PackedList a -> PackedList a -> Bool
    $cmax :: forall a. Ord a => PackedList a -> PackedList a -> PackedList a
    max :: PackedList a -> PackedList a -> PackedList a
    $cmin :: forall a. Ord a => PackedList a -> PackedList a -> PackedList a
    min :: PackedList a -> PackedList a -> PackedList a
    Ord, Int -> PackedList a -> ShowS
    [PackedList a] -> ShowS
    PackedList a -> String
    (Int -> PackedList a -> ShowS)
    -> (PackedList a -> String)
    -> ([PackedList a] -> ShowS)
    -> Show (PackedList a)
    forall a. Show a => Int -> PackedList a -> ShowS
    forall a. Show a => [PackedList a] -> ShowS
    forall a. Show a => PackedList a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> PackedList a -> ShowS
    showsPrec :: Int -> PackedList a -> ShowS
    $cshow :: forall a. Show a => PackedList a -> String
    show :: PackedList a -> String
    $cshowList :: forall a. Show a => [PackedList a] -> ShowS
    showList :: [PackedList a] -> ShowS
    Show, Functor PackedList
    Foldable PackedList
    (Functor PackedList, Foldable PackedList) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> PackedList a -> f (PackedList b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        PackedList (f a) -> f (PackedList a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> PackedList a -> m (PackedList b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        PackedList (m a) -> m (PackedList a))
    -> Traversable PackedList
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    PackedList (m a) -> m (PackedList a)
    forall (f :: * -> *) a.
    Applicative f =>
    PackedList (f a) -> f (PackedList a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PackedList a -> m (PackedList b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PackedList a -> f (PackedList b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PackedList a -> f (PackedList b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PackedList a -> f (PackedList b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PackedList (f a) -> f (PackedList a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    PackedList (f a) -> f (PackedList a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PackedList a -> m (PackedList b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PackedList a -> m (PackedList b)
    $csequence :: forall (m :: * -> *) a.
    Monad m =>
    PackedList (m a) -> m (PackedList a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    PackedList (m a) -> m (PackedList a)
    Traversable, Typeable)

    -- |
    -- Signed integers are stored in a zz-encoded form.
    newtype Signed a = Signed a
      deriving (Eq (Signed a)
    Signed a
    Eq (Signed a) =>
    (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> Signed a
    -> (Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Bool)
    -> (Signed a -> Maybe Int)
    -> (Signed a -> Int)
    -> (Signed a -> Bool)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int -> Signed a)
    -> (Signed a -> Int)
    -> Bits (Signed a)
    Int -> Signed a
    Signed a -> Bool
    Signed a -> Int
    Signed a -> Maybe Int
    Signed a -> Signed a
    Signed a -> Int -> Bool
    Signed a -> Int -> Signed a
    Signed a -> Signed a -> Signed a
    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
    forall a. Bits a => Eq (Signed a)
    forall a. Bits a => Signed a
    forall a. Bits a => Int -> Signed a
    forall a. Bits a => Signed a -> Bool
    forall a. Bits a => Signed a -> Int
    forall a. Bits a => Signed a -> Maybe Int
    forall a. Bits a => Signed a -> Signed a
    forall a. Bits a => Signed a -> Int -> Bool
    forall a. Bits a => Signed a -> Int -> Signed a
    forall a. Bits a => Signed a -> Signed a -> Signed a
    $c.&. :: forall a. Bits a => Signed a -> Signed a -> Signed a
    .&. :: Signed a -> Signed a -> Signed a
    $c.|. :: forall a. Bits a => Signed a -> Signed a -> Signed a
    .|. :: Signed a -> Signed a -> Signed a
    $cxor :: forall a. Bits a => Signed a -> Signed a -> Signed a
    xor :: Signed a -> Signed a -> Signed a
    $ccomplement :: forall a. Bits a => Signed a -> Signed a
    complement :: Signed a -> Signed a
    $cshift :: forall a. Bits a => Signed a -> Int -> Signed a
    shift :: Signed a -> Int -> Signed a
    $crotate :: forall a. Bits a => Signed a -> Int -> Signed a
    rotate :: Signed a -> Int -> Signed a
    $czeroBits :: forall a. Bits a => Signed a
    zeroBits :: Signed a
    $cbit :: forall a. Bits a => Int -> Signed a
    bit :: Int -> Signed a
    $csetBit :: forall a. Bits a => Signed a -> Int -> Signed a
    setBit :: Signed a -> Int -> Signed a
    $cclearBit :: forall a. Bits a => Signed a -> Int -> Signed a
    clearBit :: Signed a -> Int -> Signed a
    $ccomplementBit :: forall a. Bits a => Signed a -> Int -> Signed a
    complementBit :: Signed a -> Int -> Signed a
    $ctestBit :: forall a. Bits a => Signed a -> Int -> Bool
    testBit :: Signed a -> Int -> Bool
    $cbitSizeMaybe :: forall a. Bits a => Signed a -> Maybe Int
    bitSizeMaybe :: Signed a -> Maybe Int
    $cbitSize :: forall a. Bits a => Signed a -> Int
    bitSize :: Signed a -> Int
    $cisSigned :: forall a. Bits a => Signed a -> Bool
    isSigned :: Signed a -> Bool
    $cshiftL :: forall a. Bits a => Signed a -> Int -> Signed a
    shiftL :: Signed a -> Int -> Signed a
    $cunsafeShiftL :: forall a. Bits a => Signed a -> Int -> Signed a
    unsafeShiftL :: Signed a -> Int -> Signed a
    $cshiftR :: forall a. Bits a => Signed a -> Int -> Signed a
    shiftR :: Signed a -> Int -> Signed a
    $cunsafeShiftR :: forall a. Bits a => Signed a -> Int -> Signed a
    unsafeShiftR :: Signed a -> Int -> Signed a
    $crotateL :: forall a. Bits a => Signed a -> Int -> Signed a
    rotateL :: Signed a -> Int -> Signed a
    $crotateR :: forall a. Bits a => Signed a -> Int -> Signed a
    rotateR :: Signed a -> Int -> Signed a
    $cpopCount :: forall a. Bits a => Signed a -> Int
    popCount :: Signed a -> Int
    Bits, Signed a
    Signed a -> Signed a -> Bounded (Signed a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Signed a
    $cminBound :: forall a. Bounded a => Signed a
    minBound :: Signed a
    $cmaxBound :: forall a. Bounded a => Signed a
    maxBound :: Signed a
    Bounded, Int -> Signed a
    Signed a -> Int
    Signed a -> [Signed a]
    Signed a -> Signed a
    Signed a -> Signed a -> [Signed a]
    Signed a -> Signed a -> Signed a -> [Signed a]
    (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Int -> Signed a)
    -> (Signed a -> Int)
    -> (Signed a -> [Signed a])
    -> (Signed a -> Signed a -> [Signed a])
    -> (Signed a -> Signed a -> [Signed a])
    -> (Signed a -> Signed a -> Signed a -> [Signed a])
    -> Enum (Signed a)
    forall a. Enum a => Int -> Signed a
    forall a. Enum a => Signed a -> Int
    forall a. Enum a => Signed a -> [Signed a]
    forall a. Enum a => Signed a -> Signed a
    forall a. Enum a => Signed a -> Signed a -> [Signed a]
    forall a. Enum a => Signed a -> Signed a -> Signed a -> [Signed a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => Signed a -> Signed a
    succ :: Signed a -> Signed a
    $cpred :: forall a. Enum a => Signed a -> Signed a
    pred :: Signed a -> Signed a
    $ctoEnum :: forall a. Enum a => Int -> Signed a
    toEnum :: Int -> Signed a
    $cfromEnum :: forall a. Enum a => Signed a -> Int
    fromEnum :: Signed a -> Int
    $cenumFrom :: forall a. Enum a => Signed a -> [Signed a]
    enumFrom :: Signed a -> [Signed a]
    $cenumFromThen :: forall a. Enum a => Signed a -> Signed a -> [Signed a]
    enumFromThen :: Signed a -> Signed a -> [Signed a]
    $cenumFromTo :: forall a. Enum a => Signed a -> Signed a -> [Signed a]
    enumFromTo :: Signed a -> Signed a -> [Signed a]
    $cenumFromThenTo :: forall a. Enum a => Signed a -> Signed a -> Signed a -> [Signed a]
    enumFromThenTo :: Signed a -> Signed a -> Signed a -> [Signed a]
    Enum, Signed a -> Signed a -> Bool
    (Signed a -> Signed a -> Bool)
    -> (Signed a -> Signed a -> Bool) -> Eq (Signed a)
    forall a. Eq a => Signed a -> Signed a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Signed a -> Signed a -> Bool
    == :: Signed a -> Signed a -> Bool
    $c/= :: forall a. Eq a => Signed a -> Signed a -> Bool
    /= :: Signed a -> Signed a -> Bool
    Eq, Fractional (Signed a)
    Signed a
    Fractional (Signed a) =>
    Signed a
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> Floating (Signed a)
    Signed a -> Signed a
    Signed a -> Signed a -> Signed a
    forall a. Floating a => Fractional (Signed a)
    forall a. Floating a => Signed a
    forall a. Floating a => Signed a -> Signed a
    forall a. Floating a => Signed a -> Signed a -> Signed a
    forall a.
    Fractional a =>
    a
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> Floating a
    $cpi :: forall a. Floating a => Signed a
    pi :: Signed a
    $cexp :: forall a. Floating a => Signed a -> Signed a
    exp :: Signed a -> Signed a
    $clog :: forall a. Floating a => Signed a -> Signed a
    log :: Signed a -> Signed a
    $csqrt :: forall a. Floating a => Signed a -> Signed a
    sqrt :: Signed a -> Signed a
    $c** :: forall a. Floating a => Signed a -> Signed a -> Signed a
    ** :: Signed a -> Signed a -> Signed a
    $clogBase :: forall a. Floating a => Signed a -> Signed a -> Signed a
    logBase :: Signed a -> Signed a -> Signed a
    $csin :: forall a. Floating a => Signed a -> Signed a
    sin :: Signed a -> Signed a
    $ccos :: forall a. Floating a => Signed a -> Signed a
    cos :: Signed a -> Signed a
    $ctan :: forall a. Floating a => Signed a -> Signed a
    tan :: Signed a -> Signed a
    $casin :: forall a. Floating a => Signed a -> Signed a
    asin :: Signed a -> Signed a
    $cacos :: forall a. Floating a => Signed a -> Signed a
    acos :: Signed a -> Signed a
    $catan :: forall a. Floating a => Signed a -> Signed a
    atan :: Signed a -> Signed a
    $csinh :: forall a. Floating a => Signed a -> Signed a
    sinh :: Signed a -> Signed a
    $ccosh :: forall a. Floating a => Signed a -> Signed a
    cosh :: Signed a -> Signed a
    $ctanh :: forall a. Floating a => Signed a -> Signed a
    tanh :: Signed a -> Signed a
    $casinh :: forall a. Floating a => Signed a -> Signed a
    asinh :: Signed a -> Signed a
    $cacosh :: forall a. Floating a => Signed a -> Signed a
    acosh :: Signed a -> Signed a
    $catanh :: forall a. Floating a => Signed a -> Signed a
    atanh :: Signed a -> Signed a
    $clog1p :: forall a. Floating a => Signed a -> Signed a
    log1p :: Signed a -> Signed a
    $cexpm1 :: forall a. Floating a => Signed a -> Signed a
    expm1 :: Signed a -> Signed a
    $clog1pexp :: forall a. Floating a => Signed a -> Signed a
    log1pexp :: Signed a -> Signed a
    $clog1mexp :: forall a. Floating a => Signed a -> Signed a
    log1mexp :: Signed a -> Signed a
    Floating, (forall m. Monoid m => Signed m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Signed a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Signed a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Signed a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Signed a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Signed a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Signed a -> b)
    -> (forall a. (a -> a -> a) -> Signed a -> a)
    -> (forall a. (a -> a -> a) -> Signed a -> a)
    -> (forall a. Signed a -> [a])
    -> (forall a. Signed a -> Bool)
    -> (forall a. Signed a -> Int)
    -> (forall a. Eq a => a -> Signed a -> Bool)
    -> (forall a. Ord a => Signed a -> a)
    -> (forall a. Ord a => Signed a -> a)
    -> (forall a. Num a => Signed a -> a)
    -> (forall a. Num a => Signed a -> a)
    -> Foldable Signed
    forall a. Eq a => a -> Signed a -> Bool
    forall a. Num a => Signed a -> a
    forall a. Ord a => Signed a -> a
    forall m. Monoid m => Signed m -> m
    forall a. Signed a -> Bool
    forall a. Signed a -> Int
    forall a. Signed a -> [a]
    forall a. (a -> a -> a) -> Signed a -> a
    forall m a. Monoid m => (a -> m) -> Signed a -> m
    forall b a. (b -> a -> b) -> b -> Signed a -> b
    forall a b. (a -> b -> b) -> b -> Signed a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Signed m -> m
    fold :: forall m. Monoid m => Signed m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Signed a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Signed a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Signed a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Signed a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Signed a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Signed a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Signed a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Signed a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Signed a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Signed a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Signed a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Signed a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Signed a -> a
    foldr1 :: forall a. (a -> a -> a) -> Signed a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Signed a -> a
    foldl1 :: forall a. (a -> a -> a) -> Signed a -> a
    $ctoList :: forall a. Signed a -> [a]
    toList :: forall a. Signed a -> [a]
    $cnull :: forall a. Signed a -> Bool
    null :: forall a. Signed a -> Bool
    $clength :: forall a. Signed a -> Int
    length :: forall a. Signed a -> Int
    $celem :: forall a. Eq a => a -> Signed a -> Bool
    elem :: forall a. Eq a => a -> Signed a -> Bool
    $cmaximum :: forall a. Ord a => Signed a -> a
    maximum :: forall a. Ord a => Signed a -> a
    $cminimum :: forall a. Ord a => Signed a -> a
    minimum :: forall a. Ord a => Signed a -> a
    $csum :: forall a. Num a => Signed a -> a
    sum :: forall a. Num a => Signed a -> a
    $cproduct :: forall a. Num a => Signed a -> a
    product :: forall a. Num a => Signed a -> a
    Foldable, Num (Signed a)
    Num (Signed a) =>
    (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Rational -> Signed a)
    -> Fractional (Signed a)
    Rational -> Signed a
    Signed a -> Signed a
    Signed a -> Signed a -> Signed a
    forall a. Fractional a => Num (Signed a)
    forall a. Fractional a => Rational -> Signed a
    forall a. Fractional a => Signed a -> Signed a
    forall a. Fractional a => Signed a -> Signed a -> Signed a
    forall a.
    Num a =>
    (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
    $c/ :: forall a. Fractional a => Signed a -> Signed a -> Signed a
    / :: Signed a -> Signed a -> Signed a
    $crecip :: forall a. Fractional a => Signed a -> Signed a
    recip :: Signed a -> Signed a
    $cfromRational :: forall a. Fractional a => Rational -> Signed a
    fromRational :: Rational -> Signed a
    Fractional, (forall a b. (a -> b) -> Signed a -> Signed b)
    -> (forall a b. a -> Signed b -> Signed a) -> Functor Signed
    forall a b. a -> Signed b -> Signed a
    forall a b. (a -> b) -> Signed a -> Signed b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Signed a -> Signed b
    fmap :: forall a b. (a -> b) -> Signed a -> Signed b
    $c<$ :: forall a b. a -> Signed b -> Signed a
    <$ :: forall a b. a -> Signed b -> Signed a
    Functor, Enum (Signed a)
    Real (Signed a)
    (Real (Signed a), Enum (Signed a)) =>
    (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> (Signed a, Signed a))
    -> (Signed a -> Signed a -> (Signed a, Signed a))
    -> (Signed a -> Integer)
    -> Integral (Signed a)
    Signed a -> Integer
    Signed a -> Signed a -> (Signed a, Signed a)
    Signed a -> Signed a -> Signed a
    forall a. Integral a => Enum (Signed a)
    forall a. Integral a => Real (Signed a)
    forall a. Integral a => Signed a -> Integer
    forall a.
    Integral a =>
    Signed a -> Signed a -> (Signed a, Signed a)
    forall a. Integral a => Signed a -> Signed a -> Signed a
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: forall a. Integral a => Signed a -> Signed a -> Signed a
    quot :: Signed a -> Signed a -> Signed a
    $crem :: forall a. Integral a => Signed a -> Signed a -> Signed a
    rem :: Signed a -> Signed a -> Signed a
    $cdiv :: forall a. Integral a => Signed a -> Signed a -> Signed a
    div :: Signed a -> Signed a -> Signed a
    $cmod :: forall a. Integral a => Signed a -> Signed a -> Signed a
    mod :: Signed a -> Signed a -> Signed a
    $cquotRem :: forall a.
    Integral a =>
    Signed a -> Signed a -> (Signed a, Signed a)
    quotRem :: Signed a -> Signed a -> (Signed a, Signed a)
    $cdivMod :: forall a.
    Integral a =>
    Signed a -> Signed a -> (Signed a, Signed a)
    divMod :: Signed a -> Signed a -> (Signed a, Signed a)
    $ctoInteger :: forall a. Integral a => Signed a -> Integer
    toInteger :: Signed a -> Integer
    Integral, NonEmpty (Signed a) -> Signed a
    Signed a -> Signed a -> Signed a
    (Signed a -> Signed a -> Signed a)
    -> (NonEmpty (Signed a) -> Signed a)
    -> (forall b. Integral b => b -> Signed a -> Signed a)
    -> Semigroup (Signed a)
    forall b. Integral b => b -> Signed a -> Signed a
    forall a. Semigroup a => NonEmpty (Signed a) -> Signed a
    forall a. Semigroup a => Signed a -> Signed a -> Signed a
    forall a b. (Semigroup a, Integral b) => b -> Signed a -> Signed a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a. Semigroup a => Signed a -> Signed a -> Signed a
    <> :: Signed a -> Signed a -> Signed a
    $csconcat :: forall a. Semigroup a => NonEmpty (Signed a) -> Signed a
    sconcat :: NonEmpty (Signed a) -> Signed a
    $cstimes :: forall a b. (Semigroup a, Integral b) => b -> Signed a -> Signed a
    stimes :: forall b. Integral b => b -> Signed a -> Signed a
    Semigroup, Semigroup (Signed a)
    Signed a
    Semigroup (Signed a) =>
    Signed a
    -> (Signed a -> Signed a -> Signed a)
    -> ([Signed a] -> Signed a)
    -> Monoid (Signed a)
    [Signed a] -> Signed a
    Signed a -> Signed a -> Signed a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (Signed a)
    forall a. Monoid a => Signed a
    forall a. Monoid a => [Signed a] -> Signed a
    forall a. Monoid a => Signed a -> Signed a -> Signed a
    $cmempty :: forall a. Monoid a => Signed a
    mempty :: Signed a
    $cmappend :: forall a. Monoid a => Signed a -> Signed a -> Signed a
    mappend :: Signed a -> Signed a -> Signed a
    $cmconcat :: forall a. Monoid a => [Signed a] -> Signed a
    mconcat :: [Signed a] -> Signed a
    Monoid, Signed a -> ()
    (Signed a -> ()) -> NFData (Signed a)
    forall a. NFData a => Signed a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => Signed a -> ()
    rnf :: Signed a -> ()
    NFData, Integer -> Signed a
    Signed a -> Signed a
    Signed a -> Signed a -> Signed a
    (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Signed a -> Signed a)
    -> (Integer -> Signed a)
    -> Num (Signed a)
    forall a. Num a => Integer -> Signed a
    forall a. Num a => Signed a -> Signed a
    forall a. Num a => Signed a -> Signed a -> Signed a
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: forall a. Num a => Signed a -> Signed a -> Signed a
    + :: Signed a -> Signed a -> Signed a
    $c- :: forall a. Num a => Signed a -> Signed a -> Signed a
    - :: Signed a -> Signed a -> Signed a
    $c* :: forall a. Num a => Signed a -> Signed a -> Signed a
    * :: Signed a -> Signed a -> Signed a
    $cnegate :: forall a. Num a => Signed a -> Signed a
    negate :: Signed a -> Signed a
    $cabs :: forall a. Num a => Signed a -> Signed a
    abs :: Signed a -> Signed a
    $csignum :: forall a. Num a => Signed a -> Signed a
    signum :: Signed a -> Signed a
    $cfromInteger :: forall a. Num a => Integer -> Signed a
    fromInteger :: Integer -> Signed a
    Num, Eq (Signed a)
    Eq (Signed a) =>
    (Signed a -> Signed a -> Ordering)
    -> (Signed a -> Signed a -> Bool)
    -> (Signed a -> Signed a -> Bool)
    -> (Signed a -> Signed a -> Bool)
    -> (Signed a -> Signed a -> Bool)
    -> (Signed a -> Signed a -> Signed a)
    -> (Signed a -> Signed a -> Signed a)
    -> Ord (Signed a)
    Signed a -> Signed a -> Bool
    Signed a -> Signed a -> Ordering
    Signed a -> Signed a -> Signed a
    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
    forall a. Ord a => Eq (Signed a)
    forall a. Ord a => Signed a -> Signed a -> Bool
    forall a. Ord a => Signed a -> Signed a -> Ordering
    forall a. Ord a => Signed a -> Signed a -> Signed a
    $ccompare :: forall a. Ord a => Signed a -> Signed a -> Ordering
    compare :: Signed a -> Signed a -> Ordering
    $c< :: forall a. Ord a => Signed a -> Signed a -> Bool
    < :: Signed a -> Signed a -> Bool
    $c<= :: forall a. Ord a => Signed a -> Signed a -> Bool
    <= :: Signed a -> Signed a -> Bool
    $c> :: forall a. Ord a => Signed a -> Signed a -> Bool
    > :: Signed a -> Signed a -> Bool
    $c>= :: forall a. Ord a => Signed a -> Signed a -> Bool
    >= :: Signed a -> Signed a -> Bool
    $cmax :: forall a. Ord a => Signed a -> Signed a -> Signed a
    max :: Signed a -> Signed a -> Signed a
    $cmin :: forall a. Ord a => Signed a -> Signed a -> Signed a
    min :: Signed a -> Signed a -> Signed a
    Ord, Num (Signed a)
    Ord (Signed a)
    (Num (Signed a), Ord (Signed a)) =>
    (Signed a -> Rational) -> Real (Signed a)
    Signed a -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    forall a. Real a => Num (Signed a)
    forall a. Real a => Ord (Signed a)
    forall a. Real a => Signed a -> Rational
    $ctoRational :: forall a. Real a => Signed a -> Rational
    toRational :: Signed a -> Rational
    Real, Floating (Signed a)
    RealFrac (Signed a)
    (RealFrac (Signed a), Floating (Signed a)) =>
    (Signed a -> Integer)
    -> (Signed a -> Int)
    -> (Signed a -> (Int, Int))
    -> (Signed a -> (Integer, Int))
    -> (Integer -> Int -> Signed a)
    -> (Signed a -> Int)
    -> (Signed a -> Signed a)
    -> (Int -> Signed a -> Signed a)
    -> (Signed a -> Bool)
    -> (Signed a -> Bool)
    -> (Signed a -> Bool)
    -> (Signed a -> Bool)
    -> (Signed a -> Bool)
    -> (Signed a -> Signed a -> Signed a)
    -> RealFloat (Signed a)
    Int -> Signed a -> Signed a
    Integer -> Int -> Signed a
    Signed a -> Bool
    Signed a -> Int
    Signed a -> Integer
    Signed a -> (Int, Int)
    Signed a -> (Integer, Int)
    Signed a -> Signed a
    Signed a -> Signed a -> Signed a
    forall a. RealFloat a => Floating (Signed a)
    forall a. RealFloat a => RealFrac (Signed a)
    forall a. RealFloat a => Int -> Signed a -> Signed a
    forall a. RealFloat a => Integer -> Int -> Signed a
    forall a. RealFloat a => Signed a -> Bool
    forall a. RealFloat a => Signed a -> Int
    forall a. RealFloat a => Signed a -> Integer
    forall a. RealFloat a => Signed a -> (Int, Int)
    forall a. RealFloat a => Signed a -> (Integer, Int)
    forall a. RealFloat a => Signed a -> Signed a
    forall a. RealFloat a => Signed a -> Signed a -> Signed a
    forall a.
    (RealFrac a, Floating a) =>
    (a -> Integer)
    -> (a -> Int)
    -> (a -> (Int, Int))
    -> (a -> (Integer, Int))
    -> (Integer -> Int -> a)
    -> (a -> Int)
    -> (a -> a)
    -> (Int -> a -> a)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> a -> a)
    -> RealFloat a
    $cfloatRadix :: forall a. RealFloat a => Signed a -> Integer
    floatRadix :: Signed a -> Integer
    $cfloatDigits :: forall a. RealFloat a => Signed a -> Int
    floatDigits :: Signed a -> Int
    $cfloatRange :: forall a. RealFloat a => Signed a -> (Int, Int)
    floatRange :: Signed a -> (Int, Int)
    $cdecodeFloat :: forall a. RealFloat a => Signed a -> (Integer, Int)
    decodeFloat :: Signed a -> (Integer, Int)
    $cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Signed a
    encodeFloat :: Integer -> Int -> Signed a
    $cexponent :: forall a. RealFloat a => Signed a -> Int
    exponent :: Signed a -> Int
    $csignificand :: forall a. RealFloat a => Signed a -> Signed a
    significand :: Signed a -> Signed a
    $cscaleFloat :: forall a. RealFloat a => Int -> Signed a -> Signed a
    scaleFloat :: Int -> Signed a -> Signed a
    $cisNaN :: forall a. RealFloat a => Signed a -> Bool
    isNaN :: Signed a -> Bool
    $cisInfinite :: forall a. RealFloat a => Signed a -> Bool
    isInfinite :: Signed a -> Bool
    $cisDenormalized :: forall a. RealFloat a => Signed a -> Bool
    isDenormalized :: Signed a -> Bool
    $cisNegativeZero :: forall a. RealFloat a => Signed a -> Bool
    isNegativeZero :: Signed a -> Bool
    $cisIEEE :: forall a. RealFloat a => Signed a -> Bool
    isIEEE :: Signed a -> Bool
    $catan2 :: forall a. RealFloat a => Signed a -> Signed a -> Signed a
    atan2 :: Signed a -> Signed a -> Signed a
    RealFloat, Fractional (Signed a)
    Real (Signed a)
    (Real (Signed a), Fractional (Signed a)) =>
    (forall b. Integral b => Signed a -> (b, Signed a))
    -> (forall b. Integral b => Signed a -> b)
    -> (forall b. Integral b => Signed a -> b)
    -> (forall b. Integral b => Signed a -> b)
    -> (forall b. Integral b => Signed a -> b)
    -> RealFrac (Signed a)
    forall b. Integral b => Signed a -> b
    forall b. Integral b => Signed a -> (b, Signed a)
    forall a.
    (Real a, Fractional a) =>
    (forall b. Integral b => a -> (b, a))
    -> (forall b. Integral b => a -> b)
    -> (forall b. Integral b => a -> b)
    -> (forall b. Integral b => a -> b)
    -> (forall b. Integral b => a -> b)
    -> RealFrac a
    forall a. RealFrac a => Fractional (Signed a)
    forall a. RealFrac a => Real (Signed a)
    forall a b. (RealFrac a, Integral b) => Signed a -> b
    forall a b. (RealFrac a, Integral b) => Signed a -> (b, Signed a)
    $cproperFraction :: forall a b. (RealFrac a, Integral b) => Signed a -> (b, Signed a)
    properFraction :: forall b. Integral b => Signed a -> (b, Signed a)
    $ctruncate :: forall a b. (RealFrac a, Integral b) => Signed a -> b
    truncate :: forall b. Integral b => Signed a -> b
    $cround :: forall a b. (RealFrac a, Integral b) => Signed a -> b
    round :: forall b. Integral b => Signed a -> b
    $cceiling :: forall a b. (RealFrac a, Integral b) => Signed a -> b
    ceiling :: forall b. Integral b => Signed a -> b
    $cfloor :: forall a b. (RealFrac a, Integral b) => Signed a -> b
    floor :: forall b. Integral b => Signed a -> b
    RealFrac, Int -> Signed a -> ShowS
    [Signed a] -> ShowS
    Signed a -> String
    (Int -> Signed a -> ShowS)
    -> (Signed a -> String) -> ([Signed a] -> ShowS) -> Show (Signed a)
    forall a. Show a => Int -> Signed a -> ShowS
    forall a. Show a => [Signed a] -> ShowS
    forall a. Show a => Signed a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Signed a -> ShowS
    showsPrec :: Int -> Signed a -> ShowS
    $cshow :: forall a. Show a => Signed a -> String
    show :: Signed a -> String
    $cshowList :: forall a. Show a => [Signed a] -> ShowS
    showList :: [Signed a] -> ShowS
    Show, Functor Signed
    Foldable Signed
    (Functor Signed, Foldable Signed) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Signed a -> f (Signed b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Signed (f a) -> f (Signed a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Signed a -> m (Signed b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        Signed (m a) -> m (Signed a))
    -> Traversable Signed
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Signed (m a) -> m (Signed a)
    forall (f :: * -> *) a.
    Applicative f =>
    Signed (f a) -> f (Signed a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Signed a -> m (Signed b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Signed a -> f (Signed b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Signed a -> f (Signed b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Signed a -> f (Signed b)
    $csequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Signed (f a) -> f (Signed a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    Signed (f a) -> f (Signed a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Signed a -> m (Signed b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Signed a -> m (Signed b)
    $csequence :: forall (m :: * -> *) a. Monad m => Signed (m a) -> m (Signed a)
    sequence :: forall (m :: * -> *) a. Monad m => Signed (m a) -> m (Signed a)
    Traversable, Typeable)

    -- |
    -- Fixed integers are stored in little-endian form without additional encoding.
    newtype Fixed a = Fixed a
      deriving (Eq (Fixed a)
    Fixed a
    Eq (Fixed a) =>
    (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> Fixed a
    -> (Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Bool)
    -> (Fixed a -> Maybe Int)
    -> (Fixed a -> Int)
    -> (Fixed a -> Bool)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int -> Fixed a)
    -> (Fixed a -> Int)
    -> Bits (Fixed a)
    Int -> Fixed a
    Fixed a -> Bool
    Fixed a -> Int
    Fixed a -> Maybe Int
    Fixed a -> Fixed a
    Fixed a -> Int -> Bool
    Fixed a -> Int -> Fixed a
    Fixed a -> Fixed a -> Fixed a
    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
    forall a. Bits a => Eq (Fixed a)
    forall a. Bits a => Fixed a
    forall a. Bits a => Int -> Fixed a
    forall a. Bits a => Fixed a -> Bool
    forall a. Bits a => Fixed a -> Int
    forall a. Bits a => Fixed a -> Maybe Int
    forall a. Bits a => Fixed a -> Fixed a
    forall a. Bits a => Fixed a -> Int -> Bool
    forall a. Bits a => Fixed a -> Int -> Fixed a
    forall a. Bits a => Fixed a -> Fixed a -> Fixed a
    $c.&. :: forall a. Bits a => Fixed a -> Fixed a -> Fixed a
    .&. :: Fixed a -> Fixed a -> Fixed a
    $c.|. :: forall a. Bits a => Fixed a -> Fixed a -> Fixed a
    .|. :: Fixed a -> Fixed a -> Fixed a
    $cxor :: forall a. Bits a => Fixed a -> Fixed a -> Fixed a
    xor :: Fixed a -> Fixed a -> Fixed a
    $ccomplement :: forall a. Bits a => Fixed a -> Fixed a
    complement :: Fixed a -> Fixed a
    $cshift :: forall a. Bits a => Fixed a -> Int -> Fixed a
    shift :: Fixed a -> Int -> Fixed a
    $crotate :: forall a. Bits a => Fixed a -> Int -> Fixed a
    rotate :: Fixed a -> Int -> Fixed a
    $czeroBits :: forall a. Bits a => Fixed a
    zeroBits :: Fixed a
    $cbit :: forall a. Bits a => Int -> Fixed a
    bit :: Int -> Fixed a
    $csetBit :: forall a. Bits a => Fixed a -> Int -> Fixed a
    setBit :: Fixed a -> Int -> Fixed a
    $cclearBit :: forall a. Bits a => Fixed a -> Int -> Fixed a
    clearBit :: Fixed a -> Int -> Fixed a
    $ccomplementBit :: forall a. Bits a => Fixed a -> Int -> Fixed a
    complementBit :: Fixed a -> Int -> Fixed a
    $ctestBit :: forall a. Bits a => Fixed a -> Int -> Bool
    testBit :: Fixed a -> Int -> Bool
    $cbitSizeMaybe :: forall a. Bits a => Fixed a -> Maybe Int
    bitSizeMaybe :: Fixed a -> Maybe Int
    $cbitSize :: forall a. Bits a => Fixed a -> Int
    bitSize :: Fixed a -> Int
    $cisSigned :: forall a. Bits a => Fixed a -> Bool
    isSigned :: Fixed a -> Bool
    $cshiftL :: forall a. Bits a => Fixed a -> Int -> Fixed a
    shiftL :: Fixed a -> Int -> Fixed a
    $cunsafeShiftL :: forall a. Bits a => Fixed a -> Int -> Fixed a
    unsafeShiftL :: Fixed a -> Int -> Fixed a
    $cshiftR :: forall a. Bits a => Fixed a -> Int -> Fixed a
    shiftR :: Fixed a -> Int -> Fixed a
    $cunsafeShiftR :: forall a. Bits a => Fixed a -> Int -> Fixed a
    unsafeShiftR :: Fixed a -> Int -> Fixed a
    $crotateL :: forall a. Bits a => Fixed a -> Int -> Fixed a
    rotateL :: Fixed a -> Int -> Fixed a
    $crotateR :: forall a. Bits a => Fixed a -> Int -> Fixed a
    rotateR :: Fixed a -> Int -> Fixed a
    $cpopCount :: forall a. Bits a => Fixed a -> Int
    popCount :: Fixed a -> Int
    Bits, Fixed a
    Fixed a -> Fixed a -> Bounded (Fixed a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Fixed a
    $cminBound :: forall a. Bounded a => Fixed a
    minBound :: Fixed a
    $cmaxBound :: forall a. Bounded a => Fixed a
    maxBound :: Fixed a
    Bounded, Int -> Fixed a
    Fixed a -> Int
    Fixed a -> [Fixed a]
    Fixed a -> Fixed a
    Fixed a -> Fixed a -> [Fixed a]
    Fixed a -> Fixed a -> Fixed a -> [Fixed a]
    (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Int -> Fixed a)
    -> (Fixed a -> Int)
    -> (Fixed a -> [Fixed a])
    -> (Fixed a -> Fixed a -> [Fixed a])
    -> (Fixed a -> Fixed a -> [Fixed a])
    -> (Fixed a -> Fixed a -> Fixed a -> [Fixed a])
    -> Enum (Fixed a)
    forall a. Enum a => Int -> Fixed a
    forall a. Enum a => Fixed a -> Int
    forall a. Enum a => Fixed a -> [Fixed a]
    forall a. Enum a => Fixed a -> Fixed a
    forall a. Enum a => Fixed a -> Fixed a -> [Fixed a]
    forall a. Enum a => Fixed a -> Fixed a -> Fixed a -> [Fixed a]
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: forall a. Enum a => Fixed a -> Fixed a
    succ :: Fixed a -> Fixed a
    $cpred :: forall a. Enum a => Fixed a -> Fixed a
    pred :: Fixed a -> Fixed a
    $ctoEnum :: forall a. Enum a => Int -> Fixed a
    toEnum :: Int -> Fixed a
    $cfromEnum :: forall a. Enum a => Fixed a -> Int
    fromEnum :: Fixed a -> Int
    $cenumFrom :: forall a. Enum a => Fixed a -> [Fixed a]
    enumFrom :: Fixed a -> [Fixed a]
    $cenumFromThen :: forall a. Enum a => Fixed a -> Fixed a -> [Fixed a]
    enumFromThen :: Fixed a -> Fixed a -> [Fixed a]
    $cenumFromTo :: forall a. Enum a => Fixed a -> Fixed a -> [Fixed a]
    enumFromTo :: Fixed a -> Fixed a -> [Fixed a]
    $cenumFromThenTo :: forall a. Enum a => Fixed a -> Fixed a -> Fixed a -> [Fixed a]
    enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a]
    Enum, Fixed a -> Fixed a -> Bool
    (Fixed a -> Fixed a -> Bool)
    -> (Fixed a -> Fixed a -> Bool) -> Eq (Fixed a)
    forall a. Eq a => Fixed a -> Fixed a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Fixed a -> Fixed a -> Bool
    == :: Fixed a -> Fixed a -> Bool
    $c/= :: forall a. Eq a => Fixed a -> Fixed a -> Bool
    /= :: Fixed a -> Fixed a -> Bool
    Eq, Fractional (Fixed a)
    Fixed a
    Fractional (Fixed a) =>
    Fixed a
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> Floating (Fixed a)
    Fixed a -> Fixed a
    Fixed a -> Fixed a -> Fixed a
    forall a. Floating a => Fractional (Fixed a)
    forall a. Floating a => Fixed a
    forall a. Floating a => Fixed a -> Fixed a
    forall a. Floating a => Fixed a -> Fixed a -> Fixed a
    forall a.
    Fractional a =>
    a
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> Floating a
    $cpi :: forall a. Floating a => Fixed a
    pi :: Fixed a
    $cexp :: forall a. Floating a => Fixed a -> Fixed a
    exp :: Fixed a -> Fixed a
    $clog :: forall a. Floating a => Fixed a -> Fixed a
    log :: Fixed a -> Fixed a
    $csqrt :: forall a. Floating a => Fixed a -> Fixed a
    sqrt :: Fixed a -> Fixed a
    $c** :: forall a. Floating a => Fixed a -> Fixed a -> Fixed a
    ** :: Fixed a -> Fixed a -> Fixed a
    $clogBase :: forall a. Floating a => Fixed a -> Fixed a -> Fixed a
    logBase :: Fixed a -> Fixed a -> Fixed a
    $csin :: forall a. Floating a => Fixed a -> Fixed a
    sin :: Fixed a -> Fixed a
    $ccos :: forall a. Floating a => Fixed a -> Fixed a
    cos :: Fixed a -> Fixed a
    $ctan :: forall a. Floating a => Fixed a -> Fixed a
    tan :: Fixed a -> Fixed a
    $casin :: forall a. Floating a => Fixed a -> Fixed a
    asin :: Fixed a -> Fixed a
    $cacos :: forall a. Floating a => Fixed a -> Fixed a
    acos :: Fixed a -> Fixed a
    $catan :: forall a. Floating a => Fixed a -> Fixed a
    atan :: Fixed a -> Fixed a
    $csinh :: forall a. Floating a => Fixed a -> Fixed a
    sinh :: Fixed a -> Fixed a
    $ccosh :: forall a. Floating a => Fixed a -> Fixed a
    cosh :: Fixed a -> Fixed a
    $ctanh :: forall a. Floating a => Fixed a -> Fixed a
    tanh :: Fixed a -> Fixed a
    $casinh :: forall a. Floating a => Fixed a -> Fixed a
    asinh :: Fixed a -> Fixed a
    $cacosh :: forall a. Floating a => Fixed a -> Fixed a
    acosh :: Fixed a -> Fixed a
    $catanh :: forall a. Floating a => Fixed a -> Fixed a
    atanh :: Fixed a -> Fixed a
    $clog1p :: forall a. Floating a => Fixed a -> Fixed a
    log1p :: Fixed a -> Fixed a
    $cexpm1 :: forall a. Floating a => Fixed a -> Fixed a
    expm1 :: Fixed a -> Fixed a
    $clog1pexp :: forall a. Floating a => Fixed a -> Fixed a
    log1pexp :: Fixed a -> Fixed a
    $clog1mexp :: forall a. Floating a => Fixed a -> Fixed a
    log1mexp :: Fixed a -> Fixed a
    Floating, (forall m. Monoid m => Fixed m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Fixed a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Fixed a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Fixed a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Fixed a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Fixed a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Fixed a -> b)
    -> (forall a. (a -> a -> a) -> Fixed a -> a)
    -> (forall a. (a -> a -> a) -> Fixed a -> a)
    -> (forall a. Fixed a -> [a])
    -> (forall a. Fixed a -> Bool)
    -> (forall a. Fixed a -> Int)
    -> (forall a. Eq a => a -> Fixed a -> Bool)
    -> (forall a. Ord a => Fixed a -> a)
    -> (forall a. Ord a => Fixed a -> a)
    -> (forall a. Num a => Fixed a -> a)
    -> (forall a. Num a => Fixed a -> a)
    -> Foldable Fixed
    forall a. Eq a => a -> Fixed a -> Bool
    forall a. Num a => Fixed a -> a
    forall a. Ord a => Fixed a -> a
    forall m. Monoid m => Fixed m -> m
    forall a. Fixed a -> Bool
    forall a. Fixed a -> Int
    forall a. Fixed a -> [a]
    forall a. (a -> a -> a) -> Fixed a -> a
    forall m a. Monoid m => (a -> m) -> Fixed a -> m
    forall b a. (b -> a -> b) -> b -> Fixed a -> b
    forall a b. (a -> b -> b) -> b -> Fixed a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Fixed m -> m
    fold :: forall m. Monoid m => Fixed m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Fixed a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Fixed a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Fixed a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Fixed a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Fixed a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Fixed a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Fixed a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Fixed a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Fixed a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Fixed a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Fixed a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Fixed a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Fixed a -> a
    foldr1 :: forall a. (a -> a -> a) -> Fixed a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Fixed a -> a
    foldl1 :: forall a. (a -> a -> a) -> Fixed a -> a
    $ctoList :: forall a. Fixed a -> [a]
    toList :: forall a. Fixed a -> [a]
    $cnull :: forall a. Fixed a -> Bool
    null :: forall a. Fixed a -> Bool
    $clength :: forall a. Fixed a -> Int
    length :: forall a. Fixed a -> Int
    $celem :: forall a. Eq a => a -> Fixed a -> Bool
    elem :: forall a. Eq a => a -> Fixed a -> Bool
    $cmaximum :: forall a. Ord a => Fixed a -> a
    maximum :: forall a. Ord a => Fixed a -> a
    $cminimum :: forall a. Ord a => Fixed a -> a
    minimum :: forall a. Ord a => Fixed a -> a
    $csum :: forall a. Num a => Fixed a -> a
    sum :: forall a. Num a => Fixed a -> a
    $cproduct :: forall a. Num a => Fixed a -> a
    product :: forall a. Num a => Fixed a -> a
    Foldable, Num (Fixed a)
    Num (Fixed a) =>
    (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Rational -> Fixed a)
    -> Fractional (Fixed a)
    Rational -> Fixed a
    Fixed a -> Fixed a
    Fixed a -> Fixed a -> Fixed a
    forall a. Fractional a => Num (Fixed a)
    forall a. Fractional a => Rational -> Fixed a
    forall a. Fractional a => Fixed a -> Fixed a
    forall a. Fractional a => Fixed a -> Fixed a -> Fixed a
    forall a.
    Num a =>
    (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
    $c/ :: forall a. Fractional a => Fixed a -> Fixed a -> Fixed a
    / :: Fixed a -> Fixed a -> Fixed a
    $crecip :: forall a. Fractional a => Fixed a -> Fixed a
    recip :: Fixed a -> Fixed a
    $cfromRational :: forall a. Fractional a => Rational -> Fixed a
    fromRational :: Rational -> Fixed a
    Fractional, (forall a b. (a -> b) -> Fixed a -> Fixed b)
    -> (forall a b. a -> Fixed b -> Fixed a) -> Functor Fixed
    forall a b. a -> Fixed b -> Fixed a
    forall a b. (a -> b) -> Fixed a -> Fixed b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Fixed a -> Fixed b
    fmap :: forall a b. (a -> b) -> Fixed a -> Fixed b
    $c<$ :: forall a b. a -> Fixed b -> Fixed a
    <$ :: forall a b. a -> Fixed b -> Fixed a
    Functor, Enum (Fixed a)
    Real (Fixed a)
    (Real (Fixed a), Enum (Fixed a)) =>
    (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> (Fixed a, Fixed a))
    -> (Fixed a -> Fixed a -> (Fixed a, Fixed a))
    -> (Fixed a -> Integer)
    -> Integral (Fixed a)
    Fixed a -> Integer
    Fixed a -> Fixed a -> (Fixed a, Fixed a)
    Fixed a -> Fixed a -> Fixed a
    forall a. Integral a => Enum (Fixed a)
    forall a. Integral a => Real (Fixed a)
    forall a. Integral a => Fixed a -> Integer
    forall a. Integral a => Fixed a -> Fixed a -> (Fixed a, Fixed a)
    forall a. Integral a => Fixed a -> Fixed a -> Fixed a
    forall a.
    (Real a, Enum a) =>
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> (a, a))
    -> (a -> a -> (a, a))
    -> (a -> Integer)
    -> Integral a
    $cquot :: forall a. Integral a => Fixed a -> Fixed a -> Fixed a
    quot :: Fixed a -> Fixed a -> Fixed a
    $crem :: forall a. Integral a => Fixed a -> Fixed a -> Fixed a
    rem :: Fixed a -> Fixed a -> Fixed a
    $cdiv :: forall a. Integral a => Fixed a -> Fixed a -> Fixed a
    div :: Fixed a -> Fixed a -> Fixed a
    $cmod :: forall a. Integral a => Fixed a -> Fixed a -> Fixed a
    mod :: Fixed a -> Fixed a -> Fixed a
    $cquotRem :: forall a. Integral a => Fixed a -> Fixed a -> (Fixed a, Fixed a)
    quotRem :: Fixed a -> Fixed a -> (Fixed a, Fixed a)
    $cdivMod :: forall a. Integral a => Fixed a -> Fixed a -> (Fixed a, Fixed a)
    divMod :: Fixed a -> Fixed a -> (Fixed a, Fixed a)
    $ctoInteger :: forall a. Integral a => Fixed a -> Integer
    toInteger :: Fixed a -> Integer
    Integral, NonEmpty (Fixed a) -> Fixed a
    Fixed a -> Fixed a -> Fixed a
    (Fixed a -> Fixed a -> Fixed a)
    -> (NonEmpty (Fixed a) -> Fixed a)
    -> (forall b. Integral b => b -> Fixed a -> Fixed a)
    -> Semigroup (Fixed a)
    forall b. Integral b => b -> Fixed a -> Fixed a
    forall a. Semigroup a => NonEmpty (Fixed a) -> Fixed a
    forall a. Semigroup a => Fixed a -> Fixed a -> Fixed a
    forall a b. (Semigroup a, Integral b) => b -> Fixed a -> Fixed a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    $c<> :: forall a. Semigroup a => Fixed a -> Fixed a -> Fixed a
    <> :: Fixed a -> Fixed a -> Fixed a
    $csconcat :: forall a. Semigroup a => NonEmpty (Fixed a) -> Fixed a
    sconcat :: NonEmpty (Fixed a) -> Fixed a
    $cstimes :: forall a b. (Semigroup a, Integral b) => b -> Fixed a -> Fixed a
    stimes :: forall b. Integral b => b -> Fixed a -> Fixed a
    Semigroup, Semigroup (Fixed a)
    Fixed a
    Semigroup (Fixed a) =>
    Fixed a
    -> (Fixed a -> Fixed a -> Fixed a)
    -> ([Fixed a] -> Fixed a)
    -> Monoid (Fixed a)
    [Fixed a] -> Fixed a
    Fixed a -> Fixed a -> Fixed a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. Monoid a => Semigroup (Fixed a)
    forall a. Monoid a => Fixed a
    forall a. Monoid a => [Fixed a] -> Fixed a
    forall a. Monoid a => Fixed a -> Fixed a -> Fixed a
    $cmempty :: forall a. Monoid a => Fixed a
    mempty :: Fixed a
    $cmappend :: forall a. Monoid a => Fixed a -> Fixed a -> Fixed a
    mappend :: Fixed a -> Fixed a -> Fixed a
    $cmconcat :: forall a. Monoid a => [Fixed a] -> Fixed a
    mconcat :: [Fixed a] -> Fixed a
    Monoid, Fixed a -> ()
    (Fixed a -> ()) -> NFData (Fixed a)
    forall a. NFData a => Fixed a -> ()
    forall a. (a -> ()) -> NFData a
    $crnf :: forall a. NFData a => Fixed a -> ()
    rnf :: Fixed a -> ()
    NFData, Integer -> Fixed a
    Fixed a -> Fixed a
    Fixed a -> Fixed a -> Fixed a
    (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a)
    -> (Integer -> Fixed a)
    -> Num (Fixed a)
    forall a. Num a => Integer -> Fixed a
    forall a. Num a => Fixed a -> Fixed a
    forall a. Num a => Fixed a -> Fixed a -> Fixed a
    forall a.
    (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (a -> a)
    -> (Integer -> a)
    -> Num a
    $c+ :: forall a. Num a => Fixed a -> Fixed a -> Fixed a
    + :: Fixed a -> Fixed a -> Fixed a
    $c- :: forall a. Num a => Fixed a -> Fixed a -> Fixed a
    - :: Fixed a -> Fixed a -> Fixed a
    $c* :: forall a. Num a => Fixed a -> Fixed a -> Fixed a
    * :: Fixed a -> Fixed a -> Fixed a
    $cnegate :: forall a. Num a => Fixed a -> Fixed a
    negate :: Fixed a -> Fixed a
    $cabs :: forall a. Num a => Fixed a -> Fixed a
    abs :: Fixed a -> Fixed a
    $csignum :: forall a. Num a => Fixed a -> Fixed a
    signum :: Fixed a -> Fixed a
    $cfromInteger :: forall a. Num a => Integer -> Fixed a
    fromInteger :: Integer -> Fixed a
    Num, Eq (Fixed a)
    Eq (Fixed a) =>
    (Fixed a -> Fixed a -> Ordering)
    -> (Fixed a -> Fixed a -> Bool)
    -> (Fixed a -> Fixed a -> Bool)
    -> (Fixed a -> Fixed a -> Bool)
    -> (Fixed a -> Fixed a -> Bool)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> Ord (Fixed a)
    Fixed a -> Fixed a -> Bool
    Fixed a -> Fixed a -> Ordering
    Fixed a -> Fixed a -> Fixed a
    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
    forall a. Ord a => Eq (Fixed a)
    forall a. Ord a => Fixed a -> Fixed a -> Bool
    forall a. Ord a => Fixed a -> Fixed a -> Ordering
    forall a. Ord a => Fixed a -> Fixed a -> Fixed a
    $ccompare :: forall a. Ord a => Fixed a -> Fixed a -> Ordering
    compare :: Fixed a -> Fixed a -> Ordering
    $c< :: forall a. Ord a => Fixed a -> Fixed a -> Bool
    < :: Fixed a -> Fixed a -> Bool
    $c<= :: forall a. Ord a => Fixed a -> Fixed a -> Bool
    <= :: Fixed a -> Fixed a -> Bool
    $c> :: forall a. Ord a => Fixed a -> Fixed a -> Bool
    > :: Fixed a -> Fixed a -> Bool
    $c>= :: forall a. Ord a => Fixed a -> Fixed a -> Bool
    >= :: Fixed a -> Fixed a -> Bool
    $cmax :: forall a. Ord a => Fixed a -> Fixed a -> Fixed a
    max :: Fixed a -> Fixed a -> Fixed a
    $cmin :: forall a. Ord a => Fixed a -> Fixed a -> Fixed a
    min :: Fixed a -> Fixed a -> Fixed a
    Ord, Num (Fixed a)
    Ord (Fixed a)
    (Num (Fixed a), Ord (Fixed a)) =>
    (Fixed a -> Rational) -> Real (Fixed a)
    Fixed a -> Rational
    forall a. (Num a, Ord a) => (a -> Rational) -> Real a
    forall a. Real a => Num (Fixed a)
    forall a. Real a => Ord (Fixed a)
    forall a. Real a => Fixed a -> Rational
    $ctoRational :: forall a. Real a => Fixed a -> Rational
    toRational :: Fixed a -> Rational
    Real, Floating (Fixed a)
    RealFrac (Fixed a)
    (RealFrac (Fixed a), Floating (Fixed a)) =>
    (Fixed a -> Integer)
    -> (Fixed a -> Int)
    -> (Fixed a -> (Int, Int))
    -> (Fixed a -> (Integer, Int))
    -> (Integer -> Int -> Fixed a)
    -> (Fixed a -> Int)
    -> (Fixed a -> Fixed a)
    -> (Int -> Fixed a -> Fixed a)
    -> (Fixed a -> Bool)
    -> (Fixed a -> Bool)
    -> (Fixed a -> Bool)
    -> (Fixed a -> Bool)
    -> (Fixed a -> Bool)
    -> (Fixed a -> Fixed a -> Fixed a)
    -> RealFloat (Fixed a)
    Int -> Fixed a -> Fixed a
    Integer -> Int -> Fixed a
    Fixed a -> Bool
    Fixed a -> Int
    Fixed a -> Integer
    Fixed a -> (Int, Int)
    Fixed a -> (Integer, Int)
    Fixed a -> Fixed a
    Fixed a -> Fixed a -> Fixed a
    forall a. RealFloat a => Floating (Fixed a)
    forall a. RealFloat a => RealFrac (Fixed a)
    forall a. RealFloat a => Int -> Fixed a -> Fixed a
    forall a. RealFloat a => Integer -> Int -> Fixed a
    forall a. RealFloat a => Fixed a -> Bool
    forall a. RealFloat a => Fixed a -> Int
    forall a. RealFloat a => Fixed a -> Integer
    forall a. RealFloat a => Fixed a -> (Int, Int)
    forall a. RealFloat a => Fixed a -> (Integer, Int)
    forall a. RealFloat a => Fixed a -> Fixed a
    forall a. RealFloat a => Fixed a -> Fixed a -> Fixed a
    forall a.
    (RealFrac a, Floating a) =>
    (a -> Integer)
    -> (a -> Int)
    -> (a -> (Int, Int))
    -> (a -> (Integer, Int))
    -> (Integer -> Int -> a)
    -> (a -> Int)
    -> (a -> a)
    -> (Int -> a -> a)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> Bool)
    -> (a -> a -> a)
    -> RealFloat a
    $cfloatRadix :: forall a. RealFloat a => Fixed a -> Integer
    floatRadix :: Fixed a -> Integer
    $cfloatDigits :: forall a. RealFloat a => Fixed a -> Int
    floatDigits :: Fixed a -> Int
    $cfloatRange :: forall a. RealFloat a => Fixed a -> (Int, Int)
    floatRange :: Fixed a -> (Int, Int)
    $cdecodeFloat :: forall a. RealFloat a => Fixed a -> (Integer, Int)
    decodeFloat :: Fixed a -> (Integer, Int)
    $cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Fixed a
    encodeFloat :: Integer -> Int -> Fixed a
    $cexponent :: forall a. RealFloat a => Fixed a -> Int
    exponent :: Fixed a -> Int
    $csignificand :: forall a. RealFloat a => Fixed a -> Fixed a
    significand :: Fixed a -> Fixed a
    $cscaleFloat :: forall a. RealFloat a => Int -> Fixed a -> Fixed a
    scaleFloat :: Int -> Fixed a -> Fixed a
    $cisNaN :: forall a. RealFloat a => Fixed a -> Bool
    isNaN :: Fixed a -> Bool
    $cisInfinite :: forall a. RealFloat a => Fixed a -> Bool
    isInfinite :: Fixed a -> Bool
    $cisDenormalized :: forall a. RealFloat a => Fixed a -> Bool
    isDenormalized :: Fixed a -> Bool
    $cisNegativeZero :: forall a. RealFloat a => Fixed a -> Bool
    isNegativeZero :: Fixed a -> Bool
    $cisIEEE :: forall a. RealFloat a => Fixed a -> Bool
    isIEEE :: Fixed a -> Bool
    $catan2 :: forall a. RealFloat a => Fixed a -> Fixed a -> Fixed a
    atan2 :: Fixed a -> Fixed a -> Fixed a
    RealFloat, Fractional (Fixed a)
    Real (Fixed a)
    (Real (Fixed a), Fractional (Fixed a)) =>
    (forall b. Integral b => Fixed a -> (b, Fixed a))
    -> (forall b. Integral b => Fixed a -> b)
    -> (forall b. Integral b => Fixed a -> b)
    -> (forall b. Integral b => Fixed a -> b)
    -> (forall b. Integral b => Fixed a -> b)
    -> RealFrac (Fixed a)
    forall b. Integral b => Fixed a -> b
    forall b. Integral b => Fixed a -> (b, Fixed a)
    forall a.
    (Real a, Fractional a) =>
    (forall b. Integral b => a -> (b, a))
    -> (forall b. Integral b => a -> b)
    -> (forall b. Integral b => a -> b)
    -> (forall b. Integral b => a -> b)
    -> (forall b. Integral b => a -> b)
    -> RealFrac a
    forall a. RealFrac a => Fractional (Fixed a)
    forall a. RealFrac a => Real (Fixed a)
    forall a b. (RealFrac a, Integral b) => Fixed a -> b
    forall a b. (RealFrac a, Integral b) => Fixed a -> (b, Fixed a)
    $cproperFraction :: forall a b. (RealFrac a, Integral b) => Fixed a -> (b, Fixed a)
    properFraction :: forall b. Integral b => Fixed a -> (b, Fixed a)
    $ctruncate :: forall a b. (RealFrac a, Integral b) => Fixed a -> b
    truncate :: forall b. Integral b => Fixed a -> b
    $cround :: forall a b. (RealFrac a, Integral b) => Fixed a -> b
    round :: forall b. Integral b => Fixed a -> b
    $cceiling :: forall a b. (RealFrac a, Integral b) => Fixed a -> b
    ceiling :: forall b. Integral b => Fixed a -> b
    $cfloor :: forall a b. (RealFrac a, Integral b) => Fixed a -> b
    floor :: forall b. Integral b => Fixed a -> b
    RealFrac, Int -> Fixed a -> ShowS
    [Fixed a] -> ShowS
    Fixed a -> String
    (Int -> Fixed a -> ShowS)
    -> (Fixed a -> String) -> ([Fixed a] -> ShowS) -> Show (Fixed a)
    forall a. Show a => Int -> Fixed a -> ShowS
    forall a. Show a => [Fixed a] -> ShowS
    forall a. Show a => Fixed a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Fixed a -> ShowS
    showsPrec :: Int -> Fixed a -> ShowS
    $cshow :: forall a. Show a => Fixed a -> String
    show :: Fixed a -> String
    $cshowList :: forall a. Show a => [Fixed a] -> ShowS
    showList :: [Fixed a] -> ShowS
    Show, Functor Fixed
    Foldable Fixed
    (Functor Fixed, Foldable Fixed) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> Fixed a -> f (Fixed b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        Fixed (f a) -> f (Fixed a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> Fixed a -> m (Fixed b))
    -> (forall (m :: * -> *) a. Monad m => Fixed (m a) -> m (Fixed a))
    -> Traversable Fixed
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a. Monad m => Fixed (m a) -> m (Fixed a)
    forall (f :: * -> *) a. Applicative f => Fixed (f a) -> f (Fixed a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Fixed a -> m (Fixed b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Fixed a -> f (Fixed b)
    $ctraverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Fixed a -> f (Fixed b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Fixed a -> f (Fixed b)
    $csequenceA :: forall (f :: * -> *) a. Applicative f => Fixed (f a) -> f (Fixed a)
    sequenceA :: forall (f :: * -> *) a. Applicative f => Fixed (f a) -> f (Fixed a)
    $cmapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Fixed a -> m (Fixed b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Fixed a -> m (Fixed b)
    $csequence :: forall (m :: * -> *) a. Monad m => Fixed (m a) -> m (Fixed a)
    sequence :: forall (m :: * -> *) a. Monad m => Fixed (m a) -> m (Fixed a)
    Traversable, Typeable)