{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

module Proto3.Suite.Types
  (
  -- * Integral Types
    Fixed(..)
  , Signed(..)

  -- * Enumerable Types
  , Enumerated(..)
  , codeFromEnumerated
  , codeToEnumerated

  -- * String and Bytes Types
  , String(..)
  , Bytes(..)

  , ForceEmit(..)
  , Nested(..)
  , UnpackedVec(..)
  , PackedVec(..)
  , NestedVec(..)
  , Commented(..)
  , type (//)()
  ) where

import           Control.Applicative
import           Control.DeepSeq (NFData)
import           GHC.Exts (IsList(..))
import           GHC.Generics (Generic)
import           Data.Function (on)
import           Data.Int (Int32)
import qualified Data.Vector as V
import           GHC.TypeLits (Symbol)
import           Prelude hiding (String)
import           Proto3.Wire.Class (ProtoEnum(..))
import           Test.QuickCheck (Arbitrary(..))

-- | 'Fixed' provides a way to encode integers in the fixed-width wire formats.
newtype Fixed a = Fixed { forall a. Fixed a -> a
fixed :: a }
  deriving (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, 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, 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, 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, (forall x. Fixed a -> Rep (Fixed a) x)
-> (forall x. Rep (Fixed a) x -> Fixed a) -> Generic (Fixed a)
forall x. Rep (Fixed a) x -> Fixed a
forall x. Fixed a -> Rep (Fixed a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Fixed a) x -> Fixed a
forall a x. Fixed a -> Rep (Fixed a) x
$cfrom :: forall a x. Fixed a -> Rep (Fixed a) x
from :: forall x. Fixed a -> Rep (Fixed a) x
$cto :: forall a x. Rep (Fixed a) x -> Fixed a
to :: forall x. Rep (Fixed a) x -> Fixed a
Generic, 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, Gen (Fixed a)
Gen (Fixed a) -> (Fixed a -> [Fixed a]) -> Arbitrary (Fixed a)
Fixed a -> [Fixed a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall a. Arbitrary a => Gen (Fixed a)
forall a. Arbitrary a => Fixed a -> [Fixed a]
$carbitrary :: forall a. Arbitrary a => Gen (Fixed a)
arbitrary :: Gen (Fixed a)
$cshrink :: forall a. Arbitrary a => Fixed a -> [Fixed a]
shrink :: Fixed a -> [Fixed a]
Arbitrary, 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 -> 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
           , (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, (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, 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)

-- | 'Signed' provides a way to encode integers in the signed wire formats.
newtype Signed a = Signed { forall a. Signed a -> a
signed :: a }
  deriving (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, 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, 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, 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, (forall x. Signed a -> Rep (Signed a) x)
-> (forall x. Rep (Signed a) x -> Signed a) -> Generic (Signed a)
forall x. Rep (Signed a) x -> Signed a
forall x. Signed a -> Rep (Signed a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Signed a) x -> Signed a
forall a x. Signed a -> Rep (Signed a) x
$cfrom :: forall a x. Signed a -> Rep (Signed a) x
from :: forall x. Signed a -> Rep (Signed a) x
$cto :: forall a x. Rep (Signed a) x -> Signed a
to :: forall x. Rep (Signed a) x -> Signed a
Generic, 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, Gen (Signed a)
Gen (Signed a) -> (Signed a -> [Signed a]) -> Arbitrary (Signed a)
Signed a -> [Signed a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall a. Arbitrary a => Gen (Signed a)
forall a. Arbitrary a => Signed a -> [Signed a]
$carbitrary :: forall a. Arbitrary a => Gen (Signed a)
arbitrary :: Gen (Signed a)
$cshrink :: forall a. Arbitrary a => Signed a -> [Signed a]
shrink :: Signed a -> [Signed a]
Arbitrary, 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
           , (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, (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, 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)

-- | 'Enumerated' lifts any type with an 'IsEnum' instance so that it can be encoded
-- with 'HasEncoding'.
newtype Enumerated a = Enumerated { forall a. Enumerated a -> Either Int32 a
enumerated :: Either Int32 a }
  deriving (Int -> Enumerated a -> ShowS
[Enumerated a] -> ShowS
Enumerated a -> String
(Int -> Enumerated a -> ShowS)
-> (Enumerated a -> String)
-> ([Enumerated a] -> ShowS)
-> Show (Enumerated a)
forall a. Show a => Int -> Enumerated a -> ShowS
forall a. Show a => [Enumerated a] -> ShowS
forall a. Show a => Enumerated a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Enumerated a -> ShowS
showsPrec :: Int -> Enumerated a -> ShowS
$cshow :: forall a. Show a => Enumerated a -> String
show :: Enumerated a -> String
$cshowList :: forall a. Show a => [Enumerated a] -> ShowS
showList :: [Enumerated a] -> ShowS
Show, (forall x. Enumerated a -> Rep (Enumerated a) x)
-> (forall x. Rep (Enumerated a) x -> Enumerated a)
-> Generic (Enumerated a)
forall x. Rep (Enumerated a) x -> Enumerated a
forall x. Enumerated a -> Rep (Enumerated a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Enumerated a) x -> Enumerated a
forall a x. Enumerated a -> Rep (Enumerated a) x
$cfrom :: forall a x. Enumerated a -> Rep (Enumerated a) x
from :: forall x. Enumerated a -> Rep (Enumerated a) x
$cto :: forall a x. Rep (Enumerated a) x -> Enumerated a
to :: forall x. Rep (Enumerated a) x -> Enumerated a
Generic, Enumerated a -> ()
(Enumerated a -> ()) -> NFData (Enumerated a)
forall a. NFData a => Enumerated a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => Enumerated a -> ()
rnf :: Enumerated a -> ()
NFData, (forall a b. (a -> b) -> Enumerated a -> Enumerated b)
-> (forall a b. a -> Enumerated b -> Enumerated a)
-> Functor Enumerated
forall a b. a -> Enumerated b -> Enumerated a
forall a b. (a -> b) -> Enumerated a -> Enumerated 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) -> Enumerated a -> Enumerated b
fmap :: forall a b. (a -> b) -> Enumerated a -> Enumerated b
$c<$ :: forall a b. a -> Enumerated b -> Enumerated a
<$ :: forall a b. a -> Enumerated b -> Enumerated a
Functor, (forall m. Monoid m => Enumerated m -> m)
-> (forall m a. Monoid m => (a -> m) -> Enumerated a -> m)
-> (forall m a. Monoid m => (a -> m) -> Enumerated a -> m)
-> (forall a b. (a -> b -> b) -> b -> Enumerated a -> b)
-> (forall a b. (a -> b -> b) -> b -> Enumerated a -> b)
-> (forall b a. (b -> a -> b) -> b -> Enumerated a -> b)
-> (forall b a. (b -> a -> b) -> b -> Enumerated a -> b)
-> (forall a. (a -> a -> a) -> Enumerated a -> a)
-> (forall a. (a -> a -> a) -> Enumerated a -> a)
-> (forall a. Enumerated a -> [a])
-> (forall a. Enumerated a -> Bool)
-> (forall a. Enumerated a -> Int)
-> (forall a. Eq a => a -> Enumerated a -> Bool)
-> (forall a. Ord a => Enumerated a -> a)
-> (forall a. Ord a => Enumerated a -> a)
-> (forall a. Num a => Enumerated a -> a)
-> (forall a. Num a => Enumerated a -> a)
-> Foldable Enumerated
forall a. Eq a => a -> Enumerated a -> Bool
forall a. Num a => Enumerated a -> a
forall a. Ord a => Enumerated a -> a
forall m. Monoid m => Enumerated m -> m
forall a. Enumerated a -> Bool
forall a. Enumerated a -> Int
forall a. Enumerated a -> [a]
forall a. (a -> a -> a) -> Enumerated a -> a
forall m a. Monoid m => (a -> m) -> Enumerated a -> m
forall b a. (b -> a -> b) -> b -> Enumerated a -> b
forall a b. (a -> b -> b) -> b -> Enumerated 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 => Enumerated m -> m
fold :: forall m. Monoid m => Enumerated m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Enumerated a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Enumerated a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Enumerated a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Enumerated a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Enumerated a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Enumerated a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Enumerated a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Enumerated a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Enumerated a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Enumerated a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Enumerated a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Enumerated a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Enumerated a -> a
foldr1 :: forall a. (a -> a -> a) -> Enumerated a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Enumerated a -> a
foldl1 :: forall a. (a -> a -> a) -> Enumerated a -> a
$ctoList :: forall a. Enumerated a -> [a]
toList :: forall a. Enumerated a -> [a]
$cnull :: forall a. Enumerated a -> Bool
null :: forall a. Enumerated a -> Bool
$clength :: forall a. Enumerated a -> Int
length :: forall a. Enumerated a -> Int
$celem :: forall a. Eq a => a -> Enumerated a -> Bool
elem :: forall a. Eq a => a -> Enumerated a -> Bool
$cmaximum :: forall a. Ord a => Enumerated a -> a
maximum :: forall a. Ord a => Enumerated a -> a
$cminimum :: forall a. Ord a => Enumerated a -> a
minimum :: forall a. Ord a => Enumerated a -> a
$csum :: forall a. Num a => Enumerated a -> a
sum :: forall a. Num a => Enumerated a -> a
$cproduct :: forall a. Num a => Enumerated a -> a
product :: forall a. Num a => Enumerated a -> a
Foldable, Functor Enumerated
Foldable Enumerated
(Functor Enumerated, Foldable Enumerated) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Enumerated a -> f (Enumerated b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Enumerated (f a) -> f (Enumerated a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Enumerated a -> m (Enumerated b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Enumerated (m a) -> m (Enumerated a))
-> Traversable Enumerated
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 =>
Enumerated (m a) -> m (Enumerated a)
forall (f :: * -> *) a.
Applicative f =>
Enumerated (f a) -> f (Enumerated a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Enumerated a -> m (Enumerated b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Enumerated a -> f (Enumerated b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Enumerated a -> f (Enumerated b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Enumerated a -> f (Enumerated b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Enumerated (f a) -> f (Enumerated a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Enumerated (f a) -> f (Enumerated a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Enumerated a -> m (Enumerated b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Enumerated a -> m (Enumerated b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Enumerated (m a) -> m (Enumerated a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Enumerated (m a) -> m (Enumerated a)
Traversable)

-- | We consider two enumerated values to be equal if they serialize to the same code.
instance ProtoEnum a => Eq (Enumerated a) where
  == :: Enumerated a -> Enumerated a -> Bool
(==) = Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
(==) (Int32 -> Int32 -> Bool)
-> (Enumerated a -> Int32) -> Enumerated a -> Enumerated a -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (Int32 -> Int32) -> (a -> Int32) -> Either Int32 a -> Int32
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Int32 -> Int32
forall a. a -> a
id a -> Int32
forall a. ProtoEnum a => a -> Int32
fromProtoEnum (Either Int32 a -> Int32)
-> (Enumerated a -> Either Int32 a) -> Enumerated a -> Int32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Enumerated a -> Either Int32 a
forall a. Enumerated a -> Either Int32 a
enumerated
  {-# INLINABLE (==) #-}

-- | We compare two enumerated values by comparing the code to which they serialize.
instance ProtoEnum a => Ord (Enumerated a) where
  compare :: Enumerated a -> Enumerated a -> Ordering
compare = Int32 -> Int32 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Int32 -> Int32 -> Ordering)
-> (Enumerated a -> Int32)
-> Enumerated a
-> Enumerated a
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (Int32 -> Int32) -> (a -> Int32) -> Either Int32 a -> Int32
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Int32 -> Int32
forall a. a -> a
id a -> Int32
forall a. ProtoEnum a => a -> Int32
fromProtoEnum (Either Int32 a -> Int32)
-> (Enumerated a -> Either Int32 a) -> Enumerated a -> Int32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Enumerated a -> Either Int32 a
forall a. Enumerated a -> Either Int32 a
enumerated
  {-# INLINABLE compare #-}

instance ProtoEnum a => Arbitrary (Enumerated a) where
  arbitrary :: Gen (Enumerated a)
arbitrary = do
    Int32
i <- Gen Int32
forall a. Arbitrary a => Gen a
arbitrary
    Enumerated a -> Gen (Enumerated a)
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (Enumerated a -> Gen (Enumerated a))
-> (Either Int32 a -> Enumerated a)
-> Either Int32 a
-> Gen (Enumerated a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either Int32 a -> Enumerated a
forall a. Either Int32 a -> Enumerated a
Enumerated (Either Int32 a -> Gen (Enumerated a))
-> Either Int32 a -> Gen (Enumerated a)
forall a b. (a -> b) -> a -> b
$ Either Int32 a
-> (a -> Either Int32 a) -> Maybe a -> Either Int32 a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Int32 -> Either Int32 a
forall a b. a -> Either a b
Left Int32
i) a -> Either Int32 a
forall a b. b -> Either a b
Right (Int32 -> Maybe a
forall a. ProtoEnum a => Int32 -> Maybe a
toProtoEnumMay Int32
i)

-- | Pass through those values that are outside the enum range;
-- this is for forward compatibility as enumerations are extended.
codeFromEnumerated :: ProtoEnum e => Enumerated e -> Int32
codeFromEnumerated :: forall e. ProtoEnum e => Enumerated e -> Int32
codeFromEnumerated = (Int32 -> Int32) -> (e -> Int32) -> Either Int32 e -> Int32
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Int32 -> Int32
forall a. a -> a
id e -> Int32
forall a. ProtoEnum a => a -> Int32
fromProtoEnum (Either Int32 e -> Int32)
-> (Enumerated e -> Either Int32 e) -> Enumerated e -> Int32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Enumerated e -> Either Int32 e
forall a. Enumerated a -> Either Int32 a
enumerated
{-# INLINE codeFromEnumerated #-}

-- | Values inside the enum range are in Right, the rest in Left;
-- this is for forward compatibility as enumerations are extended.
codeToEnumerated :: ProtoEnum e => Int32 -> Enumerated e
codeToEnumerated :: forall e. ProtoEnum e => Int32 -> Enumerated e
codeToEnumerated Int32
code = Either Int32 e -> Enumerated e
forall a. Either Int32 a -> Enumerated a
Enumerated (Either Int32 e
-> (e -> Either Int32 e) -> Maybe e -> Either Int32 e
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Int32 -> Either Int32 e
forall a b. a -> Either a b
Left Int32
code) e -> Either Int32 e
forall a b. b -> Either a b
Right (Int32 -> Maybe e
forall a. ProtoEnum a => Int32 -> Maybe a
toProtoEnumMay Int32
code))
{-# INLINE codeToEnumerated #-}

-- | 'String' provides a way to indicate that the given type expresses
-- a Protobuf string scalar.  @'String' a@ may have type class instances
-- that are more specific to Protobuf uses than those of @a@.
newtype String a = String { forall a. String a -> a
string :: a }
  deriving (Int -> String a -> ShowS
[String a] -> ShowS
String a -> String
(Int -> String a -> ShowS)
-> (String a -> String) -> ([String a] -> ShowS) -> Show (String a)
forall a. Show a => Int -> String a -> ShowS
forall a. Show a => [String a] -> ShowS
forall a. Show a => String a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> String a -> ShowS
showsPrec :: Int -> String a -> ShowS
$cshow :: forall a. Show a => String a -> String
show :: String a -> String
$cshowList :: forall a. Show a => [String a] -> ShowS
showList :: [String a] -> ShowS
Show, String a -> String a -> Bool
(String a -> String a -> Bool)
-> (String a -> String a -> Bool) -> Eq (String a)
forall a. Eq a => String a -> String a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => String a -> String a -> Bool
== :: String a -> String a -> Bool
$c/= :: forall a. Eq a => String a -> String a -> Bool
/= :: String a -> String a -> Bool
Eq, Eq (String a)
Eq (String a) =>
(String a -> String a -> Ordering)
-> (String a -> String a -> Bool)
-> (String a -> String a -> Bool)
-> (String a -> String a -> Bool)
-> (String a -> String a -> Bool)
-> (String a -> String a -> String a)
-> (String a -> String a -> String a)
-> Ord (String a)
String a -> String a -> Bool
String a -> String a -> Ordering
String a -> String a -> String 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 (String a)
forall a. Ord a => String a -> String a -> Bool
forall a. Ord a => String a -> String a -> Ordering
forall a. Ord a => String a -> String a -> String a
$ccompare :: forall a. Ord a => String a -> String a -> Ordering
compare :: String a -> String a -> Ordering
$c< :: forall a. Ord a => String a -> String a -> Bool
< :: String a -> String a -> Bool
$c<= :: forall a. Ord a => String a -> String a -> Bool
<= :: String a -> String a -> Bool
$c> :: forall a. Ord a => String a -> String a -> Bool
> :: String a -> String a -> Bool
$c>= :: forall a. Ord a => String a -> String a -> Bool
>= :: String a -> String a -> Bool
$cmax :: forall a. Ord a => String a -> String a -> String a
max :: String a -> String a -> String a
$cmin :: forall a. Ord a => String a -> String a -> String a
min :: String a -> String a -> String a
Ord, (forall x. String a -> Rep (String a) x)
-> (forall x. Rep (String a) x -> String a) -> Generic (String a)
forall x. Rep (String a) x -> String a
forall x. String a -> Rep (String a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (String a) x -> String a
forall a x. String a -> Rep (String a) x
$cfrom :: forall a x. String a -> Rep (String a) x
from :: forall x. String a -> Rep (String a) x
$cto :: forall a x. Rep (String a) x -> String a
to :: forall x. Rep (String a) x -> String a
Generic, Semigroup (String a)
String a
Semigroup (String a) =>
String a
-> (String a -> String a -> String a)
-> ([String a] -> String a)
-> Monoid (String a)
[String a] -> String a
String a -> String a -> String a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (String a)
forall a. Monoid a => String a
forall a. Monoid a => [String a] -> String a
forall a. Monoid a => String a -> String a -> String a
$cmempty :: forall a. Monoid a => String a
mempty :: String a
$cmappend :: forall a. Monoid a => String a -> String a -> String a
mappend :: String a -> String a -> String a
$cmconcat :: forall a. Monoid a => [String a] -> String a
mconcat :: [String a] -> String a
Monoid, String a -> ()
(String a -> ()) -> NFData (String a)
forall a. NFData a => String a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => String a -> ()
rnf :: String a -> ()
NFData, Gen (String a)
Gen (String a) -> (String a -> [String a]) -> Arbitrary (String a)
String a -> [String a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall a. Arbitrary a => Gen (String a)
forall a. Arbitrary a => String a -> [String a]
$carbitrary :: forall a. Arbitrary a => Gen (String a)
arbitrary :: Gen (String a)
$cshrink :: forall a. Arbitrary a => String a -> [String a]
shrink :: String a -> [String a]
Arbitrary,
            (forall a b. (a -> b) -> String a -> String b)
-> (forall a b. a -> String b -> String a) -> Functor String
forall a b. a -> String b -> String a
forall a b. (a -> b) -> String a -> String 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) -> String a -> String b
fmap :: forall a b. (a -> b) -> String a -> String b
$c<$ :: forall a b. a -> String b -> String a
<$ :: forall a b. a -> String b -> String a
Functor, (forall m. Monoid m => String m -> m)
-> (forall m a. Monoid m => (a -> m) -> String a -> m)
-> (forall m a. Monoid m => (a -> m) -> String a -> m)
-> (forall a b. (a -> b -> b) -> b -> String a -> b)
-> (forall a b. (a -> b -> b) -> b -> String a -> b)
-> (forall b a. (b -> a -> b) -> b -> String a -> b)
-> (forall b a. (b -> a -> b) -> b -> String a -> b)
-> (forall a. (a -> a -> a) -> String a -> a)
-> (forall a. (a -> a -> a) -> String a -> a)
-> (forall a. String a -> [a])
-> (forall a. String a -> Bool)
-> (forall a. String a -> Int)
-> (forall a. Eq a => a -> String a -> Bool)
-> (forall a. Ord a => String a -> a)
-> (forall a. Ord a => String a -> a)
-> (forall a. Num a => String a -> a)
-> (forall a. Num a => String a -> a)
-> Foldable String
forall a. Eq a => a -> String a -> Bool
forall a. Num a => String a -> a
forall a. Ord a => String a -> a
forall m. Monoid m => String m -> m
forall a. String a -> Bool
forall a. String a -> Int
forall a. String a -> [a]
forall a. (a -> a -> a) -> String a -> a
forall m a. Monoid m => (a -> m) -> String a -> m
forall b a. (b -> a -> b) -> b -> String a -> b
forall a b. (a -> b -> b) -> b -> String 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 => String m -> m
fold :: forall m. Monoid m => String m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> String a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> String a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> String a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> String a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> String a -> b
foldr :: forall a b. (a -> b -> b) -> b -> String a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> String a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> String a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> String a -> b
foldl :: forall b a. (b -> a -> b) -> b -> String a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> String a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> String a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> String a -> a
foldr1 :: forall a. (a -> a -> a) -> String a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> String a -> a
foldl1 :: forall a. (a -> a -> a) -> String a -> a
$ctoList :: forall a. String a -> [a]
toList :: forall a. String a -> [a]
$cnull :: forall a. String a -> Bool
null :: forall a. String a -> Bool
$clength :: forall a. String a -> Int
length :: forall a. String a -> Int
$celem :: forall a. Eq a => a -> String a -> Bool
elem :: forall a. Eq a => a -> String a -> Bool
$cmaximum :: forall a. Ord a => String a -> a
maximum :: forall a. Ord a => String a -> a
$cminimum :: forall a. Ord a => String a -> a
minimum :: forall a. Ord a => String a -> a
$csum :: forall a. Num a => String a -> a
sum :: forall a. Num a => String a -> a
$cproduct :: forall a. Num a => String a -> a
product :: forall a. Num a => String a -> a
Foldable, NonEmpty (String a) -> String a
String a -> String a -> String a
(String a -> String a -> String a)
-> (NonEmpty (String a) -> String a)
-> (forall b. Integral b => b -> String a -> String a)
-> Semigroup (String a)
forall b. Integral b => b -> String a -> String a
forall a. Semigroup a => NonEmpty (String a) -> String a
forall a. Semigroup a => String a -> String a -> String a
forall a b. (Semigroup a, Integral b) => b -> String a -> String a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: forall a. Semigroup a => String a -> String a -> String a
<> :: String a -> String a -> String a
$csconcat :: forall a. Semigroup a => NonEmpty (String a) -> String a
sconcat :: NonEmpty (String a) -> String a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> String a -> String a
stimes :: forall b. Integral b => b -> String a -> String a
Semigroup, Functor String
Foldable String
(Functor String, Foldable String) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> String a -> f (String b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    String (f a) -> f (String a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> String a -> m (String b))
-> (forall (m :: * -> *) a.
    Monad m =>
    String (m a) -> m (String a))
-> Traversable String
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 => String (m a) -> m (String a)
forall (f :: * -> *) a.
Applicative f =>
String (f a) -> f (String a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> String a -> m (String b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> String a -> f (String b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> String a -> f (String b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> String a -> f (String b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
String (f a) -> f (String a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
String (f a) -> f (String a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> String a -> m (String b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> String a -> m (String b)
$csequence :: forall (m :: * -> *) a. Monad m => String (m a) -> m (String a)
sequence :: forall (m :: * -> *) a. Monad m => String (m a) -> m (String a)
Traversable)

-- | 'Bytes' provides a way to indicate that the given type expresses
-- a Protobuf bytes scalar.  @'Bytes' a@ may have type class instances
-- that are more specific to Protobuf uses than those of @a@.
newtype Bytes a = Bytes { forall a. Bytes a -> a
bytes :: a }
  deriving (Int -> Bytes a -> ShowS
[Bytes a] -> ShowS
Bytes a -> String
(Int -> Bytes a -> ShowS)
-> (Bytes a -> String) -> ([Bytes a] -> ShowS) -> Show (Bytes a)
forall a. Show a => Int -> Bytes a -> ShowS
forall a. Show a => [Bytes a] -> ShowS
forall a. Show a => Bytes a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Bytes a -> ShowS
showsPrec :: Int -> Bytes a -> ShowS
$cshow :: forall a. Show a => Bytes a -> String
show :: Bytes a -> String
$cshowList :: forall a. Show a => [Bytes a] -> ShowS
showList :: [Bytes a] -> ShowS
Show, Bytes a -> Bytes a -> Bool
(Bytes a -> Bytes a -> Bool)
-> (Bytes a -> Bytes a -> Bool) -> Eq (Bytes a)
forall a. Eq a => Bytes a -> Bytes a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Bytes a -> Bytes a -> Bool
== :: Bytes a -> Bytes a -> Bool
$c/= :: forall a. Eq a => Bytes a -> Bytes a -> Bool
/= :: Bytes a -> Bytes a -> Bool
Eq, Eq (Bytes a)
Eq (Bytes a) =>
(Bytes a -> Bytes a -> Ordering)
-> (Bytes a -> Bytes a -> Bool)
-> (Bytes a -> Bytes a -> Bool)
-> (Bytes a -> Bytes a -> Bool)
-> (Bytes a -> Bytes a -> Bool)
-> (Bytes a -> Bytes a -> Bytes a)
-> (Bytes a -> Bytes a -> Bytes a)
-> Ord (Bytes a)
Bytes a -> Bytes a -> Bool
Bytes a -> Bytes a -> Ordering
Bytes a -> Bytes a -> Bytes 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 (Bytes a)
forall a. Ord a => Bytes a -> Bytes a -> Bool
forall a. Ord a => Bytes a -> Bytes a -> Ordering
forall a. Ord a => Bytes a -> Bytes a -> Bytes a
$ccompare :: forall a. Ord a => Bytes a -> Bytes a -> Ordering
compare :: Bytes a -> Bytes a -> Ordering
$c< :: forall a. Ord a => Bytes a -> Bytes a -> Bool
< :: Bytes a -> Bytes a -> Bool
$c<= :: forall a. Ord a => Bytes a -> Bytes a -> Bool
<= :: Bytes a -> Bytes a -> Bool
$c> :: forall a. Ord a => Bytes a -> Bytes a -> Bool
> :: Bytes a -> Bytes a -> Bool
$c>= :: forall a. Ord a => Bytes a -> Bytes a -> Bool
>= :: Bytes a -> Bytes a -> Bool
$cmax :: forall a. Ord a => Bytes a -> Bytes a -> Bytes a
max :: Bytes a -> Bytes a -> Bytes a
$cmin :: forall a. Ord a => Bytes a -> Bytes a -> Bytes a
min :: Bytes a -> Bytes a -> Bytes a
Ord, (forall x. Bytes a -> Rep (Bytes a) x)
-> (forall x. Rep (Bytes a) x -> Bytes a) -> Generic (Bytes a)
forall x. Rep (Bytes a) x -> Bytes a
forall x. Bytes a -> Rep (Bytes a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Bytes a) x -> Bytes a
forall a x. Bytes a -> Rep (Bytes a) x
$cfrom :: forall a x. Bytes a -> Rep (Bytes a) x
from :: forall x. Bytes a -> Rep (Bytes a) x
$cto :: forall a x. Rep (Bytes a) x -> Bytes a
to :: forall x. Rep (Bytes a) x -> Bytes a
Generic, Semigroup (Bytes a)
Bytes a
Semigroup (Bytes a) =>
Bytes a
-> (Bytes a -> Bytes a -> Bytes a)
-> ([Bytes a] -> Bytes a)
-> Monoid (Bytes a)
[Bytes a] -> Bytes a
Bytes a -> Bytes a -> Bytes a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (Bytes a)
forall a. Monoid a => Bytes a
forall a. Monoid a => [Bytes a] -> Bytes a
forall a. Monoid a => Bytes a -> Bytes a -> Bytes a
$cmempty :: forall a. Monoid a => Bytes a
mempty :: Bytes a
$cmappend :: forall a. Monoid a => Bytes a -> Bytes a -> Bytes a
mappend :: Bytes a -> Bytes a -> Bytes a
$cmconcat :: forall a. Monoid a => [Bytes a] -> Bytes a
mconcat :: [Bytes a] -> Bytes a
Monoid, Bytes a -> ()
(Bytes a -> ()) -> NFData (Bytes a)
forall a. NFData a => Bytes a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => Bytes a -> ()
rnf :: Bytes a -> ()
NFData, Gen (Bytes a)
Gen (Bytes a) -> (Bytes a -> [Bytes a]) -> Arbitrary (Bytes a)
Bytes a -> [Bytes a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall a. Arbitrary a => Gen (Bytes a)
forall a. Arbitrary a => Bytes a -> [Bytes a]
$carbitrary :: forall a. Arbitrary a => Gen (Bytes a)
arbitrary :: Gen (Bytes a)
$cshrink :: forall a. Arbitrary a => Bytes a -> [Bytes a]
shrink :: Bytes a -> [Bytes a]
Arbitrary,
            (forall a b. (a -> b) -> Bytes a -> Bytes b)
-> (forall a b. a -> Bytes b -> Bytes a) -> Functor Bytes
forall a b. a -> Bytes b -> Bytes a
forall a b. (a -> b) -> Bytes a -> Bytes 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) -> Bytes a -> Bytes b
fmap :: forall a b. (a -> b) -> Bytes a -> Bytes b
$c<$ :: forall a b. a -> Bytes b -> Bytes a
<$ :: forall a b. a -> Bytes b -> Bytes a
Functor, (forall m. Monoid m => Bytes m -> m)
-> (forall m a. Monoid m => (a -> m) -> Bytes a -> m)
-> (forall m a. Monoid m => (a -> m) -> Bytes a -> m)
-> (forall a b. (a -> b -> b) -> b -> Bytes a -> b)
-> (forall a b. (a -> b -> b) -> b -> Bytes a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bytes a -> b)
-> (forall b a. (b -> a -> b) -> b -> Bytes a -> b)
-> (forall a. (a -> a -> a) -> Bytes a -> a)
-> (forall a. (a -> a -> a) -> Bytes a -> a)
-> (forall a. Bytes a -> [a])
-> (forall a. Bytes a -> Bool)
-> (forall a. Bytes a -> Int)
-> (forall a. Eq a => a -> Bytes a -> Bool)
-> (forall a. Ord a => Bytes a -> a)
-> (forall a. Ord a => Bytes a -> a)
-> (forall a. Num a => Bytes a -> a)
-> (forall a. Num a => Bytes a -> a)
-> Foldable Bytes
forall a. Eq a => a -> Bytes a -> Bool
forall a. Num a => Bytes a -> a
forall a. Ord a => Bytes a -> a
forall m. Monoid m => Bytes m -> m
forall a. Bytes a -> Bool
forall a. Bytes a -> Int
forall a. Bytes a -> [a]
forall a. (a -> a -> a) -> Bytes a -> a
forall m a. Monoid m => (a -> m) -> Bytes a -> m
forall b a. (b -> a -> b) -> b -> Bytes a -> b
forall a b. (a -> b -> b) -> b -> Bytes 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 => Bytes m -> m
fold :: forall m. Monoid m => Bytes m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Bytes a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Bytes a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Bytes a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Bytes a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Bytes a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Bytes a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Bytes a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Bytes a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Bytes a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Bytes a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Bytes a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Bytes a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Bytes a -> a
foldr1 :: forall a. (a -> a -> a) -> Bytes a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Bytes a -> a
foldl1 :: forall a. (a -> a -> a) -> Bytes a -> a
$ctoList :: forall a. Bytes a -> [a]
toList :: forall a. Bytes a -> [a]
$cnull :: forall a. Bytes a -> Bool
null :: forall a. Bytes a -> Bool
$clength :: forall a. Bytes a -> Int
length :: forall a. Bytes a -> Int
$celem :: forall a. Eq a => a -> Bytes a -> Bool
elem :: forall a. Eq a => a -> Bytes a -> Bool
$cmaximum :: forall a. Ord a => Bytes a -> a
maximum :: forall a. Ord a => Bytes a -> a
$cminimum :: forall a. Ord a => Bytes a -> a
minimum :: forall a. Ord a => Bytes a -> a
$csum :: forall a. Num a => Bytes a -> a
sum :: forall a. Num a => Bytes a -> a
$cproduct :: forall a. Num a => Bytes a -> a
product :: forall a. Num a => Bytes a -> a
Foldable, NonEmpty (Bytes a) -> Bytes a
Bytes a -> Bytes a -> Bytes a
(Bytes a -> Bytes a -> Bytes a)
-> (NonEmpty (Bytes a) -> Bytes a)
-> (forall b. Integral b => b -> Bytes a -> Bytes a)
-> Semigroup (Bytes a)
forall b. Integral b => b -> Bytes a -> Bytes a
forall a. Semigroup a => NonEmpty (Bytes a) -> Bytes a
forall a. Semigroup a => Bytes a -> Bytes a -> Bytes a
forall a b. (Semigroup a, Integral b) => b -> Bytes a -> Bytes a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: forall a. Semigroup a => Bytes a -> Bytes a -> Bytes a
<> :: Bytes a -> Bytes a -> Bytes a
$csconcat :: forall a. Semigroup a => NonEmpty (Bytes a) -> Bytes a
sconcat :: NonEmpty (Bytes a) -> Bytes a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Bytes a -> Bytes a
stimes :: forall b. Integral b => b -> Bytes a -> Bytes a
Semigroup, Functor Bytes
Foldable Bytes
(Functor Bytes, Foldable Bytes) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Bytes a -> f (Bytes b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Bytes (f a) -> f (Bytes a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Bytes a -> m (Bytes b))
-> (forall (m :: * -> *) a. Monad m => Bytes (m a) -> m (Bytes a))
-> Traversable Bytes
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 => Bytes (m a) -> m (Bytes a)
forall (f :: * -> *) a. Applicative f => Bytes (f a) -> f (Bytes a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bytes a -> m (Bytes b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bytes a -> f (Bytes b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bytes a -> f (Bytes b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Bytes a -> f (Bytes b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Bytes (f a) -> f (Bytes a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Bytes (f a) -> f (Bytes a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bytes a -> m (Bytes b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Bytes a -> m (Bytes b)
$csequence :: forall (m :: * -> *) a. Monad m => Bytes (m a) -> m (Bytes a)
sequence :: forall (m :: * -> *) a. Monad m => Bytes (m a) -> m (Bytes a)
Traversable)

-- | 'PackedVec' provides a way to encode packed lists of basic protobuf types into
-- the wire format.
newtype PackedVec a = PackedVec { forall a. PackedVec a -> Vector a
packedvec :: V.Vector a }
  deriving (Int -> PackedVec a -> ShowS
[PackedVec a] -> ShowS
PackedVec a -> String
(Int -> PackedVec a -> ShowS)
-> (PackedVec a -> String)
-> ([PackedVec a] -> ShowS)
-> Show (PackedVec a)
forall a. Show a => Int -> PackedVec a -> ShowS
forall a. Show a => [PackedVec a] -> ShowS
forall a. Show a => PackedVec a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> PackedVec a -> ShowS
showsPrec :: Int -> PackedVec a -> ShowS
$cshow :: forall a. Show a => PackedVec a -> String
show :: PackedVec a -> String
$cshowList :: forall a. Show a => [PackedVec a] -> ShowS
showList :: [PackedVec a] -> ShowS
Show, PackedVec a -> PackedVec a -> Bool
(PackedVec a -> PackedVec a -> Bool)
-> (PackedVec a -> PackedVec a -> Bool) -> Eq (PackedVec a)
forall a. Eq a => PackedVec a -> PackedVec a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => PackedVec a -> PackedVec a -> Bool
== :: PackedVec a -> PackedVec a -> Bool
$c/= :: forall a. Eq a => PackedVec a -> PackedVec a -> Bool
/= :: PackedVec a -> PackedVec a -> Bool
Eq, (forall a b. (a -> b) -> PackedVec a -> PackedVec b)
-> (forall a b. a -> PackedVec b -> PackedVec a)
-> Functor PackedVec
forall a b. a -> PackedVec b -> PackedVec a
forall a b. (a -> b) -> PackedVec a -> PackedVec 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) -> PackedVec a -> PackedVec b
fmap :: forall a b. (a -> b) -> PackedVec a -> PackedVec b
$c<$ :: forall a b. a -> PackedVec b -> PackedVec a
<$ :: forall a b. a -> PackedVec b -> PackedVec a
Functor, (forall m. Monoid m => PackedVec m -> m)
-> (forall m a. Monoid m => (a -> m) -> PackedVec a -> m)
-> (forall m a. Monoid m => (a -> m) -> PackedVec a -> m)
-> (forall a b. (a -> b -> b) -> b -> PackedVec a -> b)
-> (forall a b. (a -> b -> b) -> b -> PackedVec a -> b)
-> (forall b a. (b -> a -> b) -> b -> PackedVec a -> b)
-> (forall b a. (b -> a -> b) -> b -> PackedVec a -> b)
-> (forall a. (a -> a -> a) -> PackedVec a -> a)
-> (forall a. (a -> a -> a) -> PackedVec a -> a)
-> (forall a. PackedVec a -> [a])
-> (forall a. PackedVec a -> Bool)
-> (forall a. PackedVec a -> Int)
-> (forall a. Eq a => a -> PackedVec a -> Bool)
-> (forall a. Ord a => PackedVec a -> a)
-> (forall a. Ord a => PackedVec a -> a)
-> (forall a. Num a => PackedVec a -> a)
-> (forall a. Num a => PackedVec a -> a)
-> Foldable PackedVec
forall a. Eq a => a -> PackedVec a -> Bool
forall a. Num a => PackedVec a -> a
forall a. Ord a => PackedVec a -> a
forall m. Monoid m => PackedVec m -> m
forall a. PackedVec a -> Bool
forall a. PackedVec a -> Int
forall a. PackedVec a -> [a]
forall a. (a -> a -> a) -> PackedVec a -> a
forall m a. Monoid m => (a -> m) -> PackedVec a -> m
forall b a. (b -> a -> b) -> b -> PackedVec a -> b
forall a b. (a -> b -> b) -> b -> PackedVec 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 => PackedVec m -> m
fold :: forall m. Monoid m => PackedVec m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PackedVec a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PackedVec a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PackedVec a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PackedVec a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> PackedVec a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PackedVec a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PackedVec a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PackedVec a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PackedVec a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PackedVec a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PackedVec a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PackedVec a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> PackedVec a -> a
foldr1 :: forall a. (a -> a -> a) -> PackedVec a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PackedVec a -> a
foldl1 :: forall a. (a -> a -> a) -> PackedVec a -> a
$ctoList :: forall a. PackedVec a -> [a]
toList :: forall a. PackedVec a -> [a]
$cnull :: forall a. PackedVec a -> Bool
null :: forall a. PackedVec a -> Bool
$clength :: forall a. PackedVec a -> Int
length :: forall a. PackedVec a -> Int
$celem :: forall a. Eq a => a -> PackedVec a -> Bool
elem :: forall a. Eq a => a -> PackedVec a -> Bool
$cmaximum :: forall a. Ord a => PackedVec a -> a
maximum :: forall a. Ord a => PackedVec a -> a
$cminimum :: forall a. Ord a => PackedVec a -> a
minimum :: forall a. Ord a => PackedVec a -> a
$csum :: forall a. Num a => PackedVec a -> a
sum :: forall a. Num a => PackedVec a -> a
$cproduct :: forall a. Num a => PackedVec a -> a
product :: forall a. Num a => PackedVec a -> a
Foldable, Functor PackedVec
Foldable PackedVec
(Functor PackedVec, Foldable PackedVec) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> PackedVec a -> f (PackedVec b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PackedVec (f a) -> f (PackedVec a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PackedVec a -> m (PackedVec b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PackedVec (m a) -> m (PackedVec a))
-> Traversable PackedVec
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 =>
PackedVec (m a) -> m (PackedVec a)
forall (f :: * -> *) a.
Applicative f =>
PackedVec (f a) -> f (PackedVec a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PackedVec a -> m (PackedVec b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PackedVec a -> f (PackedVec b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PackedVec a -> f (PackedVec b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PackedVec a -> f (PackedVec b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PackedVec (f a) -> f (PackedVec a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PackedVec (f a) -> f (PackedVec a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PackedVec a -> m (PackedVec b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PackedVec a -> m (PackedVec b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
PackedVec (m a) -> m (PackedVec a)
sequence :: forall (m :: * -> *) a.
Monad m =>
PackedVec (m a) -> m (PackedVec a)
Traversable, Eq (PackedVec a)
Eq (PackedVec a) =>
(PackedVec a -> PackedVec a -> Ordering)
-> (PackedVec a -> PackedVec a -> Bool)
-> (PackedVec a -> PackedVec a -> Bool)
-> (PackedVec a -> PackedVec a -> Bool)
-> (PackedVec a -> PackedVec a -> Bool)
-> (PackedVec a -> PackedVec a -> PackedVec a)
-> (PackedVec a -> PackedVec a -> PackedVec a)
-> Ord (PackedVec a)
PackedVec a -> PackedVec a -> Bool
PackedVec a -> PackedVec a -> Ordering
PackedVec a -> PackedVec a -> PackedVec 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 (PackedVec a)
forall a. Ord a => PackedVec a -> PackedVec a -> Bool
forall a. Ord a => PackedVec a -> PackedVec a -> Ordering
forall a. Ord a => PackedVec a -> PackedVec a -> PackedVec a
$ccompare :: forall a. Ord a => PackedVec a -> PackedVec a -> Ordering
compare :: PackedVec a -> PackedVec a -> Ordering
$c< :: forall a. Ord a => PackedVec a -> PackedVec a -> Bool
< :: PackedVec a -> PackedVec a -> Bool
$c<= :: forall a. Ord a => PackedVec a -> PackedVec a -> Bool
<= :: PackedVec a -> PackedVec a -> Bool
$c> :: forall a. Ord a => PackedVec a -> PackedVec a -> Bool
> :: PackedVec a -> PackedVec a -> Bool
$c>= :: forall a. Ord a => PackedVec a -> PackedVec a -> Bool
>= :: PackedVec a -> PackedVec a -> Bool
$cmax :: forall a. Ord a => PackedVec a -> PackedVec a -> PackedVec a
max :: PackedVec a -> PackedVec a -> PackedVec a
$cmin :: forall a. Ord a => PackedVec a -> PackedVec a -> PackedVec a
min :: PackedVec a -> PackedVec a -> PackedVec a
Ord, PackedVec a -> ()
(PackedVec a -> ()) -> NFData (PackedVec a)
forall a. NFData a => PackedVec a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => PackedVec a -> ()
rnf :: PackedVec a -> ()
NFData, Functor PackedVec
Functor PackedVec =>
(forall a. a -> PackedVec a)
-> (forall a b. PackedVec (a -> b) -> PackedVec a -> PackedVec b)
-> (forall a b c.
    (a -> b -> c) -> PackedVec a -> PackedVec b -> PackedVec c)
-> (forall a b. PackedVec a -> PackedVec b -> PackedVec b)
-> (forall a b. PackedVec a -> PackedVec b -> PackedVec a)
-> Applicative PackedVec
forall a. a -> PackedVec a
forall a b. PackedVec a -> PackedVec b -> PackedVec a
forall a b. PackedVec a -> PackedVec b -> PackedVec b
forall a b. PackedVec (a -> b) -> PackedVec a -> PackedVec b
forall a b c.
(a -> b -> c) -> PackedVec a -> PackedVec b -> PackedVec c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> PackedVec a
pure :: forall a. a -> PackedVec a
$c<*> :: forall a b. PackedVec (a -> b) -> PackedVec a -> PackedVec b
<*> :: forall a b. PackedVec (a -> b) -> PackedVec a -> PackedVec b
$cliftA2 :: forall a b c.
(a -> b -> c) -> PackedVec a -> PackedVec b -> PackedVec c
liftA2 :: forall a b c.
(a -> b -> c) -> PackedVec a -> PackedVec b -> PackedVec c
$c*> :: forall a b. PackedVec a -> PackedVec b -> PackedVec b
*> :: forall a b. PackedVec a -> PackedVec b -> PackedVec b
$c<* :: forall a b. PackedVec a -> PackedVec b -> PackedVec a
<* :: forall a b. PackedVec a -> PackedVec b -> PackedVec a
Applicative,
            Applicative PackedVec
Applicative PackedVec =>
(forall a. PackedVec a)
-> (forall a. PackedVec a -> PackedVec a -> PackedVec a)
-> (forall a. PackedVec a -> PackedVec [a])
-> (forall a. PackedVec a -> PackedVec [a])
-> Alternative PackedVec
forall a. PackedVec a
forall a. PackedVec a -> PackedVec [a]
forall a. PackedVec a -> PackedVec a -> PackedVec a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
$cempty :: forall a. PackedVec a
empty :: forall a. PackedVec a
$c<|> :: forall a. PackedVec a -> PackedVec a -> PackedVec a
<|> :: forall a. PackedVec a -> PackedVec a -> PackedVec a
$csome :: forall a. PackedVec a -> PackedVec [a]
some :: forall a. PackedVec a -> PackedVec [a]
$cmany :: forall a. PackedVec a -> PackedVec [a]
many :: forall a. PackedVec a -> PackedVec [a]
Alternative, Semigroup (PackedVec a)
PackedVec a
Semigroup (PackedVec a) =>
PackedVec a
-> (PackedVec a -> PackedVec a -> PackedVec a)
-> ([PackedVec a] -> PackedVec a)
-> Monoid (PackedVec a)
[PackedVec a] -> PackedVec a
PackedVec a -> PackedVec a -> PackedVec a
forall a. Semigroup (PackedVec a)
forall a. PackedVec a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [PackedVec a] -> PackedVec a
forall a. PackedVec a -> PackedVec a -> PackedVec a
$cmempty :: forall a. PackedVec a
mempty :: PackedVec a
$cmappend :: forall a. PackedVec a -> PackedVec a -> PackedVec a
mappend :: PackedVec a -> PackedVec a -> PackedVec a
$cmconcat :: forall a. [PackedVec a] -> PackedVec a
mconcat :: [PackedVec a] -> PackedVec a
Monoid, NonEmpty (PackedVec a) -> PackedVec a
PackedVec a -> PackedVec a -> PackedVec a
(PackedVec a -> PackedVec a -> PackedVec a)
-> (NonEmpty (PackedVec a) -> PackedVec a)
-> (forall b. Integral b => b -> PackedVec a -> PackedVec a)
-> Semigroup (PackedVec a)
forall b. Integral b => b -> PackedVec a -> PackedVec a
forall a. NonEmpty (PackedVec a) -> PackedVec a
forall a. PackedVec a -> PackedVec a -> PackedVec a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> PackedVec a -> PackedVec a
$c<> :: forall a. PackedVec a -> PackedVec a -> PackedVec a
<> :: PackedVec a -> PackedVec a -> PackedVec a
$csconcat :: forall a. NonEmpty (PackedVec a) -> PackedVec a
sconcat :: NonEmpty (PackedVec a) -> PackedVec a
$cstimes :: forall a b. Integral b => b -> PackedVec a -> PackedVec a
stimes :: forall b. Integral b => b -> PackedVec a -> PackedVec a
Semigroup)

instance IsList (PackedVec a) where
  type Item (PackedVec a) = a
  fromList :: [Item (PackedVec a)] -> PackedVec a
fromList = Vector a -> PackedVec a
forall a. Vector a -> PackedVec a
PackedVec (Vector a -> PackedVec a)
-> ([a] -> Vector a) -> [a] -> PackedVec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Vector a
forall a. [a] -> Vector a
V.fromList
  toList :: PackedVec a -> [Item (PackedVec a)]
toList = Vector a -> [a]
forall a. Vector a -> [a]
V.toList (Vector a -> [a])
-> (PackedVec a -> Vector a) -> PackedVec a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackedVec a -> Vector a
forall a. PackedVec a -> Vector a
packedvec

instance Arbitrary a => Arbitrary (PackedVec a) where
  arbitrary :: Gen (PackedVec a)
arbitrary = ([a] -> PackedVec a) -> Gen [a] -> Gen (PackedVec a)
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Vector a -> PackedVec a
forall a. Vector a -> PackedVec a
PackedVec (Vector a -> PackedVec a)
-> ([a] -> Vector a) -> [a] -> PackedVec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Vector a
forall a. [a] -> Vector a
V.fromList) Gen [a]
forall a. Arbitrary a => Gen a
arbitrary

newtype UnpackedVec a = UnpackedVec {forall a. UnpackedVec a -> Vector a
unpackedvec :: V.Vector a }
  deriving (Int -> UnpackedVec a -> ShowS
[UnpackedVec a] -> ShowS
UnpackedVec a -> String
(Int -> UnpackedVec a -> ShowS)
-> (UnpackedVec a -> String)
-> ([UnpackedVec a] -> ShowS)
-> Show (UnpackedVec a)
forall a. Show a => Int -> UnpackedVec a -> ShowS
forall a. Show a => [UnpackedVec a] -> ShowS
forall a. Show a => UnpackedVec a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> UnpackedVec a -> ShowS
showsPrec :: Int -> UnpackedVec a -> ShowS
$cshow :: forall a. Show a => UnpackedVec a -> String
show :: UnpackedVec a -> String
$cshowList :: forall a. Show a => [UnpackedVec a] -> ShowS
showList :: [UnpackedVec a] -> ShowS
Show, UnpackedVec a -> UnpackedVec a -> Bool
(UnpackedVec a -> UnpackedVec a -> Bool)
-> (UnpackedVec a -> UnpackedVec a -> Bool) -> Eq (UnpackedVec a)
forall a. Eq a => UnpackedVec a -> UnpackedVec a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => UnpackedVec a -> UnpackedVec a -> Bool
== :: UnpackedVec a -> UnpackedVec a -> Bool
$c/= :: forall a. Eq a => UnpackedVec a -> UnpackedVec a -> Bool
/= :: UnpackedVec a -> UnpackedVec a -> Bool
Eq, (forall a b. (a -> b) -> UnpackedVec a -> UnpackedVec b)
-> (forall a b. a -> UnpackedVec b -> UnpackedVec a)
-> Functor UnpackedVec
forall a b. a -> UnpackedVec b -> UnpackedVec a
forall a b. (a -> b) -> UnpackedVec a -> UnpackedVec 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) -> UnpackedVec a -> UnpackedVec b
fmap :: forall a b. (a -> b) -> UnpackedVec a -> UnpackedVec b
$c<$ :: forall a b. a -> UnpackedVec b -> UnpackedVec a
<$ :: forall a b. a -> UnpackedVec b -> UnpackedVec a
Functor, (forall m. Monoid m => UnpackedVec m -> m)
-> (forall m a. Monoid m => (a -> m) -> UnpackedVec a -> m)
-> (forall m a. Monoid m => (a -> m) -> UnpackedVec a -> m)
-> (forall a b. (a -> b -> b) -> b -> UnpackedVec a -> b)
-> (forall a b. (a -> b -> b) -> b -> UnpackedVec a -> b)
-> (forall b a. (b -> a -> b) -> b -> UnpackedVec a -> b)
-> (forall b a. (b -> a -> b) -> b -> UnpackedVec a -> b)
-> (forall a. (a -> a -> a) -> UnpackedVec a -> a)
-> (forall a. (a -> a -> a) -> UnpackedVec a -> a)
-> (forall a. UnpackedVec a -> [a])
-> (forall a. UnpackedVec a -> Bool)
-> (forall a. UnpackedVec a -> Int)
-> (forall a. Eq a => a -> UnpackedVec a -> Bool)
-> (forall a. Ord a => UnpackedVec a -> a)
-> (forall a. Ord a => UnpackedVec a -> a)
-> (forall a. Num a => UnpackedVec a -> a)
-> (forall a. Num a => UnpackedVec a -> a)
-> Foldable UnpackedVec
forall a. Eq a => a -> UnpackedVec a -> Bool
forall a. Num a => UnpackedVec a -> a
forall a. Ord a => UnpackedVec a -> a
forall m. Monoid m => UnpackedVec m -> m
forall a. UnpackedVec a -> Bool
forall a. UnpackedVec a -> Int
forall a. UnpackedVec a -> [a]
forall a. (a -> a -> a) -> UnpackedVec a -> a
forall m a. Monoid m => (a -> m) -> UnpackedVec a -> m
forall b a. (b -> a -> b) -> b -> UnpackedVec a -> b
forall a b. (a -> b -> b) -> b -> UnpackedVec 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 => UnpackedVec m -> m
fold :: forall m. Monoid m => UnpackedVec m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> UnpackedVec a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> UnpackedVec a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> UnpackedVec a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> UnpackedVec a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> UnpackedVec a -> b
foldr :: forall a b. (a -> b -> b) -> b -> UnpackedVec a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> UnpackedVec a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> UnpackedVec a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> UnpackedVec a -> b
foldl :: forall b a. (b -> a -> b) -> b -> UnpackedVec a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> UnpackedVec a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> UnpackedVec a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> UnpackedVec a -> a
foldr1 :: forall a. (a -> a -> a) -> UnpackedVec a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> UnpackedVec a -> a
foldl1 :: forall a. (a -> a -> a) -> UnpackedVec a -> a
$ctoList :: forall a. UnpackedVec a -> [a]
toList :: forall a. UnpackedVec a -> [a]
$cnull :: forall a. UnpackedVec a -> Bool
null :: forall a. UnpackedVec a -> Bool
$clength :: forall a. UnpackedVec a -> Int
length :: forall a. UnpackedVec a -> Int
$celem :: forall a. Eq a => a -> UnpackedVec a -> Bool
elem :: forall a. Eq a => a -> UnpackedVec a -> Bool
$cmaximum :: forall a. Ord a => UnpackedVec a -> a
maximum :: forall a. Ord a => UnpackedVec a -> a
$cminimum :: forall a. Ord a => UnpackedVec a -> a
minimum :: forall a. Ord a => UnpackedVec a -> a
$csum :: forall a. Num a => UnpackedVec a -> a
sum :: forall a. Num a => UnpackedVec a -> a
$cproduct :: forall a. Num a => UnpackedVec a -> a
product :: forall a. Num a => UnpackedVec a -> a
Foldable, Functor UnpackedVec
Foldable UnpackedVec
(Functor UnpackedVec, Foldable UnpackedVec) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> UnpackedVec a -> f (UnpackedVec b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    UnpackedVec (f a) -> f (UnpackedVec a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> UnpackedVec a -> m (UnpackedVec b))
-> (forall (m :: * -> *) a.
    Monad m =>
    UnpackedVec (m a) -> m (UnpackedVec a))
-> Traversable UnpackedVec
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 =>
UnpackedVec (m a) -> m (UnpackedVec a)
forall (f :: * -> *) a.
Applicative f =>
UnpackedVec (f a) -> f (UnpackedVec a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UnpackedVec a -> m (UnpackedVec b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UnpackedVec a -> f (UnpackedVec b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UnpackedVec a -> f (UnpackedVec b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UnpackedVec a -> f (UnpackedVec b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
UnpackedVec (f a) -> f (UnpackedVec a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
UnpackedVec (f a) -> f (UnpackedVec a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UnpackedVec a -> m (UnpackedVec b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UnpackedVec a -> m (UnpackedVec b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
UnpackedVec (m a) -> m (UnpackedVec a)
sequence :: forall (m :: * -> *) a.
Monad m =>
UnpackedVec (m a) -> m (UnpackedVec a)
Traversable, Eq (UnpackedVec a)
Eq (UnpackedVec a) =>
(UnpackedVec a -> UnpackedVec a -> Ordering)
-> (UnpackedVec a -> UnpackedVec a -> Bool)
-> (UnpackedVec a -> UnpackedVec a -> Bool)
-> (UnpackedVec a -> UnpackedVec a -> Bool)
-> (UnpackedVec a -> UnpackedVec a -> Bool)
-> (UnpackedVec a -> UnpackedVec a -> UnpackedVec a)
-> (UnpackedVec a -> UnpackedVec a -> UnpackedVec a)
-> Ord (UnpackedVec a)
UnpackedVec a -> UnpackedVec a -> Bool
UnpackedVec a -> UnpackedVec a -> Ordering
UnpackedVec a -> UnpackedVec a -> UnpackedVec 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 (UnpackedVec a)
forall a. Ord a => UnpackedVec a -> UnpackedVec a -> Bool
forall a. Ord a => UnpackedVec a -> UnpackedVec a -> Ordering
forall a. Ord a => UnpackedVec a -> UnpackedVec a -> UnpackedVec a
$ccompare :: forall a. Ord a => UnpackedVec a -> UnpackedVec a -> Ordering
compare :: UnpackedVec a -> UnpackedVec a -> Ordering
$c< :: forall a. Ord a => UnpackedVec a -> UnpackedVec a -> Bool
< :: UnpackedVec a -> UnpackedVec a -> Bool
$c<= :: forall a. Ord a => UnpackedVec a -> UnpackedVec a -> Bool
<= :: UnpackedVec a -> UnpackedVec a -> Bool
$c> :: forall a. Ord a => UnpackedVec a -> UnpackedVec a -> Bool
> :: UnpackedVec a -> UnpackedVec a -> Bool
$c>= :: forall a. Ord a => UnpackedVec a -> UnpackedVec a -> Bool
>= :: UnpackedVec a -> UnpackedVec a -> Bool
$cmax :: forall a. Ord a => UnpackedVec a -> UnpackedVec a -> UnpackedVec a
max :: UnpackedVec a -> UnpackedVec a -> UnpackedVec a
$cmin :: forall a. Ord a => UnpackedVec a -> UnpackedVec a -> UnpackedVec a
min :: UnpackedVec a -> UnpackedVec a -> UnpackedVec a
Ord, UnpackedVec a -> ()
(UnpackedVec a -> ()) -> NFData (UnpackedVec a)
forall a. NFData a => UnpackedVec a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => UnpackedVec a -> ()
rnf :: UnpackedVec a -> ()
NFData, Functor UnpackedVec
Functor UnpackedVec =>
(forall a. a -> UnpackedVec a)
-> (forall a b.
    UnpackedVec (a -> b) -> UnpackedVec a -> UnpackedVec b)
-> (forall a b c.
    (a -> b -> c) -> UnpackedVec a -> UnpackedVec b -> UnpackedVec c)
-> (forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec b)
-> (forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec a)
-> Applicative UnpackedVec
forall a. a -> UnpackedVec a
forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec a
forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec b
forall a b. UnpackedVec (a -> b) -> UnpackedVec a -> UnpackedVec b
forall a b c.
(a -> b -> c) -> UnpackedVec a -> UnpackedVec b -> UnpackedVec c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> UnpackedVec a
pure :: forall a. a -> UnpackedVec a
$c<*> :: forall a b. UnpackedVec (a -> b) -> UnpackedVec a -> UnpackedVec b
<*> :: forall a b. UnpackedVec (a -> b) -> UnpackedVec a -> UnpackedVec b
$cliftA2 :: forall a b c.
(a -> b -> c) -> UnpackedVec a -> UnpackedVec b -> UnpackedVec c
liftA2 :: forall a b c.
(a -> b -> c) -> UnpackedVec a -> UnpackedVec b -> UnpackedVec c
$c*> :: forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec b
*> :: forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec b
$c<* :: forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec a
<* :: forall a b. UnpackedVec a -> UnpackedVec b -> UnpackedVec a
Applicative,
            Applicative UnpackedVec
Applicative UnpackedVec =>
(forall a. UnpackedVec a)
-> (forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a)
-> (forall a. UnpackedVec a -> UnpackedVec [a])
-> (forall a. UnpackedVec a -> UnpackedVec [a])
-> Alternative UnpackedVec
forall a. UnpackedVec a
forall a. UnpackedVec a -> UnpackedVec [a]
forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
$cempty :: forall a. UnpackedVec a
empty :: forall a. UnpackedVec a
$c<|> :: forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a
<|> :: forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a
$csome :: forall a. UnpackedVec a -> UnpackedVec [a]
some :: forall a. UnpackedVec a -> UnpackedVec [a]
$cmany :: forall a. UnpackedVec a -> UnpackedVec [a]
many :: forall a. UnpackedVec a -> UnpackedVec [a]
Alternative, Semigroup (UnpackedVec a)
UnpackedVec a
Semigroup (UnpackedVec a) =>
UnpackedVec a
-> (UnpackedVec a -> UnpackedVec a -> UnpackedVec a)
-> ([UnpackedVec a] -> UnpackedVec a)
-> Monoid (UnpackedVec a)
[UnpackedVec a] -> UnpackedVec a
UnpackedVec a -> UnpackedVec a -> UnpackedVec a
forall a. Semigroup (UnpackedVec a)
forall a. UnpackedVec a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [UnpackedVec a] -> UnpackedVec a
forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a
$cmempty :: forall a. UnpackedVec a
mempty :: UnpackedVec a
$cmappend :: forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a
mappend :: UnpackedVec a -> UnpackedVec a -> UnpackedVec a
$cmconcat :: forall a. [UnpackedVec a] -> UnpackedVec a
mconcat :: [UnpackedVec a] -> UnpackedVec a
Monoid, NonEmpty (UnpackedVec a) -> UnpackedVec a
UnpackedVec a -> UnpackedVec a -> UnpackedVec a
(UnpackedVec a -> UnpackedVec a -> UnpackedVec a)
-> (NonEmpty (UnpackedVec a) -> UnpackedVec a)
-> (forall b. Integral b => b -> UnpackedVec a -> UnpackedVec a)
-> Semigroup (UnpackedVec a)
forall b. Integral b => b -> UnpackedVec a -> UnpackedVec a
forall a. NonEmpty (UnpackedVec a) -> UnpackedVec a
forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> UnpackedVec a -> UnpackedVec a
$c<> :: forall a. UnpackedVec a -> UnpackedVec a -> UnpackedVec a
<> :: UnpackedVec a -> UnpackedVec a -> UnpackedVec a
$csconcat :: forall a. NonEmpty (UnpackedVec a) -> UnpackedVec a
sconcat :: NonEmpty (UnpackedVec a) -> UnpackedVec a
$cstimes :: forall a b. Integral b => b -> UnpackedVec a -> UnpackedVec a
stimes :: forall b. Integral b => b -> UnpackedVec a -> UnpackedVec a
Semigroup)

instance IsList (UnpackedVec a) where
  type Item (UnpackedVec a) = a
  fromList :: [Item (UnpackedVec a)] -> UnpackedVec a
fromList = Vector a -> UnpackedVec a
forall a. Vector a -> UnpackedVec a
UnpackedVec (Vector a -> UnpackedVec a)
-> ([a] -> Vector a) -> [a] -> UnpackedVec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Vector a
forall a. [a] -> Vector a
V.fromList
  toList :: UnpackedVec a -> [Item (UnpackedVec a)]
toList = Vector a -> [a]
forall a. Vector a -> [a]
V.toList (Vector a -> [a])
-> (UnpackedVec a -> Vector a) -> UnpackedVec a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnpackedVec a -> Vector a
forall a. UnpackedVec a -> Vector a
unpackedvec

instance Arbitrary a => Arbitrary (UnpackedVec a) where
  arbitrary :: Gen (UnpackedVec a)
arbitrary = ([a] -> UnpackedVec a) -> Gen [a] -> Gen (UnpackedVec a)
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Vector a -> UnpackedVec a
forall a. Vector a -> UnpackedVec a
UnpackedVec (Vector a -> UnpackedVec a)
-> ([a] -> Vector a) -> [a] -> UnpackedVec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Vector a
forall a. [a] -> Vector a
V.fromList) Gen [a]
forall a. Arbitrary a => Gen a
arbitrary

newtype NestedVec a =
  NestedVec { forall a. NestedVec a -> Vector a
nestedvec :: V.Vector a }
  deriving (Int -> NestedVec a -> ShowS
[NestedVec a] -> ShowS
NestedVec a -> String
(Int -> NestedVec a -> ShowS)
-> (NestedVec a -> String)
-> ([NestedVec a] -> ShowS)
-> Show (NestedVec a)
forall a. Show a => Int -> NestedVec a -> ShowS
forall a. Show a => [NestedVec a] -> ShowS
forall a. Show a => NestedVec a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> NestedVec a -> ShowS
showsPrec :: Int -> NestedVec a -> ShowS
$cshow :: forall a. Show a => NestedVec a -> String
show :: NestedVec a -> String
$cshowList :: forall a. Show a => [NestedVec a] -> ShowS
showList :: [NestedVec a] -> ShowS
Show, NestedVec a -> NestedVec a -> Bool
(NestedVec a -> NestedVec a -> Bool)
-> (NestedVec a -> NestedVec a -> Bool) -> Eq (NestedVec a)
forall a. Eq a => NestedVec a -> NestedVec a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => NestedVec a -> NestedVec a -> Bool
== :: NestedVec a -> NestedVec a -> Bool
$c/= :: forall a. Eq a => NestedVec a -> NestedVec a -> Bool
/= :: NestedVec a -> NestedVec a -> Bool
Eq, (forall a b. (a -> b) -> NestedVec a -> NestedVec b)
-> (forall a b. a -> NestedVec b -> NestedVec a)
-> Functor NestedVec
forall a b. a -> NestedVec b -> NestedVec a
forall a b. (a -> b) -> NestedVec a -> NestedVec 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) -> NestedVec a -> NestedVec b
fmap :: forall a b. (a -> b) -> NestedVec a -> NestedVec b
$c<$ :: forall a b. a -> NestedVec b -> NestedVec a
<$ :: forall a b. a -> NestedVec b -> NestedVec a
Functor, (forall m. Monoid m => NestedVec m -> m)
-> (forall m a. Monoid m => (a -> m) -> NestedVec a -> m)
-> (forall m a. Monoid m => (a -> m) -> NestedVec a -> m)
-> (forall a b. (a -> b -> b) -> b -> NestedVec a -> b)
-> (forall a b. (a -> b -> b) -> b -> NestedVec a -> b)
-> (forall b a. (b -> a -> b) -> b -> NestedVec a -> b)
-> (forall b a. (b -> a -> b) -> b -> NestedVec a -> b)
-> (forall a. (a -> a -> a) -> NestedVec a -> a)
-> (forall a. (a -> a -> a) -> NestedVec a -> a)
-> (forall a. NestedVec a -> [a])
-> (forall a. NestedVec a -> Bool)
-> (forall a. NestedVec a -> Int)
-> (forall a. Eq a => a -> NestedVec a -> Bool)
-> (forall a. Ord a => NestedVec a -> a)
-> (forall a. Ord a => NestedVec a -> a)
-> (forall a. Num a => NestedVec a -> a)
-> (forall a. Num a => NestedVec a -> a)
-> Foldable NestedVec
forall a. Eq a => a -> NestedVec a -> Bool
forall a. Num a => NestedVec a -> a
forall a. Ord a => NestedVec a -> a
forall m. Monoid m => NestedVec m -> m
forall a. NestedVec a -> Bool
forall a. NestedVec a -> Int
forall a. NestedVec a -> [a]
forall a. (a -> a -> a) -> NestedVec a -> a
forall m a. Monoid m => (a -> m) -> NestedVec a -> m
forall b a. (b -> a -> b) -> b -> NestedVec a -> b
forall a b. (a -> b -> b) -> b -> NestedVec 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 => NestedVec m -> m
fold :: forall m. Monoid m => NestedVec m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> NestedVec a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> NestedVec a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> NestedVec a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> NestedVec a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> NestedVec a -> b
foldr :: forall a b. (a -> b -> b) -> b -> NestedVec a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> NestedVec a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> NestedVec a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> NestedVec a -> b
foldl :: forall b a. (b -> a -> b) -> b -> NestedVec a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> NestedVec a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> NestedVec a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> NestedVec a -> a
foldr1 :: forall a. (a -> a -> a) -> NestedVec a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> NestedVec a -> a
foldl1 :: forall a. (a -> a -> a) -> NestedVec a -> a
$ctoList :: forall a. NestedVec a -> [a]
toList :: forall a. NestedVec a -> [a]
$cnull :: forall a. NestedVec a -> Bool
null :: forall a. NestedVec a -> Bool
$clength :: forall a. NestedVec a -> Int
length :: forall a. NestedVec a -> Int
$celem :: forall a. Eq a => a -> NestedVec a -> Bool
elem :: forall a. Eq a => a -> NestedVec a -> Bool
$cmaximum :: forall a. Ord a => NestedVec a -> a
maximum :: forall a. Ord a => NestedVec a -> a
$cminimum :: forall a. Ord a => NestedVec a -> a
minimum :: forall a. Ord a => NestedVec a -> a
$csum :: forall a. Num a => NestedVec a -> a
sum :: forall a. Num a => NestedVec a -> a
$cproduct :: forall a. Num a => NestedVec a -> a
product :: forall a. Num a => NestedVec a -> a
Foldable, Functor NestedVec
Foldable NestedVec
(Functor NestedVec, Foldable NestedVec) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NestedVec a -> f (NestedVec b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NestedVec (f a) -> f (NestedVec a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NestedVec a -> m (NestedVec b))
-> (forall (m :: * -> *) a.
    Monad m =>
    NestedVec (m a) -> m (NestedVec a))
-> Traversable NestedVec
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 =>
NestedVec (m a) -> m (NestedVec a)
forall (f :: * -> *) a.
Applicative f =>
NestedVec (f a) -> f (NestedVec a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NestedVec a -> m (NestedVec b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NestedVec a -> f (NestedVec b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NestedVec a -> f (NestedVec b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NestedVec a -> f (NestedVec b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
NestedVec (f a) -> f (NestedVec a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
NestedVec (f a) -> f (NestedVec a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NestedVec a -> m (NestedVec b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NestedVec a -> m (NestedVec b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
NestedVec (m a) -> m (NestedVec a)
sequence :: forall (m :: * -> *) a.
Monad m =>
NestedVec (m a) -> m (NestedVec a)
Traversable, Eq (NestedVec a)
Eq (NestedVec a) =>
(NestedVec a -> NestedVec a -> Ordering)
-> (NestedVec a -> NestedVec a -> Bool)
-> (NestedVec a -> NestedVec a -> Bool)
-> (NestedVec a -> NestedVec a -> Bool)
-> (NestedVec a -> NestedVec a -> Bool)
-> (NestedVec a -> NestedVec a -> NestedVec a)
-> (NestedVec a -> NestedVec a -> NestedVec a)
-> Ord (NestedVec a)
NestedVec a -> NestedVec a -> Bool
NestedVec a -> NestedVec a -> Ordering
NestedVec a -> NestedVec a -> NestedVec 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 (NestedVec a)
forall a. Ord a => NestedVec a -> NestedVec a -> Bool
forall a. Ord a => NestedVec a -> NestedVec a -> Ordering
forall a. Ord a => NestedVec a -> NestedVec a -> NestedVec a
$ccompare :: forall a. Ord a => NestedVec a -> NestedVec a -> Ordering
compare :: NestedVec a -> NestedVec a -> Ordering
$c< :: forall a. Ord a => NestedVec a -> NestedVec a -> Bool
< :: NestedVec a -> NestedVec a -> Bool
$c<= :: forall a. Ord a => NestedVec a -> NestedVec a -> Bool
<= :: NestedVec a -> NestedVec a -> Bool
$c> :: forall a. Ord a => NestedVec a -> NestedVec a -> Bool
> :: NestedVec a -> NestedVec a -> Bool
$c>= :: forall a. Ord a => NestedVec a -> NestedVec a -> Bool
>= :: NestedVec a -> NestedVec a -> Bool
$cmax :: forall a. Ord a => NestedVec a -> NestedVec a -> NestedVec a
max :: NestedVec a -> NestedVec a -> NestedVec a
$cmin :: forall a. Ord a => NestedVec a -> NestedVec a -> NestedVec a
min :: NestedVec a -> NestedVec a -> NestedVec a
Ord, NestedVec a -> ()
(NestedVec a -> ()) -> NFData (NestedVec a)
forall a. NFData a => NestedVec a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => NestedVec a -> ()
rnf :: NestedVec a -> ()
NFData, Functor NestedVec
Functor NestedVec =>
(forall a. a -> NestedVec a)
-> (forall a b. NestedVec (a -> b) -> NestedVec a -> NestedVec b)
-> (forall a b c.
    (a -> b -> c) -> NestedVec a -> NestedVec b -> NestedVec c)
-> (forall a b. NestedVec a -> NestedVec b -> NestedVec b)
-> (forall a b. NestedVec a -> NestedVec b -> NestedVec a)
-> Applicative NestedVec
forall a. a -> NestedVec a
forall a b. NestedVec a -> NestedVec b -> NestedVec a
forall a b. NestedVec a -> NestedVec b -> NestedVec b
forall a b. NestedVec (a -> b) -> NestedVec a -> NestedVec b
forall a b c.
(a -> b -> c) -> NestedVec a -> NestedVec b -> NestedVec c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> NestedVec a
pure :: forall a. a -> NestedVec a
$c<*> :: forall a b. NestedVec (a -> b) -> NestedVec a -> NestedVec b
<*> :: forall a b. NestedVec (a -> b) -> NestedVec a -> NestedVec b
$cliftA2 :: forall a b c.
(a -> b -> c) -> NestedVec a -> NestedVec b -> NestedVec c
liftA2 :: forall a b c.
(a -> b -> c) -> NestedVec a -> NestedVec b -> NestedVec c
$c*> :: forall a b. NestedVec a -> NestedVec b -> NestedVec b
*> :: forall a b. NestedVec a -> NestedVec b -> NestedVec b
$c<* :: forall a b. NestedVec a -> NestedVec b -> NestedVec a
<* :: forall a b. NestedVec a -> NestedVec b -> NestedVec a
Applicative,
            Applicative NestedVec
Applicative NestedVec =>
(forall a. NestedVec a)
-> (forall a. NestedVec a -> NestedVec a -> NestedVec a)
-> (forall a. NestedVec a -> NestedVec [a])
-> (forall a. NestedVec a -> NestedVec [a])
-> Alternative NestedVec
forall a. NestedVec a
forall a. NestedVec a -> NestedVec [a]
forall a. NestedVec a -> NestedVec a -> NestedVec a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
$cempty :: forall a. NestedVec a
empty :: forall a. NestedVec a
$c<|> :: forall a. NestedVec a -> NestedVec a -> NestedVec a
<|> :: forall a. NestedVec a -> NestedVec a -> NestedVec a
$csome :: forall a. NestedVec a -> NestedVec [a]
some :: forall a. NestedVec a -> NestedVec [a]
$cmany :: forall a. NestedVec a -> NestedVec [a]
many :: forall a. NestedVec a -> NestedVec [a]
Alternative, Semigroup (NestedVec a)
NestedVec a
Semigroup (NestedVec a) =>
NestedVec a
-> (NestedVec a -> NestedVec a -> NestedVec a)
-> ([NestedVec a] -> NestedVec a)
-> Monoid (NestedVec a)
[NestedVec a] -> NestedVec a
NestedVec a -> NestedVec a -> NestedVec a
forall a. Semigroup (NestedVec a)
forall a. NestedVec a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [NestedVec a] -> NestedVec a
forall a. NestedVec a -> NestedVec a -> NestedVec a
$cmempty :: forall a. NestedVec a
mempty :: NestedVec a
$cmappend :: forall a. NestedVec a -> NestedVec a -> NestedVec a
mappend :: NestedVec a -> NestedVec a -> NestedVec a
$cmconcat :: forall a. [NestedVec a] -> NestedVec a
mconcat :: [NestedVec a] -> NestedVec a
Monoid, NonEmpty (NestedVec a) -> NestedVec a
NestedVec a -> NestedVec a -> NestedVec a
(NestedVec a -> NestedVec a -> NestedVec a)
-> (NonEmpty (NestedVec a) -> NestedVec a)
-> (forall b. Integral b => b -> NestedVec a -> NestedVec a)
-> Semigroup (NestedVec a)
forall b. Integral b => b -> NestedVec a -> NestedVec a
forall a. NonEmpty (NestedVec a) -> NestedVec a
forall a. NestedVec a -> NestedVec a -> NestedVec a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> NestedVec a -> NestedVec a
$c<> :: forall a. NestedVec a -> NestedVec a -> NestedVec a
<> :: NestedVec a -> NestedVec a -> NestedVec a
$csconcat :: forall a. NonEmpty (NestedVec a) -> NestedVec a
sconcat :: NonEmpty (NestedVec a) -> NestedVec a
$cstimes :: forall a b. Integral b => b -> NestedVec a -> NestedVec a
stimes :: forall b. Integral b => b -> NestedVec a -> NestedVec a
Semigroup)

instance IsList (NestedVec a) where
  type Item (NestedVec a) = a
  fromList :: [Item (NestedVec a)] -> NestedVec a
fromList = Vector a -> NestedVec a
forall a. Vector a -> NestedVec a
NestedVec (Vector a -> NestedVec a)
-> ([a] -> Vector a) -> [a] -> NestedVec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Vector a
forall a. [a] -> Vector a
V.fromList
  toList :: NestedVec a -> [Item (NestedVec a)]
toList = Vector a -> [a]
forall a. Vector a -> [a]
V.toList (Vector a -> [a])
-> (NestedVec a -> Vector a) -> NestedVec a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NestedVec a -> Vector a
forall a. NestedVec a -> Vector a
nestedvec

instance Arbitrary a => Arbitrary (NestedVec a) where
  arbitrary :: Gen (NestedVec a)
arbitrary = ([a] -> NestedVec a) -> Gen [a] -> Gen (NestedVec a)
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Vector a -> NestedVec a
forall a. Vector a -> NestedVec a
NestedVec (Vector a -> NestedVec a)
-> ([a] -> Vector a) -> [a] -> NestedVec a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Vector a
forall a. [a] -> Vector a
V.fromList) Gen [a]
forall a. Arbitrary a => Gen a
arbitrary

-- | 'Nested' provides a way to nest protobuf messages within protobuf messages.
newtype Nested a = Nested { forall a. Nested a -> Maybe a
nested :: Maybe a }
  deriving (Int -> Nested a -> ShowS
[Nested a] -> ShowS
Nested a -> String
(Int -> Nested a -> ShowS)
-> (Nested a -> String) -> ([Nested a] -> ShowS) -> Show (Nested a)
forall a. Show a => Int -> Nested a -> ShowS
forall a. Show a => [Nested a] -> ShowS
forall a. Show a => Nested a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Nested a -> ShowS
showsPrec :: Int -> Nested a -> ShowS
$cshow :: forall a. Show a => Nested a -> String
show :: Nested a -> String
$cshowList :: forall a. Show a => [Nested a] -> ShowS
showList :: [Nested a] -> ShowS
Show, Nested a -> Nested a -> Bool
(Nested a -> Nested a -> Bool)
-> (Nested a -> Nested a -> Bool) -> Eq (Nested a)
forall a. Eq a => Nested a -> Nested a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Nested a -> Nested a -> Bool
== :: Nested a -> Nested a -> Bool
$c/= :: forall a. Eq a => Nested a -> Nested a -> Bool
/= :: Nested a -> Nested a -> Bool
Eq, Eq (Nested a)
Eq (Nested a) =>
(Nested a -> Nested a -> Ordering)
-> (Nested a -> Nested a -> Bool)
-> (Nested a -> Nested a -> Bool)
-> (Nested a -> Nested a -> Bool)
-> (Nested a -> Nested a -> Bool)
-> (Nested a -> Nested a -> Nested a)
-> (Nested a -> Nested a -> Nested a)
-> Ord (Nested a)
Nested a -> Nested a -> Bool
Nested a -> Nested a -> Ordering
Nested a -> Nested a -> Nested 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 (Nested a)
forall a. Ord a => Nested a -> Nested a -> Bool
forall a. Ord a => Nested a -> Nested a -> Ordering
forall a. Ord a => Nested a -> Nested a -> Nested a
$ccompare :: forall a. Ord a => Nested a -> Nested a -> Ordering
compare :: Nested a -> Nested a -> Ordering
$c< :: forall a. Ord a => Nested a -> Nested a -> Bool
< :: Nested a -> Nested a -> Bool
$c<= :: forall a. Ord a => Nested a -> Nested a -> Bool
<= :: Nested a -> Nested a -> Bool
$c> :: forall a. Ord a => Nested a -> Nested a -> Bool
> :: Nested a -> Nested a -> Bool
$c>= :: forall a. Ord a => Nested a -> Nested a -> Bool
>= :: Nested a -> Nested a -> Bool
$cmax :: forall a. Ord a => Nested a -> Nested a -> Nested a
max :: Nested a -> Nested a -> Nested a
$cmin :: forall a. Ord a => Nested a -> Nested a -> Nested a
min :: Nested a -> Nested a -> Nested a
Ord, (forall x. Nested a -> Rep (Nested a) x)
-> (forall x. Rep (Nested a) x -> Nested a) -> Generic (Nested a)
forall x. Rep (Nested a) x -> Nested a
forall x. Nested a -> Rep (Nested a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Nested a) x -> Nested a
forall a x. Nested a -> Rep (Nested a) x
$cfrom :: forall a x. Nested a -> Rep (Nested a) x
from :: forall x. Nested a -> Rep (Nested a) x
$cto :: forall a x. Rep (Nested a) x -> Nested a
to :: forall x. Rep (Nested a) x -> Nested a
Generic, Nested a -> ()
(Nested a -> ()) -> NFData (Nested a)
forall a. NFData a => Nested a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => Nested a -> ()
rnf :: Nested a -> ()
NFData, Semigroup (Nested a)
Nested a
Semigroup (Nested a) =>
Nested a
-> (Nested a -> Nested a -> Nested a)
-> ([Nested a] -> Nested a)
-> Monoid (Nested a)
[Nested a] -> Nested a
Nested a -> Nested a -> Nested a
forall a. Semigroup a => Semigroup (Nested a)
forall a. Semigroup a => Nested a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Semigroup a => [Nested a] -> Nested a
forall a. Semigroup a => Nested a -> Nested a -> Nested a
$cmempty :: forall a. Semigroup a => Nested a
mempty :: Nested a
$cmappend :: forall a. Semigroup a => Nested a -> Nested a -> Nested a
mappend :: Nested a -> Nested a -> Nested a
$cmconcat :: forall a. Semigroup a => [Nested a] -> Nested a
mconcat :: [Nested a] -> Nested a
Monoid, Gen (Nested a)
Gen (Nested a) -> (Nested a -> [Nested a]) -> Arbitrary (Nested a)
Nested a -> [Nested a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall a. Arbitrary a => Gen (Nested a)
forall a. Arbitrary a => Nested a -> [Nested a]
$carbitrary :: forall a. Arbitrary a => Gen (Nested a)
arbitrary :: Gen (Nested a)
$cshrink :: forall a. Arbitrary a => Nested a -> [Nested a]
shrink :: Nested a -> [Nested a]
Arbitrary, (forall a b. (a -> b) -> Nested a -> Nested b)
-> (forall a b. a -> Nested b -> Nested a) -> Functor Nested
forall a b. a -> Nested b -> Nested a
forall a b. (a -> b) -> Nested a -> Nested 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) -> Nested a -> Nested b
fmap :: forall a b. (a -> b) -> Nested a -> Nested b
$c<$ :: forall a b. a -> Nested b -> Nested a
<$ :: forall a b. a -> Nested b -> Nested a
Functor, (forall m. Monoid m => Nested m -> m)
-> (forall m a. Monoid m => (a -> m) -> Nested a -> m)
-> (forall m a. Monoid m => (a -> m) -> Nested a -> m)
-> (forall a b. (a -> b -> b) -> b -> Nested a -> b)
-> (forall a b. (a -> b -> b) -> b -> Nested a -> b)
-> (forall b a. (b -> a -> b) -> b -> Nested a -> b)
-> (forall b a. (b -> a -> b) -> b -> Nested a -> b)
-> (forall a. (a -> a -> a) -> Nested a -> a)
-> (forall a. (a -> a -> a) -> Nested a -> a)
-> (forall a. Nested a -> [a])
-> (forall a. Nested a -> Bool)
-> (forall a. Nested a -> Int)
-> (forall a. Eq a => a -> Nested a -> Bool)
-> (forall a. Ord a => Nested a -> a)
-> (forall a. Ord a => Nested a -> a)
-> (forall a. Num a => Nested a -> a)
-> (forall a. Num a => Nested a -> a)
-> Foldable Nested
forall a. Eq a => a -> Nested a -> Bool
forall a. Num a => Nested a -> a
forall a. Ord a => Nested a -> a
forall m. Monoid m => Nested m -> m
forall a. Nested a -> Bool
forall a. Nested a -> Int
forall a. Nested a -> [a]
forall a. (a -> a -> a) -> Nested a -> a
forall m a. Monoid m => (a -> m) -> Nested a -> m
forall b a. (b -> a -> b) -> b -> Nested a -> b
forall a b. (a -> b -> b) -> b -> Nested 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 => Nested m -> m
fold :: forall m. Monoid m => Nested m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Nested a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Nested a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Nested a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Nested a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Nested a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Nested a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Nested a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Nested a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Nested a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Nested a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Nested a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Nested a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Nested a -> a
foldr1 :: forall a. (a -> a -> a) -> Nested a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Nested a -> a
foldl1 :: forall a. (a -> a -> a) -> Nested a -> a
$ctoList :: forall a. Nested a -> [a]
toList :: forall a. Nested a -> [a]
$cnull :: forall a. Nested a -> Bool
null :: forall a. Nested a -> Bool
$clength :: forall a. Nested a -> Int
length :: forall a. Nested a -> Int
$celem :: forall a. Eq a => a -> Nested a -> Bool
elem :: forall a. Eq a => a -> Nested a -> Bool
$cmaximum :: forall a. Ord a => Nested a -> a
maximum :: forall a. Ord a => Nested a -> a
$cminimum :: forall a. Ord a => Nested a -> a
minimum :: forall a. Ord a => Nested a -> a
$csum :: forall a. Num a => Nested a -> a
sum :: forall a. Num a => Nested a -> a
$cproduct :: forall a. Num a => Nested a -> a
product :: forall a. Num a => Nested a -> a
Foldable,
            Functor Nested
Foldable Nested
(Functor Nested, Foldable Nested) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Nested a -> f (Nested b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Nested (f a) -> f (Nested a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Nested a -> m (Nested b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Nested (m a) -> m (Nested a))
-> Traversable Nested
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 => Nested (m a) -> m (Nested a)
forall (f :: * -> *) a.
Applicative f =>
Nested (f a) -> f (Nested a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Nested a -> m (Nested b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Nested a -> f (Nested b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Nested a -> f (Nested b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Nested a -> f (Nested b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Nested (f a) -> f (Nested a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Nested (f a) -> f (Nested a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Nested a -> m (Nested b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Nested a -> m (Nested b)
$csequence :: forall (m :: * -> *) a. Monad m => Nested (m a) -> m (Nested a)
sequence :: forall (m :: * -> *) a. Monad m => Nested (m a) -> m (Nested a)
Traversable, Functor Nested
Functor Nested =>
(forall a. a -> Nested a)
-> (forall a b. Nested (a -> b) -> Nested a -> Nested b)
-> (forall a b c.
    (a -> b -> c) -> Nested a -> Nested b -> Nested c)
-> (forall a b. Nested a -> Nested b -> Nested b)
-> (forall a b. Nested a -> Nested b -> Nested a)
-> Applicative Nested
forall a. a -> Nested a
forall a b. Nested a -> Nested b -> Nested a
forall a b. Nested a -> Nested b -> Nested b
forall a b. Nested (a -> b) -> Nested a -> Nested b
forall a b c. (a -> b -> c) -> Nested a -> Nested b -> Nested c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> Nested a
pure :: forall a. a -> Nested a
$c<*> :: forall a b. Nested (a -> b) -> Nested a -> Nested b
<*> :: forall a b. Nested (a -> b) -> Nested a -> Nested b
$cliftA2 :: forall a b c. (a -> b -> c) -> Nested a -> Nested b -> Nested c
liftA2 :: forall a b c. (a -> b -> c) -> Nested a -> Nested b -> Nested c
$c*> :: forall a b. Nested a -> Nested b -> Nested b
*> :: forall a b. Nested a -> Nested b -> Nested b
$c<* :: forall a b. Nested a -> Nested b -> Nested a
<* :: forall a b. Nested a -> Nested b -> Nested a
Applicative, Applicative Nested
Applicative Nested =>
(forall a. Nested a)
-> (forall a. Nested a -> Nested a -> Nested a)
-> (forall a. Nested a -> Nested [a])
-> (forall a. Nested a -> Nested [a])
-> Alternative Nested
forall a. Nested a
forall a. Nested a -> Nested [a]
forall a. Nested a -> Nested a -> Nested a
forall (f :: * -> *).
Applicative f =>
(forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
$cempty :: forall a. Nested a
empty :: forall a. Nested a
$c<|> :: forall a. Nested a -> Nested a -> Nested a
<|> :: forall a. Nested a -> Nested a -> Nested a
$csome :: forall a. Nested a -> Nested [a]
some :: forall a. Nested a -> Nested [a]
$cmany :: forall a. Nested a -> Nested [a]
many :: forall a. Nested a -> Nested [a]
Alternative, Applicative Nested
Applicative Nested =>
(forall a b. Nested a -> (a -> Nested b) -> Nested b)
-> (forall a b. Nested a -> Nested b -> Nested b)
-> (forall a. a -> Nested a)
-> Monad Nested
forall a. a -> Nested a
forall a b. Nested a -> Nested b -> Nested b
forall a b. Nested a -> (a -> Nested b) -> Nested b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. Nested a -> (a -> Nested b) -> Nested b
>>= :: forall a b. Nested a -> (a -> Nested b) -> Nested b
$c>> :: forall a b. Nested a -> Nested b -> Nested b
>> :: forall a b. Nested a -> Nested b -> Nested b
$creturn :: forall a. a -> Nested a
return :: forall a. a -> Nested a
Monad, NonEmpty (Nested a) -> Nested a
Nested a -> Nested a -> Nested a
(Nested a -> Nested a -> Nested a)
-> (NonEmpty (Nested a) -> Nested a)
-> (forall b. Integral b => b -> Nested a -> Nested a)
-> Semigroup (Nested a)
forall b. Integral b => b -> Nested a -> Nested a
forall a. Semigroup a => NonEmpty (Nested a) -> Nested a
forall a. Semigroup a => Nested a -> Nested a -> Nested a
forall a b. (Semigroup a, Integral b) => b -> Nested a -> Nested a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: forall a. Semigroup a => Nested a -> Nested a -> Nested a
<> :: Nested a -> Nested a -> Nested a
$csconcat :: forall a. Semigroup a => NonEmpty (Nested a) -> Nested a
sconcat :: NonEmpty (Nested a) -> Nested a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Nested a -> Nested a
stimes :: forall b. Integral b => b -> Nested a -> Nested a
Semigroup)

-- | 'ForceEmit' provides a way to force emission of field values,
-- even when they have the default value.  Used for @optional@ fields
-- and fields that are part of a @oneof@.
newtype ForceEmit a = ForceEmit{ forall a. ForceEmit a -> a
forceEmit :: a }
  deriving (Int -> ForceEmit a -> ShowS
[ForceEmit a] -> ShowS
ForceEmit a -> String
(Int -> ForceEmit a -> ShowS)
-> (ForceEmit a -> String)
-> ([ForceEmit a] -> ShowS)
-> Show (ForceEmit a)
forall a. Show a => Int -> ForceEmit a -> ShowS
forall a. Show a => [ForceEmit a] -> ShowS
forall a. Show a => ForceEmit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ForceEmit a -> ShowS
showsPrec :: Int -> ForceEmit a -> ShowS
$cshow :: forall a. Show a => ForceEmit a -> String
show :: ForceEmit a -> String
$cshowList :: forall a. Show a => [ForceEmit a] -> ShowS
showList :: [ForceEmit a] -> ShowS
Show, ForceEmit a -> ForceEmit a -> Bool
(ForceEmit a -> ForceEmit a -> Bool)
-> (ForceEmit a -> ForceEmit a -> Bool) -> Eq (ForceEmit a)
forall a. Eq a => ForceEmit a -> ForceEmit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ForceEmit a -> ForceEmit a -> Bool
== :: ForceEmit a -> ForceEmit a -> Bool
$c/= :: forall a. Eq a => ForceEmit a -> ForceEmit a -> Bool
/= :: ForceEmit a -> ForceEmit a -> Bool
Eq, Eq (ForceEmit a)
Eq (ForceEmit a) =>
(ForceEmit a -> ForceEmit a -> Ordering)
-> (ForceEmit a -> ForceEmit a -> Bool)
-> (ForceEmit a -> ForceEmit a -> Bool)
-> (ForceEmit a -> ForceEmit a -> Bool)
-> (ForceEmit a -> ForceEmit a -> Bool)
-> (ForceEmit a -> ForceEmit a -> ForceEmit a)
-> (ForceEmit a -> ForceEmit a -> ForceEmit a)
-> Ord (ForceEmit a)
ForceEmit a -> ForceEmit a -> Bool
ForceEmit a -> ForceEmit a -> Ordering
ForceEmit a -> ForceEmit a -> ForceEmit 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 (ForceEmit a)
forall a. Ord a => ForceEmit a -> ForceEmit a -> Bool
forall a. Ord a => ForceEmit a -> ForceEmit a -> Ordering
forall a. Ord a => ForceEmit a -> ForceEmit a -> ForceEmit a
$ccompare :: forall a. Ord a => ForceEmit a -> ForceEmit a -> Ordering
compare :: ForceEmit a -> ForceEmit a -> Ordering
$c< :: forall a. Ord a => ForceEmit a -> ForceEmit a -> Bool
< :: ForceEmit a -> ForceEmit a -> Bool
$c<= :: forall a. Ord a => ForceEmit a -> ForceEmit a -> Bool
<= :: ForceEmit a -> ForceEmit a -> Bool
$c> :: forall a. Ord a => ForceEmit a -> ForceEmit a -> Bool
> :: ForceEmit a -> ForceEmit a -> Bool
$c>= :: forall a. Ord a => ForceEmit a -> ForceEmit a -> Bool
>= :: ForceEmit a -> ForceEmit a -> Bool
$cmax :: forall a. Ord a => ForceEmit a -> ForceEmit a -> ForceEmit a
max :: ForceEmit a -> ForceEmit a -> ForceEmit a
$cmin :: forall a. Ord a => ForceEmit a -> ForceEmit a -> ForceEmit a
min :: ForceEmit a -> ForceEmit a -> ForceEmit a
Ord, (forall x. ForceEmit a -> Rep (ForceEmit a) x)
-> (forall x. Rep (ForceEmit a) x -> ForceEmit a)
-> Generic (ForceEmit a)
forall x. Rep (ForceEmit a) x -> ForceEmit a
forall x. ForceEmit a -> Rep (ForceEmit a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ForceEmit a) x -> ForceEmit a
forall a x. ForceEmit a -> Rep (ForceEmit a) x
$cfrom :: forall a x. ForceEmit a -> Rep (ForceEmit a) x
from :: forall x. ForceEmit a -> Rep (ForceEmit a) x
$cto :: forall a x. Rep (ForceEmit a) x -> ForceEmit a
to :: forall x. Rep (ForceEmit a) x -> ForceEmit a
Generic, ForceEmit a -> ()
(ForceEmit a -> ()) -> NFData (ForceEmit a)
forall a. NFData a => ForceEmit a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => ForceEmit a -> ()
rnf :: ForceEmit a -> ()
NFData, Semigroup (ForceEmit a)
ForceEmit a
Semigroup (ForceEmit a) =>
ForceEmit a
-> (ForceEmit a -> ForceEmit a -> ForceEmit a)
-> ([ForceEmit a] -> ForceEmit a)
-> Monoid (ForceEmit a)
[ForceEmit a] -> ForceEmit a
ForceEmit a -> ForceEmit a -> ForceEmit a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (ForceEmit a)
forall a. Monoid a => ForceEmit a
forall a. Monoid a => [ForceEmit a] -> ForceEmit a
forall a. Monoid a => ForceEmit a -> ForceEmit a -> ForceEmit a
$cmempty :: forall a. Monoid a => ForceEmit a
mempty :: ForceEmit a
$cmappend :: forall a. Monoid a => ForceEmit a -> ForceEmit a -> ForceEmit a
mappend :: ForceEmit a -> ForceEmit a -> ForceEmit a
$cmconcat :: forall a. Monoid a => [ForceEmit a] -> ForceEmit a
mconcat :: [ForceEmit a] -> ForceEmit a
Monoid, Gen (ForceEmit a)
Gen (ForceEmit a)
-> (ForceEmit a -> [ForceEmit a]) -> Arbitrary (ForceEmit a)
ForceEmit a -> [ForceEmit a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall a. Arbitrary a => Gen (ForceEmit a)
forall a. Arbitrary a => ForceEmit a -> [ForceEmit a]
$carbitrary :: forall a. Arbitrary a => Gen (ForceEmit a)
arbitrary :: Gen (ForceEmit a)
$cshrink :: forall a. Arbitrary a => ForceEmit a -> [ForceEmit a]
shrink :: ForceEmit a -> [ForceEmit a]
Arbitrary, (forall a b. (a -> b) -> ForceEmit a -> ForceEmit b)
-> (forall a b. a -> ForceEmit b -> ForceEmit a)
-> Functor ForceEmit
forall a b. a -> ForceEmit b -> ForceEmit a
forall a b. (a -> b) -> ForceEmit a -> ForceEmit 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) -> ForceEmit a -> ForceEmit b
fmap :: forall a b. (a -> b) -> ForceEmit a -> ForceEmit b
$c<$ :: forall a b. a -> ForceEmit b -> ForceEmit a
<$ :: forall a b. a -> ForceEmit b -> ForceEmit a
Functor, (forall m. Monoid m => ForceEmit m -> m)
-> (forall m a. Monoid m => (a -> m) -> ForceEmit a -> m)
-> (forall m a. Monoid m => (a -> m) -> ForceEmit a -> m)
-> (forall a b. (a -> b -> b) -> b -> ForceEmit a -> b)
-> (forall a b. (a -> b -> b) -> b -> ForceEmit a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForceEmit a -> b)
-> (forall b a. (b -> a -> b) -> b -> ForceEmit a -> b)
-> (forall a. (a -> a -> a) -> ForceEmit a -> a)
-> (forall a. (a -> a -> a) -> ForceEmit a -> a)
-> (forall a. ForceEmit a -> [a])
-> (forall a. ForceEmit a -> Bool)
-> (forall a. ForceEmit a -> Int)
-> (forall a. Eq a => a -> ForceEmit a -> Bool)
-> (forall a. Ord a => ForceEmit a -> a)
-> (forall a. Ord a => ForceEmit a -> a)
-> (forall a. Num a => ForceEmit a -> a)
-> (forall a. Num a => ForceEmit a -> a)
-> Foldable ForceEmit
forall a. Eq a => a -> ForceEmit a -> Bool
forall a. Num a => ForceEmit a -> a
forall a. Ord a => ForceEmit a -> a
forall m. Monoid m => ForceEmit m -> m
forall a. ForceEmit a -> Bool
forall a. ForceEmit a -> Int
forall a. ForceEmit a -> [a]
forall a. (a -> a -> a) -> ForceEmit a -> a
forall m a. Monoid m => (a -> m) -> ForceEmit a -> m
forall b a. (b -> a -> b) -> b -> ForceEmit a -> b
forall a b. (a -> b -> b) -> b -> ForceEmit 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 => ForceEmit m -> m
fold :: forall m. Monoid m => ForceEmit m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ForceEmit a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ForceEmit a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ForceEmit a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> ForceEmit a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> ForceEmit a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ForceEmit a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ForceEmit a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ForceEmit a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ForceEmit a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ForceEmit a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ForceEmit a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> ForceEmit a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> ForceEmit a -> a
foldr1 :: forall a. (a -> a -> a) -> ForceEmit a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ForceEmit a -> a
foldl1 :: forall a. (a -> a -> a) -> ForceEmit a -> a
$ctoList :: forall a. ForceEmit a -> [a]
toList :: forall a. ForceEmit a -> [a]
$cnull :: forall a. ForceEmit a -> Bool
null :: forall a. ForceEmit a -> Bool
$clength :: forall a. ForceEmit a -> Int
length :: forall a. ForceEmit a -> Int
$celem :: forall a. Eq a => a -> ForceEmit a -> Bool
elem :: forall a. Eq a => a -> ForceEmit a -> Bool
$cmaximum :: forall a. Ord a => ForceEmit a -> a
maximum :: forall a. Ord a => ForceEmit a -> a
$cminimum :: forall a. Ord a => ForceEmit a -> a
minimum :: forall a. Ord a => ForceEmit a -> a
$csum :: forall a. Num a => ForceEmit a -> a
sum :: forall a. Num a => ForceEmit a -> a
$cproduct :: forall a. Num a => ForceEmit a -> a
product :: forall a. Num a => ForceEmit a -> a
Foldable,
            Functor ForceEmit
Foldable ForceEmit
(Functor ForceEmit, Foldable ForceEmit) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ForceEmit a -> f (ForceEmit b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ForceEmit (f a) -> f (ForceEmit a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ForceEmit a -> m (ForceEmit b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ForceEmit (m a) -> m (ForceEmit a))
-> Traversable ForceEmit
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 =>
ForceEmit (m a) -> m (ForceEmit a)
forall (f :: * -> *) a.
Applicative f =>
ForceEmit (f a) -> f (ForceEmit a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForceEmit a -> m (ForceEmit b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForceEmit a -> f (ForceEmit b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForceEmit a -> f (ForceEmit b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ForceEmit a -> f (ForceEmit b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForceEmit (f a) -> f (ForceEmit a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ForceEmit (f a) -> f (ForceEmit a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForceEmit a -> m (ForceEmit b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ForceEmit a -> m (ForceEmit b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ForceEmit (m a) -> m (ForceEmit a)
sequence :: forall (m :: * -> *) a.
Monad m =>
ForceEmit (m a) -> m (ForceEmit a)
Traversable, NonEmpty (ForceEmit a) -> ForceEmit a
ForceEmit a -> ForceEmit a -> ForceEmit a
(ForceEmit a -> ForceEmit a -> ForceEmit a)
-> (NonEmpty (ForceEmit a) -> ForceEmit a)
-> (forall b. Integral b => b -> ForceEmit a -> ForceEmit a)
-> Semigroup (ForceEmit a)
forall b. Integral b => b -> ForceEmit a -> ForceEmit a
forall a. Semigroup a => NonEmpty (ForceEmit a) -> ForceEmit a
forall a. Semigroup a => ForceEmit a -> ForceEmit a -> ForceEmit a
forall a b.
(Semigroup a, Integral b) =>
b -> ForceEmit a -> ForceEmit a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: forall a. Semigroup a => ForceEmit a -> ForceEmit a -> ForceEmit a
<> :: ForceEmit a -> ForceEmit a -> ForceEmit a
$csconcat :: forall a. Semigroup a => NonEmpty (ForceEmit a) -> ForceEmit a
sconcat :: NonEmpty (ForceEmit a) -> ForceEmit a
$cstimes :: forall a b.
(Semigroup a, Integral b) =>
b -> ForceEmit a -> ForceEmit a
stimes :: forall b. Integral b => b -> ForceEmit a -> ForceEmit a
Semigroup)

-- | 'Commented' provides a way to add comments to generated @.proto@ files.
newtype Commented (comment :: Symbol) a = Commented { forall (comment :: Symbol) a. Commented comment a -> a
unCommented :: a }
  deriving (Int -> Commented comment a -> ShowS
[Commented comment a] -> ShowS
Commented comment a -> String
(Int -> Commented comment a -> ShowS)
-> (Commented comment a -> String)
-> ([Commented comment a] -> ShowS)
-> Show (Commented comment a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (comment :: Symbol) a.
Show a =>
Int -> Commented comment a -> ShowS
forall (comment :: Symbol) a.
Show a =>
[Commented comment a] -> ShowS
forall (comment :: Symbol) a.
Show a =>
Commented comment a -> String
$cshowsPrec :: forall (comment :: Symbol) a.
Show a =>
Int -> Commented comment a -> ShowS
showsPrec :: Int -> Commented comment a -> ShowS
$cshow :: forall (comment :: Symbol) a.
Show a =>
Commented comment a -> String
show :: Commented comment a -> String
$cshowList :: forall (comment :: Symbol) a.
Show a =>
[Commented comment a] -> ShowS
showList :: [Commented comment a] -> ShowS
Show, Commented comment a -> Commented comment a -> Bool
(Commented comment a -> Commented comment a -> Bool)
-> (Commented comment a -> Commented comment a -> Bool)
-> Eq (Commented comment a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (comment :: Symbol) a.
Eq a =>
Commented comment a -> Commented comment a -> Bool
$c== :: forall (comment :: Symbol) a.
Eq a =>
Commented comment a -> Commented comment a -> Bool
== :: Commented comment a -> Commented comment a -> Bool
$c/= :: forall (comment :: Symbol) a.
Eq a =>
Commented comment a -> Commented comment a -> Bool
/= :: Commented comment a -> Commented comment a -> Bool
Eq, Eq (Commented comment a)
Eq (Commented comment a) =>
(Commented comment a -> Commented comment a -> Ordering)
-> (Commented comment a -> Commented comment a -> Bool)
-> (Commented comment a -> Commented comment a -> Bool)
-> (Commented comment a -> Commented comment a -> Bool)
-> (Commented comment a -> Commented comment a -> Bool)
-> (Commented comment a
    -> Commented comment a -> Commented comment a)
-> (Commented comment a
    -> Commented comment a -> Commented comment a)
-> Ord (Commented comment a)
Commented comment a -> Commented comment a -> Bool
Commented comment a -> Commented comment a -> Ordering
Commented comment a -> Commented comment a -> Commented comment 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 (comment :: Symbol) a. Ord a => Eq (Commented comment a)
forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Bool
forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Ordering
forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Commented comment a
$ccompare :: forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Ordering
compare :: Commented comment a -> Commented comment a -> Ordering
$c< :: forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Bool
< :: Commented comment a -> Commented comment a -> Bool
$c<= :: forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Bool
<= :: Commented comment a -> Commented comment a -> Bool
$c> :: forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Bool
> :: Commented comment a -> Commented comment a -> Bool
$c>= :: forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Bool
>= :: Commented comment a -> Commented comment a -> Bool
$cmax :: forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Commented comment a
max :: Commented comment a -> Commented comment a -> Commented comment a
$cmin :: forall (comment :: Symbol) a.
Ord a =>
Commented comment a -> Commented comment a -> Commented comment a
min :: Commented comment a -> Commented comment a -> Commented comment a
Ord, (forall x. Commented comment a -> Rep (Commented comment a) x)
-> (forall x. Rep (Commented comment a) x -> Commented comment a)
-> Generic (Commented comment a)
forall x. Rep (Commented comment a) x -> Commented comment a
forall x. Commented comment a -> Rep (Commented comment a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (comment :: Symbol) a x.
Rep (Commented comment a) x -> Commented comment a
forall (comment :: Symbol) a x.
Commented comment a -> Rep (Commented comment a) x
$cfrom :: forall (comment :: Symbol) a x.
Commented comment a -> Rep (Commented comment a) x
from :: forall x. Commented comment a -> Rep (Commented comment a) x
$cto :: forall (comment :: Symbol) a x.
Rep (Commented comment a) x -> Commented comment a
to :: forall x. Rep (Commented comment a) x -> Commented comment a
Generic, Commented comment a -> ()
(Commented comment a -> ()) -> NFData (Commented comment a)
forall a. (a -> ()) -> NFData a
forall (comment :: Symbol) a. NFData a => Commented comment a -> ()
$crnf :: forall (comment :: Symbol) a. NFData a => Commented comment a -> ()
rnf :: Commented comment a -> ()
NFData, Semigroup (Commented comment a)
Commented comment a
Semigroup (Commented comment a) =>
Commented comment a
-> (Commented comment a
    -> Commented comment a -> Commented comment a)
-> ([Commented comment a] -> Commented comment a)
-> Monoid (Commented comment a)
[Commented comment a] -> Commented comment a
Commented comment a -> Commented comment a -> Commented comment a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall (comment :: Symbol) a.
Monoid a =>
Semigroup (Commented comment a)
forall (comment :: Symbol) a. Monoid a => Commented comment a
forall (comment :: Symbol) a.
Monoid a =>
[Commented comment a] -> Commented comment a
forall (comment :: Symbol) a.
Monoid a =>
Commented comment a -> Commented comment a -> Commented comment a
$cmempty :: forall (comment :: Symbol) a. Monoid a => Commented comment a
mempty :: Commented comment a
$cmappend :: forall (comment :: Symbol) a.
Monoid a =>
Commented comment a -> Commented comment a -> Commented comment a
mappend :: Commented comment a -> Commented comment a -> Commented comment a
$cmconcat :: forall (comment :: Symbol) a.
Monoid a =>
[Commented comment a] -> Commented comment a
mconcat :: [Commented comment a] -> Commented comment a
Monoid, Gen (Commented comment a)
Gen (Commented comment a)
-> (Commented comment a -> [Commented comment a])
-> Arbitrary (Commented comment a)
Commented comment a -> [Commented comment a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall (comment :: Symbol) a.
Arbitrary a =>
Gen (Commented comment a)
forall (comment :: Symbol) a.
Arbitrary a =>
Commented comment a -> [Commented comment a]
$carbitrary :: forall (comment :: Symbol) a.
Arbitrary a =>
Gen (Commented comment a)
arbitrary :: Gen (Commented comment a)
$cshrink :: forall (comment :: Symbol) a.
Arbitrary a =>
Commented comment a -> [Commented comment a]
shrink :: Commented comment a -> [Commented comment a]
Arbitrary, (forall a b.
 (a -> b) -> Commented comment a -> Commented comment b)
-> (forall a b. a -> Commented comment b -> Commented comment a)
-> Functor (Commented comment)
forall a b. a -> Commented comment b -> Commented comment a
forall a b. (a -> b) -> Commented comment a -> Commented comment b
forall (comment :: Symbol) a b.
a -> Commented comment b -> Commented comment a
forall (comment :: Symbol) a b.
(a -> b) -> Commented comment a -> Commented comment b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (comment :: Symbol) a b.
(a -> b) -> Commented comment a -> Commented comment b
fmap :: forall a b. (a -> b) -> Commented comment a -> Commented comment b
$c<$ :: forall (comment :: Symbol) a b.
a -> Commented comment b -> Commented comment a
<$ :: forall a b. a -> Commented comment b -> Commented comment a
Functor, (forall m. Monoid m => Commented comment m -> m)
-> (forall m a. Monoid m => (a -> m) -> Commented comment a -> m)
-> (forall m a. Monoid m => (a -> m) -> Commented comment a -> m)
-> (forall a b. (a -> b -> b) -> b -> Commented comment a -> b)
-> (forall a b. (a -> b -> b) -> b -> Commented comment a -> b)
-> (forall b a. (b -> a -> b) -> b -> Commented comment a -> b)
-> (forall b a. (b -> a -> b) -> b -> Commented comment a -> b)
-> (forall a. (a -> a -> a) -> Commented comment a -> a)
-> (forall a. (a -> a -> a) -> Commented comment a -> a)
-> (forall a. Commented comment a -> [a])
-> (forall a. Commented comment a -> Bool)
-> (forall a. Commented comment a -> Int)
-> (forall a. Eq a => a -> Commented comment a -> Bool)
-> (forall a. Ord a => Commented comment a -> a)
-> (forall a. Ord a => Commented comment a -> a)
-> (forall a. Num a => Commented comment a -> a)
-> (forall a. Num a => Commented comment a -> a)
-> Foldable (Commented comment)
forall a. Eq a => a -> Commented comment a -> Bool
forall a. Num a => Commented comment a -> a
forall a. Ord a => Commented comment a -> a
forall m. Monoid m => Commented comment m -> m
forall a. Commented comment a -> Bool
forall a. Commented comment a -> Int
forall a. Commented comment a -> [a]
forall a. (a -> a -> a) -> Commented comment a -> a
forall m a. Monoid m => (a -> m) -> Commented comment a -> m
forall b a. (b -> a -> b) -> b -> Commented comment a -> b
forall a b. (a -> b -> b) -> b -> Commented comment a -> b
forall (comment :: Symbol) a.
Eq a =>
a -> Commented comment a -> Bool
forall (comment :: Symbol) a. Num a => Commented comment a -> a
forall (comment :: Symbol) a. Ord a => Commented comment a -> a
forall (comment :: Symbol) m. Monoid m => Commented comment m -> m
forall (comment :: Symbol) a. Commented comment a -> Bool
forall (comment :: Symbol) a. Commented comment a -> Int
forall (comment :: Symbol) a. Commented comment a -> [a]
forall (comment :: Symbol) a.
(a -> a -> a) -> Commented comment a -> a
forall (comment :: Symbol) m a.
Monoid m =>
(a -> m) -> Commented comment a -> m
forall (comment :: Symbol) b a.
(b -> a -> b) -> b -> Commented comment a -> b
forall (comment :: Symbol) a b.
(a -> b -> b) -> b -> Commented comment 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 (comment :: Symbol) m. Monoid m => Commented comment m -> m
fold :: forall m. Monoid m => Commented comment m -> m
$cfoldMap :: forall (comment :: Symbol) m a.
Monoid m =>
(a -> m) -> Commented comment a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Commented comment a -> m
$cfoldMap' :: forall (comment :: Symbol) m a.
Monoid m =>
(a -> m) -> Commented comment a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Commented comment a -> m
$cfoldr :: forall (comment :: Symbol) a b.
(a -> b -> b) -> b -> Commented comment a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Commented comment a -> b
$cfoldr' :: forall (comment :: Symbol) a b.
(a -> b -> b) -> b -> Commented comment a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Commented comment a -> b
$cfoldl :: forall (comment :: Symbol) b a.
(b -> a -> b) -> b -> Commented comment a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Commented comment a -> b
$cfoldl' :: forall (comment :: Symbol) b a.
(b -> a -> b) -> b -> Commented comment a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Commented comment a -> b
$cfoldr1 :: forall (comment :: Symbol) a.
(a -> a -> a) -> Commented comment a -> a
foldr1 :: forall a. (a -> a -> a) -> Commented comment a -> a
$cfoldl1 :: forall (comment :: Symbol) a.
(a -> a -> a) -> Commented comment a -> a
foldl1 :: forall a. (a -> a -> a) -> Commented comment a -> a
$ctoList :: forall (comment :: Symbol) a. Commented comment a -> [a]
toList :: forall a. Commented comment a -> [a]
$cnull :: forall (comment :: Symbol) a. Commented comment a -> Bool
null :: forall a. Commented comment a -> Bool
$clength :: forall (comment :: Symbol) a. Commented comment a -> Int
length :: forall a. Commented comment a -> Int
$celem :: forall (comment :: Symbol) a.
Eq a =>
a -> Commented comment a -> Bool
elem :: forall a. Eq a => a -> Commented comment a -> Bool
$cmaximum :: forall (comment :: Symbol) a. Ord a => Commented comment a -> a
maximum :: forall a. Ord a => Commented comment a -> a
$cminimum :: forall (comment :: Symbol) a. Ord a => Commented comment a -> a
minimum :: forall a. Ord a => Commented comment a -> a
$csum :: forall (comment :: Symbol) a. Num a => Commented comment a -> a
sum :: forall a. Num a => Commented comment a -> a
$cproduct :: forall (comment :: Symbol) a. Num a => Commented comment a -> a
product :: forall a. Num a => Commented comment a -> a
Foldable, Functor (Commented comment)
Foldable (Commented comment)
(Functor (Commented comment), Foldable (Commented comment)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Commented comment a -> f (Commented comment b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Commented comment (f a) -> f (Commented comment a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Commented comment a -> m (Commented comment b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Commented comment (m a) -> m (Commented comment a))
-> Traversable (Commented comment)
forall (comment :: Symbol). Functor (Commented comment)
forall (comment :: Symbol). Foldable (Commented comment)
forall (comment :: Symbol) (m :: * -> *) a.
Monad m =>
Commented comment (m a) -> m (Commented comment a)
forall (comment :: Symbol) (f :: * -> *) a.
Applicative f =>
Commented comment (f a) -> f (Commented comment a)
forall (comment :: Symbol) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Commented comment a -> m (Commented comment b)
forall (comment :: Symbol) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Commented comment a -> f (Commented comment 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 =>
Commented comment (m a) -> m (Commented comment a)
forall (f :: * -> *) a.
Applicative f =>
Commented comment (f a) -> f (Commented comment a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Commented comment a -> m (Commented comment b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Commented comment a -> f (Commented comment b)
$ctraverse :: forall (comment :: Symbol) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Commented comment a -> f (Commented comment b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Commented comment a -> f (Commented comment b)
$csequenceA :: forall (comment :: Symbol) (f :: * -> *) a.
Applicative f =>
Commented comment (f a) -> f (Commented comment a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Commented comment (f a) -> f (Commented comment a)
$cmapM :: forall (comment :: Symbol) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Commented comment a -> m (Commented comment b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Commented comment a -> m (Commented comment b)
$csequence :: forall (comment :: Symbol) (m :: * -> *) a.
Monad m =>
Commented comment (m a) -> m (Commented comment a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Commented comment (m a) -> m (Commented comment a)
Traversable, NonEmpty (Commented comment a) -> Commented comment a
Commented comment a -> Commented comment a -> Commented comment a
(Commented comment a -> Commented comment a -> Commented comment a)
-> (NonEmpty (Commented comment a) -> Commented comment a)
-> (forall b.
    Integral b =>
    b -> Commented comment a -> Commented comment a)
-> Semigroup (Commented comment a)
forall b.
Integral b =>
b -> Commented comment a -> Commented comment a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall (comment :: Symbol) a.
Semigroup a =>
NonEmpty (Commented comment a) -> Commented comment a
forall (comment :: Symbol) a.
Semigroup a =>
Commented comment a -> Commented comment a -> Commented comment a
forall (comment :: Symbol) a b.
(Semigroup a, Integral b) =>
b -> Commented comment a -> Commented comment a
$c<> :: forall (comment :: Symbol) a.
Semigroup a =>
Commented comment a -> Commented comment a -> Commented comment a
<> :: Commented comment a -> Commented comment a -> Commented comment a
$csconcat :: forall (comment :: Symbol) a.
Semigroup a =>
NonEmpty (Commented comment a) -> Commented comment a
sconcat :: NonEmpty (Commented comment a) -> Commented comment a
$cstimes :: forall (comment :: Symbol) a b.
(Semigroup a, Integral b) =>
b -> Commented comment a -> Commented comment a
stimes :: forall b.
Integral b =>
b -> Commented comment a -> Commented comment a
Semigroup)

-- | A type operator synonym for 'Commented', so that we can write C-style
-- comments on fields.
type a // (comment :: Symbol) = Commented comment a