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

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

  -- * Enumerable Types
  , Enumerated(..)

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

import           Control.Applicative
import           Control.DeepSeq (NFData)
import           GHC.Exts (IsList(..))
import           GHC.Generics
import           Data.Int (Int32)
import           Data.Semigroup (Semigroup)
import qualified Data.Vector as V
import           GHC.TypeLits (Symbol)
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 { 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
showList :: [Fixed a] -> ShowS
$cshowList :: forall a. Show a => [Fixed a] -> ShowS
show :: Fixed a -> String
$cshow :: forall a. Show a => Fixed a -> String
showsPrec :: Int -> Fixed a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> 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
/= :: Fixed a -> Fixed a -> Bool
$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
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
min :: Fixed a -> Fixed a -> Fixed a
$cmin :: forall a. Ord a => Fixed a -> Fixed a -> Fixed a
max :: Fixed a -> Fixed a -> Fixed a
$cmax :: forall a. Ord a => Fixed a -> Fixed a -> Fixed a
>= :: 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
$c< :: forall a. Ord a => Fixed a -> Fixed a -> Bool
compare :: Fixed a -> Fixed a -> Ordering
$ccompare :: forall a. Ord a => Fixed a -> Fixed a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (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
fromInteger :: Integer -> Fixed a
$cfromInteger :: forall a. Num a => Integer -> Fixed a
signum :: Fixed a -> Fixed a
$csignum :: forall a. Num a => Fixed a -> Fixed a
abs :: Fixed a -> Fixed a
$cabs :: forall a. Num a => Fixed a -> Fixed a
negate :: Fixed a -> Fixed a
$cnegate :: forall a. Num 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
$c+ :: forall a. Num a => Fixed a -> Fixed a -> 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
$cto :: forall a x. Rep (Fixed a) x -> Fixed a
$cfrom :: forall a x. Fixed a -> Rep (Fixed a) x
Generic, Fixed a -> ()
(Fixed a -> ()) -> NFData (Fixed a)
forall a. NFData a => Fixed a -> ()
forall a. (a -> ()) -> NFData a
rnf :: Fixed a -> ()
$crnf :: forall a. NFData a => Fixed a -> ()
NFData, Gen (Fixed a)
Gen (Fixed a) -> (Fixed a -> [Fixed a]) -> Arbitrary (Fixed a)
Fixed a -> [Fixed a]
forall a. Arbitrary a => Gen (Fixed a)
forall a. Arbitrary a => Fixed a -> [Fixed a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
shrink :: Fixed a -> [Fixed a]
$cshrink :: forall a. Arbitrary a => Fixed a -> [Fixed a]
arbitrary :: Gen (Fixed a)
$carbitrary :: forall a. Arbitrary a => Gen (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
enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a]
$cenumFromThenTo :: forall a. Enum a => Fixed a -> Fixed a -> Fixed a -> [Fixed a]
enumFromTo :: Fixed a -> Fixed a -> [Fixed a]
$cenumFromTo :: forall a. Enum a => Fixed a -> Fixed a -> [Fixed a]
enumFromThen :: Fixed a -> Fixed a -> [Fixed a]
$cenumFromThen :: forall a. Enum a => Fixed a -> Fixed a -> [Fixed a]
enumFrom :: Fixed a -> [Fixed a]
$cenumFrom :: forall a. Enum a => Fixed a -> [Fixed a]
fromEnum :: Fixed a -> Int
$cfromEnum :: forall a. Enum a => Fixed a -> Int
toEnum :: Int -> Fixed a
$ctoEnum :: forall a. Enum a => Int -> Fixed a
pred :: Fixed a -> Fixed a
$cpred :: forall a. Enum a => Fixed a -> Fixed a
succ :: Fixed a -> Fixed a
$csucc :: forall a. Enum 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
maxBound :: Fixed a
$cmaxBound :: forall a. Bounded a => Fixed a
minBound :: Fixed a
$cminBound :: forall a. Bounded a => Fixed a
Bounded
           , a -> Fixed b -> Fixed a
(a -> b) -> Fixed a -> Fixed b
(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
<$ :: a -> Fixed b -> Fixed a
$c<$ :: forall a b. a -> Fixed b -> Fixed a
fmap :: (a -> b) -> Fixed a -> Fixed b
$cfmap :: forall a b. (a -> b) -> Fixed a -> Fixed b
Functor, Fixed a -> Bool
(a -> m) -> Fixed a -> m
(a -> b -> b) -> b -> Fixed a -> b
(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
product :: Fixed a -> a
$cproduct :: forall a. Num a => Fixed a -> a
sum :: Fixed a -> a
$csum :: forall a. Num a => Fixed a -> a
minimum :: Fixed a -> a
$cminimum :: forall a. Ord a => Fixed a -> a
maximum :: Fixed a -> a
$cmaximum :: forall a. Ord a => Fixed a -> a
elem :: a -> Fixed a -> Bool
$celem :: forall a. Eq a => a -> Fixed a -> Bool
length :: Fixed a -> Int
$clength :: forall a. Fixed a -> Int
null :: Fixed a -> Bool
$cnull :: forall a. Fixed a -> Bool
toList :: Fixed a -> [a]
$ctoList :: forall a. Fixed a -> [a]
foldl1 :: (a -> a -> a) -> Fixed a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Fixed a -> a
foldr1 :: (a -> a -> a) -> Fixed a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Fixed a -> a
foldl' :: (b -> a -> b) -> b -> Fixed a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Fixed a -> b
foldl :: (b -> a -> b) -> b -> Fixed a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Fixed a -> b
foldr' :: (a -> b -> b) -> b -> Fixed a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Fixed a -> b
foldr :: (a -> b -> b) -> b -> Fixed a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Fixed a -> b
foldMap' :: (a -> m) -> Fixed a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Fixed a -> m
foldMap :: (a -> m) -> Fixed a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Fixed a -> m
fold :: Fixed m -> m
$cfold :: forall m. Monoid m => Fixed m -> m
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
(a -> f b) -> Fixed a -> f (Fixed 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 => 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)
sequence :: Fixed (m a) -> m (Fixed a)
$csequence :: forall (m :: * -> *) a. Monad m => Fixed (m a) -> m (Fixed a)
mapM :: (a -> m b) -> Fixed a -> m (Fixed b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Fixed a -> m (Fixed b)
sequenceA :: Fixed (f a) -> f (Fixed a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Fixed (f a) -> f (Fixed a)
traverse :: (a -> f b) -> Fixed a -> f (Fixed b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Fixed a -> f (Fixed b)
$cp2Traversable :: Foldable Fixed
$cp1Traversable :: Functor Fixed
Traversable)

-- | 'Signed' provides a way to encode integers in the signed wire formats.
newtype Signed a = Signed { 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
showList :: [Signed a] -> ShowS
$cshowList :: forall a. Show a => [Signed a] -> ShowS
show :: Signed a -> String
$cshow :: forall a. Show a => Signed a -> String
showsPrec :: Int -> Signed a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> 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
/= :: Signed a -> Signed a -> Bool
$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
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
min :: Signed a -> Signed a -> Signed a
$cmin :: forall a. Ord a => Signed a -> Signed a -> Signed a
max :: Signed a -> Signed a -> Signed a
$cmax :: forall a. Ord a => Signed a -> Signed a -> Signed a
>= :: 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
$c< :: forall a. Ord a => Signed a -> Signed a -> Bool
compare :: Signed a -> Signed a -> Ordering
$ccompare :: forall a. Ord a => Signed a -> Signed a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (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
fromInteger :: Integer -> Signed a
$cfromInteger :: forall a. Num a => Integer -> Signed a
signum :: Signed a -> Signed a
$csignum :: forall a. Num a => Signed a -> Signed a
abs :: Signed a -> Signed a
$cabs :: forall a. Num a => Signed a -> Signed a
negate :: Signed a -> Signed a
$cnegate :: forall a. Num 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
$c+ :: forall a. Num a => Signed a -> Signed a -> 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
$cto :: forall a x. Rep (Signed a) x -> Signed a
$cfrom :: forall a x. Signed a -> Rep (Signed a) x
Generic, Signed a -> ()
(Signed a -> ()) -> NFData (Signed a)
forall a. NFData a => Signed a -> ()
forall a. (a -> ()) -> NFData a
rnf :: Signed a -> ()
$crnf :: forall a. NFData a => Signed a -> ()
NFData, Gen (Signed a)
Gen (Signed a) -> (Signed a -> [Signed a]) -> Arbitrary (Signed a)
Signed a -> [Signed a]
forall a. Arbitrary a => Gen (Signed a)
forall a. Arbitrary a => Signed a -> [Signed a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
shrink :: Signed a -> [Signed a]
$cshrink :: forall a. Arbitrary a => Signed a -> [Signed a]
arbitrary :: Gen (Signed a)
$carbitrary :: forall a. Arbitrary a => Gen (Signed a)
Arbitrary, Signed a
Signed a -> Signed a -> Bounded (Signed a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Signed a
maxBound :: Signed a
$cmaxBound :: forall a. Bounded a => Signed a
minBound :: Signed a
$cminBound :: forall a. Bounded a => Signed a
Bounded
           , a -> Signed b -> Signed a
(a -> b) -> Signed a -> Signed b
(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
<$ :: a -> Signed b -> Signed a
$c<$ :: forall a b. a -> Signed b -> Signed a
fmap :: (a -> b) -> Signed a -> Signed b
$cfmap :: forall a b. (a -> b) -> Signed a -> Signed b
Functor, Signed a -> Bool
(a -> m) -> Signed a -> m
(a -> b -> b) -> b -> Signed a -> b
(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
product :: Signed a -> a
$cproduct :: forall a. Num a => Signed a -> a
sum :: Signed a -> a
$csum :: forall a. Num a => Signed a -> a
minimum :: Signed a -> a
$cminimum :: forall a. Ord a => Signed a -> a
maximum :: Signed a -> a
$cmaximum :: forall a. Ord a => Signed a -> a
elem :: a -> Signed a -> Bool
$celem :: forall a. Eq a => a -> Signed a -> Bool
length :: Signed a -> Int
$clength :: forall a. Signed a -> Int
null :: Signed a -> Bool
$cnull :: forall a. Signed a -> Bool
toList :: Signed a -> [a]
$ctoList :: forall a. Signed a -> [a]
foldl1 :: (a -> a -> a) -> Signed a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Signed a -> a
foldr1 :: (a -> a -> a) -> Signed a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Signed a -> a
foldl' :: (b -> a -> b) -> b -> Signed a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Signed a -> b
foldl :: (b -> a -> b) -> b -> Signed a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Signed a -> b
foldr' :: (a -> b -> b) -> b -> Signed a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Signed a -> b
foldr :: (a -> b -> b) -> b -> Signed a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Signed a -> b
foldMap' :: (a -> m) -> Signed a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Signed a -> m
foldMap :: (a -> m) -> Signed a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Signed a -> m
fold :: Signed m -> m
$cfold :: forall m. Monoid m => Signed m -> m
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
(a -> f b) -> Signed a -> f (Signed 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 => 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)
sequence :: Signed (m a) -> m (Signed a)
$csequence :: forall (m :: * -> *) a. Monad m => Signed (m a) -> m (Signed a)
mapM :: (a -> m b) -> Signed a -> m (Signed b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Signed a -> m (Signed b)
sequenceA :: Signed (f a) -> f (Signed a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Signed (f a) -> f (Signed a)
traverse :: (a -> f b) -> Signed a -> f (Signed b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Signed a -> f (Signed b)
$cp2Traversable :: Foldable Signed
$cp1Traversable :: Functor Signed
Traversable)

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

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 (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)

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

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

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