-- |
-- Module: M.Pack.Internal.Newtypes
-- Description: Special-purpose serialization wrappers
-- Copyright: (c) axionbuster, 2025
-- License: BSD-3-Clause
--
-- Defines newtype wrappers that control how values are packed and unpacked,
-- including enum indices, fixed-point numbers, angles, and identifiers.
module M.Pack.Internal.Newtypes
  ( EnumIndex (..),
    Fixed' (..),
    Int8Angle (..),
    Identifier (..),
    IDorX (..),
    IDSet (..),
    TakeRest (..),
    PackFoldableVI (..),
    PackFoldable0 (..),
    UnpackRepresentable0 (..),
    degtoi8angle,
    i8angledeg,
  )
where

import Control.Applicative.Combinators
import Control.DeepSeq
import Data.ByteString (ByteString)
import Data.ByteString.Builder qualified as BB
import Data.Char
import Data.Coerce
import Data.Data
import Data.Fixed
import Data.Foldable
import Data.Foldable1
import Data.Functor.Classes
import Data.Functor.Rep
import Data.Hashable
import Data.Int
import Data.String
import Data.Text (Text)
import Data.Text qualified as T
import Data.Vector qualified as V
import FlatParse.Stateful qualified as F
import GHC.Generics
import Language.Haskell.TH.Syntax (Lift)
import M.LEB
import M.Pack.Internal.Etc ()
import M.Pack.Internal.FromIntegral
import M.Pack.Internal.Num
import M.Pack.Internal.Types

-- | represent any 'Enum' type using a zero-based index
newtype EnumIndex i a = EnumIndex {forall {k} (i :: k) a. EnumIndex i a -> a
enumindex :: a}
  deriving stock ((forall x. EnumIndex i a -> Rep (EnumIndex i a) x)
-> (forall x. Rep (EnumIndex i a) x -> EnumIndex i a)
-> Generic (EnumIndex i a)
forall x. Rep (EnumIndex i a) x -> EnumIndex i a
forall x. EnumIndex i a -> Rep (EnumIndex i a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (i :: k) a x. Rep (EnumIndex i a) x -> EnumIndex i a
forall k (i :: k) a x. EnumIndex i a -> Rep (EnumIndex i a) x
$cfrom :: forall k (i :: k) a x. EnumIndex i a -> Rep (EnumIndex i a) x
from :: forall x. EnumIndex i a -> Rep (EnumIndex i a) x
$cto :: forall k (i :: k) a x. Rep (EnumIndex i a) x -> EnumIndex i a
to :: forall x. Rep (EnumIndex i a) x -> EnumIndex i a
Generic, Typeable, Typeable (EnumIndex i a)
Typeable (EnumIndex i a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EnumIndex i a -> c (EnumIndex i a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EnumIndex i a))
-> (EnumIndex i a -> Constr)
-> (EnumIndex i a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EnumIndex i a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EnumIndex i a)))
-> ((forall b. Data b => b -> b) -> EnumIndex i a -> EnumIndex i a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r)
-> (forall u. (forall d. Data d => d -> u) -> EnumIndex i a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EnumIndex i a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EnumIndex i a -> m (EnumIndex i a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumIndex i a -> m (EnumIndex i a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumIndex i a -> m (EnumIndex i a))
-> Data (EnumIndex i a)
EnumIndex i a -> Constr
EnumIndex i a -> DataType
(forall b. Data b => b -> b) -> EnumIndex i a -> EnumIndex i a
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> EnumIndex i a -> u
forall u. (forall d. Data d => d -> u) -> EnumIndex i a -> [u]
forall k (i :: k) a.
(Typeable i, Typeable k, Data a) =>
Typeable (EnumIndex i a)
forall k (i :: k) a.
(Typeable i, Typeable k, Data a) =>
EnumIndex i a -> Constr
forall k (i :: k) a.
(Typeable i, Typeable k, Data a) =>
EnumIndex i a -> DataType
forall k (i :: k) a.
(Typeable i, Typeable k, Data a) =>
(forall b. Data b => b -> b) -> EnumIndex i a -> EnumIndex i a
forall k (i :: k) a u.
(Typeable i, Typeable k, Data a) =>
Int -> (forall d. Data d => d -> u) -> EnumIndex i a -> u
forall k (i :: k) a u.
(Typeable i, Typeable k, Data a) =>
(forall d. Data d => d -> u) -> EnumIndex i a -> [u]
forall k (i :: k) a r r'.
(Typeable i, Typeable k, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
forall k (i :: k) a r r'.
(Typeable i, Typeable k, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
forall k (i :: k) a (m :: * -> *).
(Typeable i, Typeable k, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
forall k (i :: k) a (m :: * -> *).
(Typeable i, Typeable k, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
forall k (i :: k) a (c :: * -> *).
(Typeable i, Typeable k, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EnumIndex i a)
forall k (i :: k) a (c :: * -> *).
(Typeable i, Typeable k, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumIndex i a -> c (EnumIndex i a)
forall k (i :: k) a (t :: * -> *) (c :: * -> *).
(Typeable i, Typeable k, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EnumIndex i a))
forall k (i :: k) a (t :: * -> * -> *) (c :: * -> *).
(Typeable i, Typeable k, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EnumIndex i a))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EnumIndex i a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumIndex i a -> c (EnumIndex i a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EnumIndex i a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EnumIndex i a))
$cgfoldl :: forall k (i :: k) a (c :: * -> *).
(Typeable i, Typeable k, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumIndex i a -> c (EnumIndex i a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumIndex i a -> c (EnumIndex i a)
$cgunfold :: forall k (i :: k) a (c :: * -> *).
(Typeable i, Typeable k, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EnumIndex i a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EnumIndex i a)
$ctoConstr :: forall k (i :: k) a.
(Typeable i, Typeable k, Data a) =>
EnumIndex i a -> Constr
toConstr :: EnumIndex i a -> Constr
$cdataTypeOf :: forall k (i :: k) a.
(Typeable i, Typeable k, Data a) =>
EnumIndex i a -> DataType
dataTypeOf :: EnumIndex i a -> DataType
$cdataCast1 :: forall k (i :: k) a (t :: * -> *) (c :: * -> *).
(Typeable i, Typeable k, Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EnumIndex i a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EnumIndex i a))
$cdataCast2 :: forall k (i :: k) a (t :: * -> * -> *) (c :: * -> *).
(Typeable i, Typeable k, Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EnumIndex i a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EnumIndex i a))
$cgmapT :: forall k (i :: k) a.
(Typeable i, Typeable k, Data a) =>
(forall b. Data b => b -> b) -> EnumIndex i a -> EnumIndex i a
gmapT :: (forall b. Data b => b -> b) -> EnumIndex i a -> EnumIndex i a
$cgmapQl :: forall k (i :: k) a r r'.
(Typeable i, Typeable k, Data a) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
$cgmapQr :: forall k (i :: k) a r r'.
(Typeable i, Typeable k, Data a) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumIndex i a -> r
$cgmapQ :: forall k (i :: k) a u.
(Typeable i, Typeable k, Data a) =>
(forall d. Data d => d -> u) -> EnumIndex i a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnumIndex i a -> [u]
$cgmapQi :: forall k (i :: k) a u.
(Typeable i, Typeable k, Data a) =>
Int -> (forall d. Data d => d -> u) -> EnumIndex i a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumIndex i a -> u
$cgmapM :: forall k (i :: k) a (m :: * -> *).
(Typeable i, Typeable k, Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
$cgmapMp :: forall k (i :: k) a (m :: * -> *).
(Typeable i, Typeable k, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
$cgmapMo :: forall k (i :: k) a (m :: * -> *).
(Typeable i, Typeable k, Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumIndex i a -> m (EnumIndex i a)
Data, (forall a b. (a -> b) -> EnumIndex i a -> EnumIndex i b)
-> (forall a b. a -> EnumIndex i b -> EnumIndex i a)
-> Functor (EnumIndex i)
forall k (i :: k) a b. a -> EnumIndex i b -> EnumIndex i a
forall k (i :: k) a b. (a -> b) -> EnumIndex i a -> EnumIndex i b
forall a b. a -> EnumIndex i b -> EnumIndex i a
forall a b. (a -> b) -> EnumIndex i a -> EnumIndex i b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall k (i :: k) a b. (a -> b) -> EnumIndex i a -> EnumIndex i b
fmap :: forall a b. (a -> b) -> EnumIndex i a -> EnumIndex i b
$c<$ :: forall k (i :: k) a b. a -> EnumIndex i b -> EnumIndex i a
<$ :: forall a b. a -> EnumIndex i b -> EnumIndex i a
Functor, (forall (m :: * -> *). Quote m => EnumIndex i a -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    EnumIndex i a -> Code m (EnumIndex i a))
-> Lift (EnumIndex i a)
forall k (i :: k) a (m :: * -> *).
(Lift a, Quote m) =>
EnumIndex i a -> m Exp
forall k (i :: k) a (m :: * -> *).
(Lift a, Quote m) =>
EnumIndex i a -> Code m (EnumIndex i a)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => EnumIndex i a -> m Exp
forall (m :: * -> *).
Quote m =>
EnumIndex i a -> Code m (EnumIndex i a)
$clift :: forall k (i :: k) a (m :: * -> *).
(Lift a, Quote m) =>
EnumIndex i a -> m Exp
lift :: forall (m :: * -> *). Quote m => EnumIndex i a -> m Exp
$cliftTyped :: forall k (i :: k) a (m :: * -> *).
(Lift a, Quote m) =>
EnumIndex i a -> Code m (EnumIndex i a)
liftTyped :: forall (m :: * -> *).
Quote m =>
EnumIndex i a -> Code m (EnumIndex i a)
Lift)
  deriving newtype (EnumIndex i a -> EnumIndex i a -> Bool
(EnumIndex i a -> EnumIndex i a -> Bool)
-> (EnumIndex i a -> EnumIndex i a -> Bool) -> Eq (EnumIndex i a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (i :: k) a. Eq a => EnumIndex i a -> EnumIndex i a -> Bool
$c== :: forall k (i :: k) a. Eq a => EnumIndex i a -> EnumIndex i a -> Bool
== :: EnumIndex i a -> EnumIndex i a -> Bool
$c/= :: forall k (i :: k) a. Eq a => EnumIndex i a -> EnumIndex i a -> Bool
/= :: EnumIndex i a -> EnumIndex i a -> Bool
Eq, Eq (EnumIndex i a)
Eq (EnumIndex i a) =>
(EnumIndex i a -> EnumIndex i a -> Ordering)
-> (EnumIndex i a -> EnumIndex i a -> Bool)
-> (EnumIndex i a -> EnumIndex i a -> Bool)
-> (EnumIndex i a -> EnumIndex i a -> Bool)
-> (EnumIndex i a -> EnumIndex i a -> Bool)
-> (EnumIndex i a -> EnumIndex i a -> EnumIndex i a)
-> (EnumIndex i a -> EnumIndex i a -> EnumIndex i a)
-> Ord (EnumIndex i a)
EnumIndex i a -> EnumIndex i a -> Bool
EnumIndex i a -> EnumIndex i a -> Ordering
EnumIndex i a -> EnumIndex i a -> EnumIndex i 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 k (i :: k) a. Ord a => Eq (EnumIndex i a)
forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> Bool
forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> Ordering
forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> EnumIndex i a
$ccompare :: forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> Ordering
compare :: EnumIndex i a -> EnumIndex i a -> Ordering
$c< :: forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> Bool
< :: EnumIndex i a -> EnumIndex i a -> Bool
$c<= :: forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> Bool
<= :: EnumIndex i a -> EnumIndex i a -> Bool
$c> :: forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> Bool
> :: EnumIndex i a -> EnumIndex i a -> Bool
$c>= :: forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> Bool
>= :: EnumIndex i a -> EnumIndex i a -> Bool
$cmax :: forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> EnumIndex i a
max :: EnumIndex i a -> EnumIndex i a -> EnumIndex i a
$cmin :: forall k (i :: k) a.
Ord a =>
EnumIndex i a -> EnumIndex i a -> EnumIndex i a
min :: EnumIndex i a -> EnumIndex i a -> EnumIndex i a
Ord, Int -> EnumIndex i a -> ShowS
[EnumIndex i a] -> ShowS
EnumIndex i a -> String
(Int -> EnumIndex i a -> ShowS)
-> (EnumIndex i a -> String)
-> ([EnumIndex i a] -> ShowS)
-> Show (EnumIndex i a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (i :: k) a. Show a => Int -> EnumIndex i a -> ShowS
forall k (i :: k) a. Show a => [EnumIndex i a] -> ShowS
forall k (i :: k) a. Show a => EnumIndex i a -> String
$cshowsPrec :: forall k (i :: k) a. Show a => Int -> EnumIndex i a -> ShowS
showsPrec :: Int -> EnumIndex i a -> ShowS
$cshow :: forall k (i :: k) a. Show a => EnumIndex i a -> String
show :: EnumIndex i a -> String
$cshowList :: forall k (i :: k) a. Show a => [EnumIndex i a] -> ShowS
showList :: [EnumIndex i a] -> ShowS
Show, ReadPrec [EnumIndex i a]
ReadPrec (EnumIndex i a)
Int -> ReadS (EnumIndex i a)
ReadS [EnumIndex i a]
(Int -> ReadS (EnumIndex i a))
-> ReadS [EnumIndex i a]
-> ReadPrec (EnumIndex i a)
-> ReadPrec [EnumIndex i a]
-> Read (EnumIndex i a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (i :: k) a. Read a => ReadPrec [EnumIndex i a]
forall k (i :: k) a. Read a => ReadPrec (EnumIndex i a)
forall k (i :: k) a. Read a => Int -> ReadS (EnumIndex i a)
forall k (i :: k) a. Read a => ReadS [EnumIndex i a]
$creadsPrec :: forall k (i :: k) a. Read a => Int -> ReadS (EnumIndex i a)
readsPrec :: Int -> ReadS (EnumIndex i a)
$creadList :: forall k (i :: k) a. Read a => ReadS [EnumIndex i a]
readList :: ReadS [EnumIndex i a]
$creadPrec :: forall k (i :: k) a. Read a => ReadPrec (EnumIndex i a)
readPrec :: ReadPrec (EnumIndex i a)
$creadListPrec :: forall k (i :: k) a. Read a => ReadPrec [EnumIndex i a]
readListPrec :: ReadPrec [EnumIndex i a]
Read, Eq (EnumIndex i a)
Eq (EnumIndex i a) =>
(Int -> EnumIndex i a -> Int)
-> (EnumIndex i a -> Int) -> Hashable (EnumIndex i a)
Int -> EnumIndex i a -> Int
EnumIndex i a -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall k (i :: k) a. Hashable a => Eq (EnumIndex i a)
forall k (i :: k) a. Hashable a => Int -> EnumIndex i a -> Int
forall k (i :: k) a. Hashable a => EnumIndex i a -> Int
$chashWithSalt :: forall k (i :: k) a. Hashable a => Int -> EnumIndex i a -> Int
hashWithSalt :: Int -> EnumIndex i a -> Int
$chash :: forall k (i :: k) a. Hashable a => EnumIndex i a -> Int
hash :: EnumIndex i a -> Int
Hashable, EnumIndex i a -> ()
(EnumIndex i a -> ()) -> NFData (EnumIndex i a)
forall a. (a -> ()) -> NFData a
forall k (i :: k) a. NFData a => EnumIndex i a -> ()
$crnf :: forall k (i :: k) a. NFData a => EnumIndex i a -> ()
rnf :: EnumIndex i a -> ()
NFData)
  deriving newtype (Int -> EnumIndex i a
EnumIndex i a -> Int
EnumIndex i a -> [EnumIndex i a]
EnumIndex i a -> EnumIndex i a
EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
EnumIndex i a -> EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
(EnumIndex i a -> EnumIndex i a)
-> (EnumIndex i a -> EnumIndex i a)
-> (Int -> EnumIndex i a)
-> (EnumIndex i a -> Int)
-> (EnumIndex i a -> [EnumIndex i a])
-> (EnumIndex i a -> EnumIndex i a -> [EnumIndex i a])
-> (EnumIndex i a -> EnumIndex i a -> [EnumIndex i a])
-> (EnumIndex i a
    -> EnumIndex i a -> EnumIndex i a -> [EnumIndex i a])
-> Enum (EnumIndex i 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
forall k (i :: k) a. Enum a => Int -> EnumIndex i a
forall k (i :: k) a. Enum a => EnumIndex i a -> Int
forall k (i :: k) a. Enum a => EnumIndex i a -> [EnumIndex i a]
forall k (i :: k) a. Enum a => EnumIndex i a -> EnumIndex i a
forall k (i :: k) a.
Enum a =>
EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
forall k (i :: k) a.
Enum a =>
EnumIndex i a -> EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
$csucc :: forall k (i :: k) a. Enum a => EnumIndex i a -> EnumIndex i a
succ :: EnumIndex i a -> EnumIndex i a
$cpred :: forall k (i :: k) a. Enum a => EnumIndex i a -> EnumIndex i a
pred :: EnumIndex i a -> EnumIndex i a
$ctoEnum :: forall k (i :: k) a. Enum a => Int -> EnumIndex i a
toEnum :: Int -> EnumIndex i a
$cfromEnum :: forall k (i :: k) a. Enum a => EnumIndex i a -> Int
fromEnum :: EnumIndex i a -> Int
$cenumFrom :: forall k (i :: k) a. Enum a => EnumIndex i a -> [EnumIndex i a]
enumFrom :: EnumIndex i a -> [EnumIndex i a]
$cenumFromThen :: forall k (i :: k) a.
Enum a =>
EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
enumFromThen :: EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
$cenumFromTo :: forall k (i :: k) a.
Enum a =>
EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
enumFromTo :: EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
$cenumFromThenTo :: forall k (i :: k) a.
Enum a =>
EnumIndex i a -> EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
enumFromThenTo :: EnumIndex i a -> EnumIndex i a -> EnumIndex i a -> [EnumIndex i a]
Enum, EnumIndex i a
EnumIndex i a -> EnumIndex i a -> Bounded (EnumIndex i a)
forall a. a -> a -> Bounded a
forall k (i :: k) a. Bounded a => EnumIndex i a
$cminBound :: forall k (i :: k) a. Bounded a => EnumIndex i a
minBound :: EnumIndex i a
$cmaxBound :: forall k (i :: k) a. Bounded a => EnumIndex i a
maxBound :: EnumIndex i a
Bounded)

instance (Enum a, Integral i, Pack i) => Pack (EnumIndex i a) where
  pack :: EnumIndex i a -> Builder
pack = forall a. Pack a => a -> Builder
pack @i (i -> Builder) -> (EnumIndex i a -> i) -> EnumIndex i a -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> i
forall a b. (Integral a, Num b) => a -> b
fi (Int -> i) -> (EnumIndex i a -> Int) -> EnumIndex i a -> i
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum (a -> Int) -> (EnumIndex i a -> a) -> EnumIndex i a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnumIndex i a -> a
forall {k} (i :: k) a. EnumIndex i a -> a
enumindex
  {-# INLINEABLE pack #-}

instance
  (Enum a, Bounded a, Integral i, Unpack i) =>
  Unpack (EnumIndex i a)
  where
  unpack :: forall (st :: ZeroBitType) r. Parser st r (EnumIndex i a)
unpack = do
    let bx :: Int -> Bool
bx Int
x = a -> Int
forall a. Enum a => a -> Int
fromEnum (forall a. Bounded a => a
minBound @a) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
x Bool -> Bool -> Bool
&& Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= a -> Int
forall a. Enum a => a -> Int
fromEnum (forall a. Bounded a => a
maxBound @a)
    i -> Int
forall a b. (Integral a, Num b) => a -> b
fi (i -> Int)
-> ParserT st r ParseError i -> ParserT st r ParseError Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (st :: ZeroBitType) r. Unpack a => Parser st r a
unpack @i ParserT st r ParseError Int
-> (Int -> Parser st r (EnumIndex i a))
-> Parser st r (EnumIndex i a)
forall a b.
ParserT st r ParseError a
-> (a -> ParserT st r ParseError b) -> ParserT st r ParseError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Int
n | Int -> Bool
bx Int
n -> EnumIndex i a -> Parser st r (EnumIndex i a)
forall a. a -> ParserT st r ParseError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> EnumIndex i a
forall {k} (i :: k) a. a -> EnumIndex i a
EnumIndex (Int -> a
forall a. Enum a => Int -> a
toEnum Int
n))
      Int
n -> ParseError -> Parser st r (EnumIndex i a)
forall e (st :: ZeroBitType) r a. e -> ParserT st r e a
F.err (ParseError -> Parser st r (EnumIndex i a))
-> ParseError -> Parser st r (EnumIndex i a)
forall a b. (a -> b) -> a -> b
$ String -> ParseError
forall a b. Coercible a b => a -> b
coerce (String -> ParseError) -> String -> ParseError
forall a b. (a -> b) -> a -> b
$ String
"EnumIndex: out of bounds: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
n

-- | use an integer type @i@ for serialization of a fixed-point number
-- with resolution @r@ (see 'HasResolution', 'Fixed'), with underlying
-- numeric representation @f@
newtype Fixed' i r f = Fixed' {forall {k} {k} (i :: k) (r :: k) f. Fixed' i r f -> f
unfixed' :: f}
  deriving stock ((forall x. Fixed' i r f -> Rep (Fixed' i r f) x)
-> (forall x. Rep (Fixed' i r f) x -> Fixed' i r f)
-> Generic (Fixed' i r f)
forall x. Rep (Fixed' i r f) x -> Fixed' i r f
forall x. Fixed' i r f -> Rep (Fixed' i r f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (i :: k) k (r :: k) f x.
Rep (Fixed' i r f) x -> Fixed' i r f
forall k (i :: k) k (r :: k) f x.
Fixed' i r f -> Rep (Fixed' i r f) x
$cfrom :: forall k (i :: k) k (r :: k) f x.
Fixed' i r f -> Rep (Fixed' i r f) x
from :: forall x. Fixed' i r f -> Rep (Fixed' i r f) x
$cto :: forall k (i :: k) k (r :: k) f x.
Rep (Fixed' i r f) x -> Fixed' i r f
to :: forall x. Rep (Fixed' i r f) x -> Fixed' i r f
Generic, Typeable, Typeable (Fixed' i r f)
Typeable (Fixed' i r f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Fixed' i r f -> c (Fixed' i r f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Fixed' i r f))
-> (Fixed' i r f -> Constr)
-> (Fixed' i r f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Fixed' i r f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Fixed' i r f)))
-> ((forall b. Data b => b -> b) -> Fixed' i r f -> Fixed' i r f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r)
-> (forall u. (forall d. Data d => d -> u) -> Fixed' i r f -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Fixed' i r f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f))
-> Data (Fixed' i r f)
Fixed' i r f -> Constr
Fixed' i r f -> DataType
(forall b. Data b => b -> b) -> Fixed' i r f -> Fixed' i r f
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Fixed' i r f -> u
forall u. (forall d. Data d => d -> u) -> Fixed' i r f -> [u]
forall k (i :: k) k (r :: k) f.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
Typeable (Fixed' i r f)
forall k (i :: k) k (r :: k) f.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
Fixed' i r f -> Constr
forall k (i :: k) k (r :: k) f.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
Fixed' i r f -> DataType
forall k (i :: k) k (r :: k) f.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall b. Data b => b -> b) -> Fixed' i r f -> Fixed' i r f
forall k (i :: k) k (r :: k) f u.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
Int -> (forall d. Data d => d -> u) -> Fixed' i r f -> u
forall k (i :: k) k (r :: k) f u.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall d. Data d => d -> u) -> Fixed' i r f -> [u]
forall k (i :: k) k (r :: k) f r r'.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
forall k (i :: k) k (r :: k) f r r'.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
forall k (i :: k) k (r :: k) f (m :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 Monad m) =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
forall k (i :: k) k (r :: k) f (m :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
forall k (i :: k) k (r :: k) f (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Fixed' i r f)
forall k (i :: k) k (r :: k) f (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixed' i r f -> c (Fixed' i r f)
forall k (i :: k) k (r :: k) f (t :: * -> *) (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Fixed' i r f))
forall k (i :: k) k (r :: k) f (t :: * -> * -> *) (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Fixed' i r f))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Fixed' i r f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixed' i r f -> c (Fixed' i r f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Fixed' i r f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Fixed' i r f))
$cgfoldl :: forall k (i :: k) k (r :: k) f (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixed' i r f -> c (Fixed' i r f)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixed' i r f -> c (Fixed' i r f)
$cgunfold :: forall k (i :: k) k (r :: k) f (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Fixed' i r f)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Fixed' i r f)
$ctoConstr :: forall k (i :: k) k (r :: k) f.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
Fixed' i r f -> Constr
toConstr :: Fixed' i r f -> Constr
$cdataTypeOf :: forall k (i :: k) k (r :: k) f.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
Fixed' i r f -> DataType
dataTypeOf :: Fixed' i r f -> DataType
$cdataCast1 :: forall k (i :: k) k (r :: k) f (t :: * -> *) (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Fixed' i r f))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Fixed' i r f))
$cdataCast2 :: forall k (i :: k) k (r :: k) f (t :: * -> * -> *) (c :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Fixed' i r f))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Fixed' i r f))
$cgmapT :: forall k (i :: k) k (r :: k) f.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall b. Data b => b -> b) -> Fixed' i r f -> Fixed' i r f
gmapT :: (forall b. Data b => b -> b) -> Fixed' i r f -> Fixed' i r f
$cgmapQl :: forall k (i :: k) k (r :: k) f r r'.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
$cgmapQr :: forall k (i :: k) k (r :: k) f r r'.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fixed' i r f -> r
$cgmapQ :: forall k (i :: k) k (r :: k) f u.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
(forall d. Data d => d -> u) -> Fixed' i r f -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Fixed' i r f -> [u]
$cgmapQi :: forall k (i :: k) k (r :: k) f u.
(Typeable i, Typeable r, Typeable k, Typeable k, Data f) =>
Int -> (forall d. Data d => d -> u) -> Fixed' i r f -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fixed' i r f -> u
$cgmapM :: forall k (i :: k) k (r :: k) f (m :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 Monad m) =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
$cgmapMp :: forall k (i :: k) k (r :: k) f (m :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
$cgmapMo :: forall k (i :: k) k (r :: k) f (m :: * -> *).
(Typeable i, Typeable r, Typeable k, Typeable k, Data f,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixed' i r f -> m (Fixed' i r f)
Data, (forall (m :: * -> *). Quote m => Fixed' i r f -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    Fixed' i r f -> Code m (Fixed' i r f))
-> Lift (Fixed' i r f)
forall k (i :: k) k (r :: k) f (m :: * -> *).
(Lift f, Quote m) =>
Fixed' i r f -> m Exp
forall k (i :: k) k (r :: k) f (m :: * -> *).
(Lift f, Quote m) =>
Fixed' i r f -> Code m (Fixed' i r f)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Fixed' i r f -> m Exp
forall (m :: * -> *).
Quote m =>
Fixed' i r f -> Code m (Fixed' i r f)
$clift :: forall k (i :: k) k (r :: k) f (m :: * -> *).
(Lift f, Quote m) =>
Fixed' i r f -> m Exp
lift :: forall (m :: * -> *). Quote m => Fixed' i r f -> m Exp
$cliftTyped :: forall k (i :: k) k (r :: k) f (m :: * -> *).
(Lift f, Quote m) =>
Fixed' i r f -> Code m (Fixed' i r f)
liftTyped :: forall (m :: * -> *).
Quote m =>
Fixed' i r f -> Code m (Fixed' i r f)
Lift)
  deriving newtype (Fixed' i r f -> Fixed' i r f -> Bool
(Fixed' i r f -> Fixed' i r f -> Bool)
-> (Fixed' i r f -> Fixed' i r f -> Bool) -> Eq (Fixed' i r f)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (i :: k) k (r :: k) f.
Eq f =>
Fixed' i r f -> Fixed' i r f -> Bool
$c== :: forall k (i :: k) k (r :: k) f.
Eq f =>
Fixed' i r f -> Fixed' i r f -> Bool
== :: Fixed' i r f -> Fixed' i r f -> Bool
$c/= :: forall k (i :: k) k (r :: k) f.
Eq f =>
Fixed' i r f -> Fixed' i r f -> Bool
/= :: Fixed' i r f -> Fixed' i r f -> Bool
Eq, Eq (Fixed' i r f)
Eq (Fixed' i r f) =>
(Fixed' i r f -> Fixed' i r f -> Ordering)
-> (Fixed' i r f -> Fixed' i r f -> Bool)
-> (Fixed' i r f -> Fixed' i r f -> Bool)
-> (Fixed' i r f -> Fixed' i r f -> Bool)
-> (Fixed' i r f -> Fixed' i r f -> Bool)
-> (Fixed' i r f -> Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f -> Fixed' i r f)
-> Ord (Fixed' i r f)
Fixed' i r f -> Fixed' i r f -> Bool
Fixed' i r f -> Fixed' i r f -> Ordering
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
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 k (i :: k) k (r :: k) f. Ord f => Eq (Fixed' i r f)
forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Bool
forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Ordering
forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$ccompare :: forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Ordering
compare :: Fixed' i r f -> Fixed' i r f -> Ordering
$c< :: forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Bool
< :: Fixed' i r f -> Fixed' i r f -> Bool
$c<= :: forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Bool
<= :: Fixed' i r f -> Fixed' i r f -> Bool
$c> :: forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Bool
> :: Fixed' i r f -> Fixed' i r f -> Bool
$c>= :: forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Bool
>= :: Fixed' i r f -> Fixed' i r f -> Bool
$cmax :: forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
max :: Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$cmin :: forall k (i :: k) k (r :: k) f.
Ord f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
min :: Fixed' i r f -> Fixed' i r f -> Fixed' i r f
Ord, Int -> Fixed' i r f -> ShowS
[Fixed' i r f] -> ShowS
Fixed' i r f -> String
(Int -> Fixed' i r f -> ShowS)
-> (Fixed' i r f -> String)
-> ([Fixed' i r f] -> ShowS)
-> Show (Fixed' i r f)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (i :: k) k (r :: k) f.
Show f =>
Int -> Fixed' i r f -> ShowS
forall k (i :: k) k (r :: k) f. Show f => [Fixed' i r f] -> ShowS
forall k (i :: k) k (r :: k) f. Show f => Fixed' i r f -> String
$cshowsPrec :: forall k (i :: k) k (r :: k) f.
Show f =>
Int -> Fixed' i r f -> ShowS
showsPrec :: Int -> Fixed' i r f -> ShowS
$cshow :: forall k (i :: k) k (r :: k) f. Show f => Fixed' i r f -> String
show :: Fixed' i r f -> String
$cshowList :: forall k (i :: k) k (r :: k) f. Show f => [Fixed' i r f] -> ShowS
showList :: [Fixed' i r f] -> ShowS
Show, ReadPrec [Fixed' i r f]
ReadPrec (Fixed' i r f)
Int -> ReadS (Fixed' i r f)
ReadS [Fixed' i r f]
(Int -> ReadS (Fixed' i r f))
-> ReadS [Fixed' i r f]
-> ReadPrec (Fixed' i r f)
-> ReadPrec [Fixed' i r f]
-> Read (Fixed' i r f)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (i :: k) k (r :: k) f. Read f => ReadPrec [Fixed' i r f]
forall k (i :: k) k (r :: k) f. Read f => ReadPrec (Fixed' i r f)
forall k (i :: k) k (r :: k) f.
Read f =>
Int -> ReadS (Fixed' i r f)
forall k (i :: k) k (r :: k) f. Read f => ReadS [Fixed' i r f]
$creadsPrec :: forall k (i :: k) k (r :: k) f.
Read f =>
Int -> ReadS (Fixed' i r f)
readsPrec :: Int -> ReadS (Fixed' i r f)
$creadList :: forall k (i :: k) k (r :: k) f. Read f => ReadS [Fixed' i r f]
readList :: ReadS [Fixed' i r f]
$creadPrec :: forall k (i :: k) k (r :: k) f. Read f => ReadPrec (Fixed' i r f)
readPrec :: ReadPrec (Fixed' i r f)
$creadListPrec :: forall k (i :: k) k (r :: k) f. Read f => ReadPrec [Fixed' i r f]
readListPrec :: ReadPrec [Fixed' i r f]
Read, Eq (Fixed' i r f)
Eq (Fixed' i r f) =>
(Int -> Fixed' i r f -> Int)
-> (Fixed' i r f -> Int) -> Hashable (Fixed' i r f)
Int -> Fixed' i r f -> Int
Fixed' i r f -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall k (i :: k) k (r :: k) f. Hashable f => Eq (Fixed' i r f)
forall k (i :: k) k (r :: k) f.
Hashable f =>
Int -> Fixed' i r f -> Int
forall k (i :: k) k (r :: k) f. Hashable f => Fixed' i r f -> Int
$chashWithSalt :: forall k (i :: k) k (r :: k) f.
Hashable f =>
Int -> Fixed' i r f -> Int
hashWithSalt :: Int -> Fixed' i r f -> Int
$chash :: forall k (i :: k) k (r :: k) f. Hashable f => Fixed' i r f -> Int
hash :: Fixed' i r f -> Int
Hashable, Fixed' i r f -> ()
(Fixed' i r f -> ()) -> NFData (Fixed' i r f)
forall a. (a -> ()) -> NFData a
forall k (i :: k) k (r :: k) f. NFData f => Fixed' i r f -> ()
$crnf :: forall k (i :: k) k (r :: k) f. NFData f => Fixed' i r f -> ()
rnf :: Fixed' i r f -> ()
NFData)
  deriving newtype (Int -> Fixed' i r f
Fixed' i r f -> Int
Fixed' i r f -> [Fixed' i r f]
Fixed' i r f -> Fixed' i r f
Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
Fixed' i r f -> Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
(Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f)
-> (Int -> Fixed' i r f)
-> (Fixed' i r f -> Int)
-> (Fixed' i r f -> [Fixed' i r f])
-> (Fixed' i r f -> Fixed' i r f -> [Fixed' i r f])
-> (Fixed' i r f -> Fixed' i r f -> [Fixed' i r f])
-> (Fixed' i r f -> Fixed' i r f -> Fixed' i r f -> [Fixed' i r f])
-> Enum (Fixed' i r f)
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
forall k (i :: k) k (r :: k) f. Enum f => Int -> Fixed' i r f
forall k (i :: k) k (r :: k) f. Enum f => Fixed' i r f -> Int
forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> [Fixed' i r f]
forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f
forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
$csucc :: forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f
succ :: Fixed' i r f -> Fixed' i r f
$cpred :: forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f
pred :: Fixed' i r f -> Fixed' i r f
$ctoEnum :: forall k (i :: k) k (r :: k) f. Enum f => Int -> Fixed' i r f
toEnum :: Int -> Fixed' i r f
$cfromEnum :: forall k (i :: k) k (r :: k) f. Enum f => Fixed' i r f -> Int
fromEnum :: Fixed' i r f -> Int
$cenumFrom :: forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> [Fixed' i r f]
enumFrom :: Fixed' i r f -> [Fixed' i r f]
$cenumFromThen :: forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
enumFromThen :: Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
$cenumFromTo :: forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
enumFromTo :: Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
$cenumFromThenTo :: forall k (i :: k) k (r :: k) f.
Enum f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
enumFromThenTo :: Fixed' i r f -> Fixed' i r f -> Fixed' i r f -> [Fixed' i r f]
Enum, Integer -> Fixed' i r f
Fixed' i r f -> Fixed' i r f
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
(Fixed' i r f -> Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f)
-> (Integer -> Fixed' i r f)
-> Num (Fixed' i r f)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall k (i :: k) k (r :: k) f. Num f => Integer -> Fixed' i r f
forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f
forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$c+ :: forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
+ :: Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$c- :: forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
- :: Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$c* :: forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
* :: Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$cnegate :: forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f
negate :: Fixed' i r f -> Fixed' i r f
$cabs :: forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f
abs :: Fixed' i r f -> Fixed' i r f
$csignum :: forall k (i :: k) k (r :: k) f.
Num f =>
Fixed' i r f -> Fixed' i r f
signum :: Fixed' i r f -> Fixed' i r f
$cfromInteger :: forall k (i :: k) k (r :: k) f. Num f => Integer -> Fixed' i r f
fromInteger :: Integer -> Fixed' i r f
Num, Num (Fixed' i r f)
Ord (Fixed' i r f)
(Num (Fixed' i r f), Ord (Fixed' i r f)) =>
(Fixed' i r f -> Rational) -> Real (Fixed' i r f)
Fixed' i r f -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
forall k (i :: k) k (r :: k) f. Real f => Num (Fixed' i r f)
forall k (i :: k) k (r :: k) f. Real f => Ord (Fixed' i r f)
forall k (i :: k) k (r :: k) f. Real f => Fixed' i r f -> Rational
$ctoRational :: forall k (i :: k) k (r :: k) f. Real f => Fixed' i r f -> Rational
toRational :: Fixed' i r f -> Rational
Real, Num (Fixed' i r f)
Num (Fixed' i r f) =>
(Fixed' i r f -> Fixed' i r f -> Fixed' i r f)
-> (Fixed' i r f -> Fixed' i r f)
-> (Rational -> Fixed' i r f)
-> Fractional (Fixed' i r f)
Rational -> Fixed' i r f
Fixed' i r f -> Fixed' i r f
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
forall a.
Num a =>
(a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall k (i :: k) k (r :: k) f. Fractional f => Num (Fixed' i r f)
forall k (i :: k) k (r :: k) f.
Fractional f =>
Rational -> Fixed' i r f
forall k (i :: k) k (r :: k) f.
Fractional f =>
Fixed' i r f -> Fixed' i r f
forall k (i :: k) k (r :: k) f.
Fractional f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$c/ :: forall k (i :: k) k (r :: k) f.
Fractional f =>
Fixed' i r f -> Fixed' i r f -> Fixed' i r f
/ :: Fixed' i r f -> Fixed' i r f -> Fixed' i r f
$crecip :: forall k (i :: k) k (r :: k) f.
Fractional f =>
Fixed' i r f -> Fixed' i r f
recip :: Fixed' i r f -> Fixed' i r f
$cfromRational :: forall k (i :: k) k (r :: k) f.
Fractional f =>
Rational -> Fixed' i r f
fromRational :: Rational -> Fixed' i r f
Fractional, Fractional (Fixed' i r f)
Real (Fixed' i r f)
(Real (Fixed' i r f), Fractional (Fixed' i r f)) =>
(forall b. Integral b => Fixed' i r f -> (b, Fixed' i r f))
-> (forall b. Integral b => Fixed' i r f -> b)
-> (forall b. Integral b => Fixed' i r f -> b)
-> (forall b. Integral b => Fixed' i r f -> b)
-> (forall b. Integral b => Fixed' i r f -> b)
-> RealFrac (Fixed' i r f)
forall b. Integral b => Fixed' i r f -> b
forall b. Integral b => Fixed' i r f -> (b, Fixed' i r f)
forall a.
(Real a, Fractional a) =>
(forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
forall k (i :: k) k (r :: k) f.
RealFrac f =>
Fractional (Fixed' i r f)
forall k (i :: k) k (r :: k) f. RealFrac f => Real (Fixed' i r f)
forall k (i :: k) k (r :: k) f b.
(RealFrac f, Integral b) =>
Fixed' i r f -> b
forall k (i :: k) k (r :: k) f b.
(RealFrac f, Integral b) =>
Fixed' i r f -> (b, Fixed' i r f)
$cproperFraction :: forall k (i :: k) k (r :: k) f b.
(RealFrac f, Integral b) =>
Fixed' i r f -> (b, Fixed' i r f)
properFraction :: forall b. Integral b => Fixed' i r f -> (b, Fixed' i r f)
$ctruncate :: forall k (i :: k) k (r :: k) f b.
(RealFrac f, Integral b) =>
Fixed' i r f -> b
truncate :: forall b. Integral b => Fixed' i r f -> b
$cround :: forall k (i :: k) k (r :: k) f b.
(RealFrac f, Integral b) =>
Fixed' i r f -> b
round :: forall b. Integral b => Fixed' i r f -> b
$cceiling :: forall k (i :: k) k (r :: k) f b.
(RealFrac f, Integral b) =>
Fixed' i r f -> b
ceiling :: forall b. Integral b => Fixed' i r f -> b
$cfloor :: forall k (i :: k) k (r :: k) f b.
(RealFrac f, Integral b) =>
Fixed' i r f -> b
floor :: forall b. Integral b => Fixed' i r f -> b
RealFrac)

unfix :: Fixed r -> Integer
unfix :: forall {k} (r :: k). Fixed r -> Integer
unfix (MkFixed Integer
x) = Integer
x
{-# INLINE unfix #-}

instance
  (Integral i, Pack i, Real f, HasResolution r) =>
  Pack (Fixed' i r f)
  where
  pack :: Fixed' i r f -> Builder
pack =
    forall a. Pack a => a -> Builder
pack @i
      (i -> Builder) -> (Fixed' i r f -> i) -> Fixed' i r f -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> i
forall a b. (Integral a, Num b) => a -> b
fi
      (Integer -> i) -> (Fixed' i r f -> Integer) -> Fixed' i r f -> i
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fixed r -> Integer
forall {k} (r :: k). Fixed r -> Integer
unfix :: Fixed r -> Integer)
      (Fixed r -> Integer)
-> (Fixed' i r f -> Fixed r) -> Fixed' i r f -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f -> Fixed r
forall a b. (Real a, Fractional b) => a -> b
realToFrac
      (f -> Fixed r) -> (Fixed' i r f -> f) -> Fixed' i r f -> Fixed r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fixed' i r f -> f
forall {k} {k} (i :: k) (r :: k) f. Fixed' i r f -> f
unfixed'
  {-# INLINEABLE pack #-}

instance
  (Integral i, Unpack i, Fractional f, HasResolution r) =>
  Unpack (Fixed' i r f)
  where
  unpack :: forall (st :: ZeroBitType) r. Parser st r (Fixed' i r f)
unpack =
    f -> Fixed' i r f
forall {k} {k} (i :: k) (r :: k) f. f -> Fixed' i r f
Fixed'
      (f -> Fixed' i r f) -> (i -> f) -> i -> Fixed' i r f
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fixed r -> f
forall a b. (Real a, Fractional b) => a -> b
realToFrac :: Fixed r -> f)
      (Fixed r -> f) -> (i -> Fixed r) -> i -> f
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Fixed r
forall k (a :: k). Integer -> Fixed a
MkFixed
      (Integer -> Fixed r) -> (i -> Integer) -> i -> Fixed r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. i -> Integer
forall a b. (Integral a, Num b) => a -> b
fi
      (i -> Fixed' i r f)
-> ParserT st r ParseError i
-> ParserT st r ParseError (Fixed' i r f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (st :: ZeroBitType) r. Unpack a => Parser st r a
unpack @i
  {-# INLINEABLE unpack #-}

-- | a signed angle; divides the circle into 256 parts
newtype Int8Angle = Int8Angle {Int8Angle -> Int8
int8angle :: Int8}
  deriving stock ((forall x. Int8Angle -> Rep Int8Angle x)
-> (forall x. Rep Int8Angle x -> Int8Angle) -> Generic Int8Angle
forall x. Rep Int8Angle x -> Int8Angle
forall x. Int8Angle -> Rep Int8Angle x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Int8Angle -> Rep Int8Angle x
from :: forall x. Int8Angle -> Rep Int8Angle x
$cto :: forall x. Rep Int8Angle x -> Int8Angle
to :: forall x. Rep Int8Angle x -> Int8Angle
Generic, Typeable, Typeable Int8Angle
Typeable Int8Angle =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Int8Angle -> c Int8Angle)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Int8Angle)
-> (Int8Angle -> Constr)
-> (Int8Angle -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Int8Angle))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8Angle))
-> ((forall b. Data b => b -> b) -> Int8Angle -> Int8Angle)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Int8Angle -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Int8Angle -> r)
-> (forall u. (forall d. Data d => d -> u) -> Int8Angle -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Int8Angle -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle)
-> Data Int8Angle
Int8Angle -> Constr
Int8Angle -> DataType
(forall b. Data b => b -> b) -> Int8Angle -> Int8Angle
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Int8Angle -> u
forall u. (forall d. Data d => d -> u) -> Int8Angle -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Int8Angle -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Int8Angle -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Int8Angle
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Int8Angle -> c Int8Angle
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Int8Angle)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8Angle)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Int8Angle -> c Int8Angle
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Int8Angle -> c Int8Angle
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Int8Angle
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Int8Angle
$ctoConstr :: Int8Angle -> Constr
toConstr :: Int8Angle -> Constr
$cdataTypeOf :: Int8Angle -> DataType
dataTypeOf :: Int8Angle -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Int8Angle)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Int8Angle)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8Angle)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8Angle)
$cgmapT :: (forall b. Data b => b -> b) -> Int8Angle -> Int8Angle
gmapT :: (forall b. Data b => b -> b) -> Int8Angle -> Int8Angle
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Int8Angle -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Int8Angle -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Int8Angle -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Int8Angle -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Int8Angle -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Int8Angle -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Int8Angle -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Int8Angle -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Int8Angle -> m Int8Angle
Data, (forall (m :: * -> *). Quote m => Int8Angle -> m Exp)
-> (forall (m :: * -> *). Quote m => Int8Angle -> Code m Int8Angle)
-> Lift Int8Angle
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Int8Angle -> m Exp
forall (m :: * -> *). Quote m => Int8Angle -> Code m Int8Angle
$clift :: forall (m :: * -> *). Quote m => Int8Angle -> m Exp
lift :: forall (m :: * -> *). Quote m => Int8Angle -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Int8Angle -> Code m Int8Angle
liftTyped :: forall (m :: * -> *). Quote m => Int8Angle -> Code m Int8Angle
Lift)
  deriving newtype (Int8Angle -> Int8Angle -> Bool
(Int8Angle -> Int8Angle -> Bool)
-> (Int8Angle -> Int8Angle -> Bool) -> Eq Int8Angle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Int8Angle -> Int8Angle -> Bool
== :: Int8Angle -> Int8Angle -> Bool
$c/= :: Int8Angle -> Int8Angle -> Bool
/= :: Int8Angle -> Int8Angle -> Bool
Eq, Eq Int8Angle
Eq Int8Angle =>
(Int8Angle -> Int8Angle -> Ordering)
-> (Int8Angle -> Int8Angle -> Bool)
-> (Int8Angle -> Int8Angle -> Bool)
-> (Int8Angle -> Int8Angle -> Bool)
-> (Int8Angle -> Int8Angle -> Bool)
-> (Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle -> Int8Angle)
-> Ord Int8Angle
Int8Angle -> Int8Angle -> Bool
Int8Angle -> Int8Angle -> Ordering
Int8Angle -> Int8Angle -> Int8Angle
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Int8Angle -> Int8Angle -> Ordering
compare :: Int8Angle -> Int8Angle -> Ordering
$c< :: Int8Angle -> Int8Angle -> Bool
< :: Int8Angle -> Int8Angle -> Bool
$c<= :: Int8Angle -> Int8Angle -> Bool
<= :: Int8Angle -> Int8Angle -> Bool
$c> :: Int8Angle -> Int8Angle -> Bool
> :: Int8Angle -> Int8Angle -> Bool
$c>= :: Int8Angle -> Int8Angle -> Bool
>= :: Int8Angle -> Int8Angle -> Bool
$cmax :: Int8Angle -> Int8Angle -> Int8Angle
max :: Int8Angle -> Int8Angle -> Int8Angle
$cmin :: Int8Angle -> Int8Angle -> Int8Angle
min :: Int8Angle -> Int8Angle -> Int8Angle
Ord, Int -> Int8Angle -> ShowS
[Int8Angle] -> ShowS
Int8Angle -> String
(Int -> Int8Angle -> ShowS)
-> (Int8Angle -> String)
-> ([Int8Angle] -> ShowS)
-> Show Int8Angle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Int8Angle -> ShowS
showsPrec :: Int -> Int8Angle -> ShowS
$cshow :: Int8Angle -> String
show :: Int8Angle -> String
$cshowList :: [Int8Angle] -> ShowS
showList :: [Int8Angle] -> ShowS
Show, ReadPrec [Int8Angle]
ReadPrec Int8Angle
Int -> ReadS Int8Angle
ReadS [Int8Angle]
(Int -> ReadS Int8Angle)
-> ReadS [Int8Angle]
-> ReadPrec Int8Angle
-> ReadPrec [Int8Angle]
-> Read Int8Angle
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Int8Angle
readsPrec :: Int -> ReadS Int8Angle
$creadList :: ReadS [Int8Angle]
readList :: ReadS [Int8Angle]
$creadPrec :: ReadPrec Int8Angle
readPrec :: ReadPrec Int8Angle
$creadListPrec :: ReadPrec [Int8Angle]
readListPrec :: ReadPrec [Int8Angle]
Read, Eq Int8Angle
Eq Int8Angle =>
(Int -> Int8Angle -> Int)
-> (Int8Angle -> Int) -> Hashable Int8Angle
Int -> Int8Angle -> Int
Int8Angle -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Int8Angle -> Int
hashWithSalt :: Int -> Int8Angle -> Int
$chash :: Int8Angle -> Int
hash :: Int8Angle -> Int
Hashable, Int8Angle -> ()
(Int8Angle -> ()) -> NFData Int8Angle
forall a. (a -> ()) -> NFData a
$crnf :: Int8Angle -> ()
rnf :: Int8Angle -> ()
NFData)
  deriving newtype (Int -> Int8Angle
Int8Angle -> Int
Int8Angle -> [Int8Angle]
Int8Angle -> Int8Angle
Int8Angle -> Int8Angle -> [Int8Angle]
Int8Angle -> Int8Angle -> Int8Angle -> [Int8Angle]
(Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle)
-> (Int -> Int8Angle)
-> (Int8Angle -> Int)
-> (Int8Angle -> [Int8Angle])
-> (Int8Angle -> Int8Angle -> [Int8Angle])
-> (Int8Angle -> Int8Angle -> [Int8Angle])
-> (Int8Angle -> Int8Angle -> Int8Angle -> [Int8Angle])
-> Enum Int8Angle
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Int8Angle -> Int8Angle
succ :: Int8Angle -> Int8Angle
$cpred :: Int8Angle -> Int8Angle
pred :: Int8Angle -> Int8Angle
$ctoEnum :: Int -> Int8Angle
toEnum :: Int -> Int8Angle
$cfromEnum :: Int8Angle -> Int
fromEnum :: Int8Angle -> Int
$cenumFrom :: Int8Angle -> [Int8Angle]
enumFrom :: Int8Angle -> [Int8Angle]
$cenumFromThen :: Int8Angle -> Int8Angle -> [Int8Angle]
enumFromThen :: Int8Angle -> Int8Angle -> [Int8Angle]
$cenumFromTo :: Int8Angle -> Int8Angle -> [Int8Angle]
enumFromTo :: Int8Angle -> Int8Angle -> [Int8Angle]
$cenumFromThenTo :: Int8Angle -> Int8Angle -> Int8Angle -> [Int8Angle]
enumFromThenTo :: Int8Angle -> Int8Angle -> Int8Angle -> [Int8Angle]
Enum, Integer -> Int8Angle
Int8Angle -> Int8Angle
Int8Angle -> Int8Angle -> Int8Angle
(Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle)
-> (Integer -> Int8Angle)
-> Num Int8Angle
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Int8Angle -> Int8Angle -> Int8Angle
+ :: Int8Angle -> Int8Angle -> Int8Angle
$c- :: Int8Angle -> Int8Angle -> Int8Angle
- :: Int8Angle -> Int8Angle -> Int8Angle
$c* :: Int8Angle -> Int8Angle -> Int8Angle
* :: Int8Angle -> Int8Angle -> Int8Angle
$cnegate :: Int8Angle -> Int8Angle
negate :: Int8Angle -> Int8Angle
$cabs :: Int8Angle -> Int8Angle
abs :: Int8Angle -> Int8Angle
$csignum :: Int8Angle -> Int8Angle
signum :: Int8Angle -> Int8Angle
$cfromInteger :: Integer -> Int8Angle
fromInteger :: Integer -> Int8Angle
Num, Num Int8Angle
Ord Int8Angle
(Num Int8Angle, Ord Int8Angle) =>
(Int8Angle -> Rational) -> Real Int8Angle
Int8Angle -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: Int8Angle -> Rational
toRational :: Int8Angle -> Rational
Real, Enum Int8Angle
Real Int8Angle
(Real Int8Angle, Enum Int8Angle) =>
(Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle -> Int8Angle)
-> (Int8Angle -> Int8Angle -> (Int8Angle, Int8Angle))
-> (Int8Angle -> Int8Angle -> (Int8Angle, Int8Angle))
-> (Int8Angle -> Integer)
-> Integral Int8Angle
Int8Angle -> Integer
Int8Angle -> Int8Angle -> (Int8Angle, Int8Angle)
Int8Angle -> Int8Angle -> Int8Angle
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: Int8Angle -> Int8Angle -> Int8Angle
quot :: Int8Angle -> Int8Angle -> Int8Angle
$crem :: Int8Angle -> Int8Angle -> Int8Angle
rem :: Int8Angle -> Int8Angle -> Int8Angle
$cdiv :: Int8Angle -> Int8Angle -> Int8Angle
div :: Int8Angle -> Int8Angle -> Int8Angle
$cmod :: Int8Angle -> Int8Angle -> Int8Angle
mod :: Int8Angle -> Int8Angle -> Int8Angle
$cquotRem :: Int8Angle -> Int8Angle -> (Int8Angle, Int8Angle)
quotRem :: Int8Angle -> Int8Angle -> (Int8Angle, Int8Angle)
$cdivMod :: Int8Angle -> Int8Angle -> (Int8Angle, Int8Angle)
divMod :: Int8Angle -> Int8Angle -> (Int8Angle, Int8Angle)
$ctoInteger :: Int8Angle -> Integer
toInteger :: Int8Angle -> Integer
Integral, Int8Angle -> Builder
(Int8Angle -> Builder) -> Pack Int8Angle
forall a. (a -> Builder) -> Pack a
$cpack :: Int8Angle -> Builder
pack :: Int8Angle -> Builder
Pack, (forall (st :: ZeroBitType) r. Parser st r Int8Angle)
-> Unpack Int8Angle
forall (st :: ZeroBitType) r. Parser st r Int8Angle
forall a. (forall (st :: ZeroBitType) r. Parser st r a) -> Unpack a
$cunpack :: forall (st :: ZeroBitType) r. Parser st r Int8Angle
unpack :: forall (st :: ZeroBitType) r. Parser st r Int8Angle
Unpack)

-- | convert degrees to 'Int8Angle'
degtoi8angle :: (RealFrac a) => a -> Int8Angle
degtoi8angle :: forall a. RealFrac a => a -> Int8Angle
degtoi8angle a
x = Int8 -> Int8Angle
Int8Angle (a -> Int8
forall b. Integral b => a -> b
forall a b. (RealFrac a, Integral b) => a -> b
round ((a
x a -> a -> a
forall a. Num a => a -> a -> a
* (a
256 a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
360)) a -> a -> a
forall a. Real a => a -> a -> a
`mod'` a
256))
{-# INLINEABLE degtoi8angle #-}

-- | convert 'Int8Angle' to degrees
i8angledeg :: (RealFrac a) => Int8Angle -> a
i8angledeg :: forall a. RealFrac a => Int8Angle -> a
i8angledeg (Int8Angle Int8
x) = Int8 -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int8
x a -> a -> a
forall a. Num a => a -> a -> a
* (a
360 a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
256)
{-# INLINEABLE i8angledeg #-}

-- | an \"identifier\" string, used for names, tags, etc.
--
-- example: @minecraft:stone@ or @stone/stone@
--
-- validation only happens when unpacking ('unpack')
newtype Identifier = Identifier {Identifier -> Text
identifier :: Text}
  deriving stock
    ( (forall x. Identifier -> Rep Identifier x)
-> (forall x. Rep Identifier x -> Identifier) -> Generic Identifier
forall x. Rep Identifier x -> Identifier
forall x. Identifier -> Rep Identifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Identifier -> Rep Identifier x
from :: forall x. Identifier -> Rep Identifier x
$cto :: forall x. Rep Identifier x -> Identifier
to :: forall x. Rep Identifier x -> Identifier
Generic,
      Typeable,
      Typeable Identifier
Typeable Identifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Identifier -> c Identifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Identifier)
-> (Identifier -> Constr)
-> (Identifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Identifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Identifier))
-> ((forall b. Data b => b -> b) -> Identifier -> Identifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall u. (forall d. Data d => d -> u) -> Identifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Identifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> Data Identifier
Identifier -> Constr
Identifier -> DataType
(forall b. Data b => b -> b) -> Identifier -> Identifier
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
$ctoConstr :: Identifier -> Constr
toConstr :: Identifier -> Constr
$cdataTypeOf :: Identifier -> DataType
dataTypeOf :: Identifier -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cgmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
gmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
Data,
      (forall (m :: * -> *). Quote m => Identifier -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    Identifier -> Code m Identifier)
-> Lift Identifier
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Identifier -> m Exp
forall (m :: * -> *). Quote m => Identifier -> Code m Identifier
$clift :: forall (m :: * -> *). Quote m => Identifier -> m Exp
lift :: forall (m :: * -> *). Quote m => Identifier -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Identifier -> Code m Identifier
liftTyped :: forall (m :: * -> *). Quote m => Identifier -> Code m Identifier
Lift
    )
  deriving anyclass (Identifier -> ()
(Identifier -> ()) -> NFData Identifier
forall a. (a -> ()) -> NFData a
$crnf :: Identifier -> ()
rnf :: Identifier -> ()
NFData)
  deriving newtype
    ( Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
/= :: Identifier -> Identifier -> Bool
Eq,
      Eq Identifier
Eq Identifier =>
(Identifier -> Identifier -> Ordering)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Identifier)
-> (Identifier -> Identifier -> Identifier)
-> Ord Identifier
Identifier -> Identifier -> Bool
Identifier -> Identifier -> Ordering
Identifier -> Identifier -> Identifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Identifier -> Identifier -> Ordering
compare :: Identifier -> Identifier -> Ordering
$c< :: Identifier -> Identifier -> Bool
< :: Identifier -> Identifier -> Bool
$c<= :: Identifier -> Identifier -> Bool
<= :: Identifier -> Identifier -> Bool
$c> :: Identifier -> Identifier -> Bool
> :: Identifier -> Identifier -> Bool
$c>= :: Identifier -> Identifier -> Bool
>= :: Identifier -> Identifier -> Bool
$cmax :: Identifier -> Identifier -> Identifier
max :: Identifier -> Identifier -> Identifier
$cmin :: Identifier -> Identifier -> Identifier
min :: Identifier -> Identifier -> Identifier
Ord,
      Int -> Identifier -> ShowS
[Identifier] -> ShowS
Identifier -> String
(Int -> Identifier -> ShowS)
-> (Identifier -> String)
-> ([Identifier] -> ShowS)
-> Show Identifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Identifier -> ShowS
showsPrec :: Int -> Identifier -> ShowS
$cshow :: Identifier -> String
show :: Identifier -> String
$cshowList :: [Identifier] -> ShowS
showList :: [Identifier] -> ShowS
Show,
      ReadPrec [Identifier]
ReadPrec Identifier
Int -> ReadS Identifier
ReadS [Identifier]
(Int -> ReadS Identifier)
-> ReadS [Identifier]
-> ReadPrec Identifier
-> ReadPrec [Identifier]
-> Read Identifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Identifier
readsPrec :: Int -> ReadS Identifier
$creadList :: ReadS [Identifier]
readList :: ReadS [Identifier]
$creadPrec :: ReadPrec Identifier
readPrec :: ReadPrec Identifier
$creadListPrec :: ReadPrec [Identifier]
readListPrec :: ReadPrec [Identifier]
Read,
      Eq Identifier
Eq Identifier =>
(Int -> Identifier -> Int)
-> (Identifier -> Int) -> Hashable Identifier
Int -> Identifier -> Int
Identifier -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Identifier -> Int
hashWithSalt :: Int -> Identifier -> Int
$chash :: Identifier -> Int
hash :: Identifier -> Int
Hashable,
      NonEmpty Identifier -> Identifier
Identifier -> Identifier -> Identifier
(Identifier -> Identifier -> Identifier)
-> (NonEmpty Identifier -> Identifier)
-> (forall b. Integral b => b -> Identifier -> Identifier)
-> Semigroup Identifier
forall b. Integral b => b -> Identifier -> Identifier
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: Identifier -> Identifier -> Identifier
<> :: Identifier -> Identifier -> Identifier
$csconcat :: NonEmpty Identifier -> Identifier
sconcat :: NonEmpty Identifier -> Identifier
$cstimes :: forall b. Integral b => b -> Identifier -> Identifier
stimes :: forall b. Integral b => b -> Identifier -> Identifier
Semigroup,
      Semigroup Identifier
Identifier
Semigroup Identifier =>
Identifier
-> (Identifier -> Identifier -> Identifier)
-> ([Identifier] -> Identifier)
-> Monoid Identifier
[Identifier] -> Identifier
Identifier -> Identifier -> Identifier
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: Identifier
mempty :: Identifier
$cmappend :: Identifier -> Identifier -> Identifier
mappend :: Identifier -> Identifier -> Identifier
$cmconcat :: [Identifier] -> Identifier
mconcat :: [Identifier] -> Identifier
Monoid,
      String -> Identifier
(String -> Identifier) -> IsString Identifier
forall a. (String -> a) -> IsString a
$cfromString :: String -> Identifier
fromString :: String -> Identifier
IsString
    )

instance Unpack Identifier where
  unpack :: forall (st :: ZeroBitType) r. Parser st r Identifier
unpack =
    Parser st r Int
forall a (st :: ZeroBitType) r. Integral a => Parser st r a
unpackleb32
      Parser st r Int -> (Int -> Parser st r Int) -> Parser st r Int
forall a b.
ParserT st r ParseError a
-> (a -> ParserT st r ParseError b) -> ParserT st r ParseError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Int -> Parser st r Int
forall a (st :: ZeroBitType) r.
(Num a, Ord a, Show a) =>
String -> a -> Parser st r a
guardnat String
"Identifier.unpack length"
      Parser st r Int
-> (Int -> ParserT st r ParseError Identifier)
-> ParserT st r ParseError Identifier
forall a b.
ParserT st r ParseError a
-> (a -> ParserT st r ParseError b) -> ParserT st r ParseError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int
-> ParserT st r ParseError Identifier
-> ParserT st r ParseError Identifier
forall (st :: ZeroBitType) r e a.
Int -> ParserT st r e a -> ParserT st r e a
`F.isolate` ParserT st r ParseError Identifier
forall (st :: ZeroBitType) r. Parser st r Identifier
unpackid)
  {-# INLINE unpack #-}

instance Pack Identifier where
  pack :: Identifier -> Builder
pack = Text -> Builder
forall a. Pack a => a -> Builder
pack (Text -> Builder) -> (Identifier -> Text) -> Identifier -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Text
identifier
  {-# INLINE pack #-}

unpackid :: Parser st r Identifier
unpackid :: forall (st :: ZeroBitType) r. Parser st r Identifier
unpackid =
  -- ':' may happen at most once
  -- if never occurs, then whole thing is the 'value' part of the ID
  -- if occurs, the earlier part is the namespace, the later part is the value
  -- the namespace may not be empty
  -- the namespace consists of [a-z0-9.-_]
  -- the value consists of [a-z0-9._-/] -- note that '/' is allowed anywhere
  -- the value may not be empty
  let name :: ParserT st r e Char
name = (Char -> Bool) -> ParserT st r e Char
forall (st :: ZeroBitType) r e.
(Char -> Bool) -> ParserT st r e Char
F.satisfyAscii
        \Char
c ->
          Char -> Bool
isAsciiLower Char
c
            Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
c
            Bool -> Bool -> Bool
|| Char
c Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (String
".-_" :: String)
      value :: ParserT st r e Char
value = (Char -> Bool) -> ParserT st r e Char
forall (st :: ZeroBitType) r e.
(Char -> Bool) -> ParserT st r e Char
F.satisfyAscii
        \Char
c ->
          Char -> Bool
isAsciiLower Char
c
            Bool -> Bool -> Bool
|| Char -> Bool
isDigit Char
c
            Bool -> Bool -> Bool
|| Char
c Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (String
"._-/" :: String)
      colon :: ParserT st r e Char
colon = (Char -> Bool) -> ParserT st r e Char
forall (st :: ZeroBitType) r e.
(Char -> Bool) -> ParserT st r e Char
F.satisfyAscii (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':')
      cvt :: String -> Identifier
cvt = Text -> Identifier
Identifier (Text -> Identifier) -> (String -> Text) -> String -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack
      cmb :: (String, Char) -> String -> Identifier
cmb (String
ns, Char
v) String
w = String -> Identifier
cvt (String -> Identifier) -> String -> Identifier
forall a b. (a -> b) -> a -> b
$ [String] -> String
forall a. Monoid a => [a] -> a
mconcat [String
Item [String]
ns, [Char
Item String
v], String
Item [String]
w]
   in (String -> Identifier)
-> ParserT st r ParseError String
-> ParserT st r ParseError Identifier
forall a b.
(a -> b) -> ParserT st r ParseError a -> ParserT st r ParseError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Identifier
cvt (ParserT st r ParseError Char -> ParserT st r ParseError String
forall a. ParserT st r ParseError a -> ParserT st r ParseError [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some ParserT st r ParseError Char
forall {st :: ZeroBitType} {r} {e}. ParserT st r e Char
value ParserT st r ParseError String
-> ParserT st r ParseError () -> ParserT st r ParseError String
forall a b.
ParserT st r ParseError a
-> ParserT st r ParseError b -> ParserT st r ParseError a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserT st r ParseError ()
forall (st :: ZeroBitType) r e. ParserT st r e ()
F.eof)
        ParserT st r ParseError Identifier
-> ParserT st r ParseError Identifier
-> ParserT st r ParseError Identifier
forall a.
ParserT st r ParseError a
-> ParserT st r ParseError a -> ParserT st r ParseError a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((String, Char) -> String -> Identifier)
-> ParserT st r ParseError (String, Char)
-> ParserT st r ParseError String
-> ParserT st r ParseError Identifier
forall a b c.
(a -> b -> c)
-> ParserT st r ParseError a
-> ParserT st r ParseError b
-> ParserT st r ParseError c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (String, Char) -> String -> Identifier
cmb (ParserT st r ParseError Char
-> ParserT st r ParseError Char
-> ParserT st r ParseError (String, Char)
forall (m :: * -> *) a end.
Alternative m =>
m a -> m end -> m ([a], end)
manyTill_ ParserT st r ParseError Char
forall {st :: ZeroBitType} {r} {e}. ParserT st r e Char
name ParserT st r ParseError Char
forall {st :: ZeroBitType} {r} {e}. ParserT st r e Char
colon) (ParserT st r ParseError Char -> ParserT st r ParseError String
forall a. ParserT st r ParseError a -> ParserT st r ParseError [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
some ParserT st r ParseError Char
forall {st :: ZeroBitType} {r} {e}. ParserT st r e Char
value ParserT st r ParseError String
-> ParserT st r ParseError () -> ParserT st r ParseError String
forall a b.
ParserT st r ParseError a
-> ParserT st r ParseError b -> ParserT st r ParseError a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserT st r ParseError ()
forall (st :: ZeroBitType) r e. ParserT st r e ()
F.eof)
        ParserT st r ParseError Identifier
-> ParserT st r ParseError Identifier
-> ParserT st r ParseError Identifier
forall a.
ParserT st r ParseError a
-> ParserT st r ParseError a -> ParserT st r ParseError a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParseError -> ParserT st r ParseError Identifier
forall e (st :: ZeroBitType) r a. e -> ParserT st r e a
F.err ParseError
"unpack Identifier: invalid or empty identifier"

-- | unresolved value; either an ID or an inline value
newtype IDorX a = IDorX
  { -- | VarInt ID (NOT +1) or inline value
    forall a. IDorX a -> Either Int32 a
idorvalue :: Either Int32 a
  }
  deriving stock ((forall x. IDorX a -> Rep (IDorX a) x)
-> (forall x. Rep (IDorX a) x -> IDorX a) -> Generic (IDorX a)
forall x. Rep (IDorX a) x -> IDorX a
forall x. IDorX a -> Rep (IDorX a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (IDorX a) x -> IDorX a
forall a x. IDorX a -> Rep (IDorX a) x
$cfrom :: forall a x. IDorX a -> Rep (IDorX a) x
from :: forall x. IDorX a -> Rep (IDorX a) x
$cto :: forall a x. Rep (IDorX a) x -> IDorX a
to :: forall x. Rep (IDorX a) x -> IDorX a
Generic, Typeable, Typeable (IDorX a)
Typeable (IDorX a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IDorX a -> c (IDorX a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IDorX a))
-> (IDorX a -> Constr)
-> (IDorX a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IDorX a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IDorX a)))
-> ((forall b. Data b => b -> b) -> IDorX a -> IDorX a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IDorX a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IDorX a -> r)
-> (forall u. (forall d. Data d => d -> u) -> IDorX a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IDorX a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a))
-> Data (IDorX a)
IDorX a -> Constr
IDorX a -> DataType
(forall b. Data b => b -> b) -> IDorX a -> IDorX a
forall a. Data a => Typeable (IDorX a)
forall a. Data a => IDorX a -> Constr
forall a. Data a => IDorX a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> IDorX a -> IDorX a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> IDorX a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> IDorX a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IDorX a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDorX a -> c (IDorX a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IDorX a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IDorX a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IDorX a -> u
forall u. (forall d. Data d => d -> u) -> IDorX a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IDorX a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDorX a -> c (IDorX a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (IDorX a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IDorX a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDorX a -> c (IDorX a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDorX a -> c (IDorX a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IDorX a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IDorX a)
$ctoConstr :: forall a. Data a => IDorX a -> Constr
toConstr :: IDorX a -> Constr
$cdataTypeOf :: forall a. Data a => IDorX a -> DataType
dataTypeOf :: IDorX a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IDorX a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (IDorX a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IDorX a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IDorX a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> IDorX a -> IDorX a
gmapT :: (forall b. Data b => b -> b) -> IDorX a -> IDorX a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IDorX a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> IDorX a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IDorX a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> IDorX a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IDorX a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDorX a -> m (IDorX a)
Data, (forall (m :: * -> *). Quote m => IDorX a -> m Exp)
-> (forall (m :: * -> *). Quote m => IDorX a -> Code m (IDorX a))
-> Lift (IDorX a)
forall a (m :: * -> *). (Lift a, Quote m) => IDorX a -> m Exp
forall a (m :: * -> *).
(Lift a, Quote m) =>
IDorX a -> Code m (IDorX a)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => IDorX a -> m Exp
forall (m :: * -> *). Quote m => IDorX a -> Code m (IDorX a)
$clift :: forall a (m :: * -> *). (Lift a, Quote m) => IDorX a -> m Exp
lift :: forall (m :: * -> *). Quote m => IDorX a -> m Exp
$cliftTyped :: forall a (m :: * -> *).
(Lift a, Quote m) =>
IDorX a -> Code m (IDorX a)
liftTyped :: forall (m :: * -> *). Quote m => IDorX a -> Code m (IDorX a)
Lift)
  deriving newtype (IDorX a -> IDorX a -> Bool
(IDorX a -> IDorX a -> Bool)
-> (IDorX a -> IDorX a -> Bool) -> Eq (IDorX a)
forall a. Eq a => IDorX a -> IDorX a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => IDorX a -> IDorX a -> Bool
== :: IDorX a -> IDorX a -> Bool
$c/= :: forall a. Eq a => IDorX a -> IDorX a -> Bool
/= :: IDorX a -> IDorX a -> Bool
Eq, Eq (IDorX a)
Eq (IDorX a) =>
(IDorX a -> IDorX a -> Ordering)
-> (IDorX a -> IDorX a -> Bool)
-> (IDorX a -> IDorX a -> Bool)
-> (IDorX a -> IDorX a -> Bool)
-> (IDorX a -> IDorX a -> Bool)
-> (IDorX a -> IDorX a -> IDorX a)
-> (IDorX a -> IDorX a -> IDorX a)
-> Ord (IDorX a)
IDorX a -> IDorX a -> Bool
IDorX a -> IDorX a -> Ordering
IDorX a -> IDorX a -> IDorX 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 (IDorX a)
forall a. Ord a => IDorX a -> IDorX a -> Bool
forall a. Ord a => IDorX a -> IDorX a -> Ordering
forall a. Ord a => IDorX a -> IDorX a -> IDorX a
$ccompare :: forall a. Ord a => IDorX a -> IDorX a -> Ordering
compare :: IDorX a -> IDorX a -> Ordering
$c< :: forall a. Ord a => IDorX a -> IDorX a -> Bool
< :: IDorX a -> IDorX a -> Bool
$c<= :: forall a. Ord a => IDorX a -> IDorX a -> Bool
<= :: IDorX a -> IDorX a -> Bool
$c> :: forall a. Ord a => IDorX a -> IDorX a -> Bool
> :: IDorX a -> IDorX a -> Bool
$c>= :: forall a. Ord a => IDorX a -> IDorX a -> Bool
>= :: IDorX a -> IDorX a -> Bool
$cmax :: forall a. Ord a => IDorX a -> IDorX a -> IDorX a
max :: IDorX a -> IDorX a -> IDorX a
$cmin :: forall a. Ord a => IDorX a -> IDorX a -> IDorX a
min :: IDorX a -> IDorX a -> IDorX a
Ord, Int -> IDorX a -> ShowS
[IDorX a] -> ShowS
IDorX a -> String
(Int -> IDorX a -> ShowS)
-> (IDorX a -> String) -> ([IDorX a] -> ShowS) -> Show (IDorX a)
forall a. Show a => Int -> IDorX a -> ShowS
forall a. Show a => [IDorX a] -> ShowS
forall a. Show a => IDorX a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> IDorX a -> ShowS
showsPrec :: Int -> IDorX a -> ShowS
$cshow :: forall a. Show a => IDorX a -> String
show :: IDorX a -> String
$cshowList :: forall a. Show a => [IDorX a] -> ShowS
showList :: [IDorX a] -> ShowS
Show, ReadPrec [IDorX a]
ReadPrec (IDorX a)
Int -> ReadS (IDorX a)
ReadS [IDorX a]
(Int -> ReadS (IDorX a))
-> ReadS [IDorX a]
-> ReadPrec (IDorX a)
-> ReadPrec [IDorX a]
-> Read (IDorX a)
forall a. Read a => ReadPrec [IDorX a]
forall a. Read a => ReadPrec (IDorX a)
forall a. Read a => Int -> ReadS (IDorX a)
forall a. Read a => ReadS [IDorX a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (IDorX a)
readsPrec :: Int -> ReadS (IDorX a)
$creadList :: forall a. Read a => ReadS [IDorX a]
readList :: ReadS [IDorX a]
$creadPrec :: forall a. Read a => ReadPrec (IDorX a)
readPrec :: ReadPrec (IDorX a)
$creadListPrec :: forall a. Read a => ReadPrec [IDorX a]
readListPrec :: ReadPrec [IDorX a]
Read, Eq (IDorX a)
Eq (IDorX a) =>
(Int -> IDorX a -> Int) -> (IDorX a -> Int) -> Hashable (IDorX a)
Int -> IDorX a -> Int
IDorX a -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall a. Hashable a => Eq (IDorX a)
forall a. Hashable a => Int -> IDorX a -> Int
forall a. Hashable a => IDorX a -> Int
$chashWithSalt :: forall a. Hashable a => Int -> IDorX a -> Int
hashWithSalt :: Int -> IDorX a -> Int
$chash :: forall a. Hashable a => IDorX a -> Int
hash :: IDorX a -> Int
Hashable, IDorX a -> ()
(IDorX a -> ()) -> NFData (IDorX a)
forall a. NFData a => IDorX a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => IDorX a -> ()
rnf :: IDorX a -> ()
NFData, (forall a b. (a -> b) -> IDorX a -> IDorX b)
-> (forall a b. a -> IDorX b -> IDorX a) -> Functor IDorX
forall a b. a -> IDorX b -> IDorX a
forall a b. (a -> b) -> IDorX a -> IDorX b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> IDorX a -> IDorX b
fmap :: forall a b. (a -> b) -> IDorX a -> IDorX b
$c<$ :: forall a b. a -> IDorX b -> IDorX a
<$ :: forall a b. a -> IDorX b -> IDorX a
Functor)
  deriving newtype (Functor IDorX
Functor IDorX =>
(forall a. a -> IDorX a)
-> (forall a b. IDorX (a -> b) -> IDorX a -> IDorX b)
-> (forall a b c. (a -> b -> c) -> IDorX a -> IDorX b -> IDorX c)
-> (forall a b. IDorX a -> IDorX b -> IDorX b)
-> (forall a b. IDorX a -> IDorX b -> IDorX a)
-> Applicative IDorX
forall a. a -> IDorX a
forall a b. IDorX a -> IDorX b -> IDorX a
forall a b. IDorX a -> IDorX b -> IDorX b
forall a b. IDorX (a -> b) -> IDorX a -> IDorX b
forall a b c. (a -> b -> c) -> IDorX a -> IDorX b -> IDorX c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> IDorX a
pure :: forall a. a -> IDorX a
$c<*> :: forall a b. IDorX (a -> b) -> IDorX a -> IDorX b
<*> :: forall a b. IDorX (a -> b) -> IDorX a -> IDorX b
$cliftA2 :: forall a b c. (a -> b -> c) -> IDorX a -> IDorX b -> IDorX c
liftA2 :: forall a b c. (a -> b -> c) -> IDorX a -> IDorX b -> IDorX c
$c*> :: forall a b. IDorX a -> IDorX b -> IDorX b
*> :: forall a b. IDorX a -> IDorX b -> IDorX b
$c<* :: forall a b. IDorX a -> IDorX b -> IDorX a
<* :: forall a b. IDorX a -> IDorX b -> IDorX a
Applicative, Applicative IDorX
Applicative IDorX =>
(forall a b. IDorX a -> (a -> IDorX b) -> IDorX b)
-> (forall a b. IDorX a -> IDorX b -> IDorX b)
-> (forall a. a -> IDorX a)
-> Monad IDorX
forall a. a -> IDorX a
forall a b. IDorX a -> IDorX b -> IDorX b
forall a b. IDorX a -> (a -> IDorX b) -> IDorX b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. IDorX a -> (a -> IDorX b) -> IDorX b
>>= :: forall a b. IDorX a -> (a -> IDorX b) -> IDorX b
$c>> :: forall a b. IDorX a -> IDorX b -> IDorX b
>> :: forall a b. IDorX a -> IDorX b -> IDorX b
$creturn :: forall a. a -> IDorX a
return :: forall a. a -> IDorX a
Monad, (forall m. Monoid m => IDorX m -> m)
-> (forall m a. Monoid m => (a -> m) -> IDorX a -> m)
-> (forall m a. Monoid m => (a -> m) -> IDorX a -> m)
-> (forall a b. (a -> b -> b) -> b -> IDorX a -> b)
-> (forall a b. (a -> b -> b) -> b -> IDorX a -> b)
-> (forall b a. (b -> a -> b) -> b -> IDorX a -> b)
-> (forall b a. (b -> a -> b) -> b -> IDorX a -> b)
-> (forall a. (a -> a -> a) -> IDorX a -> a)
-> (forall a. (a -> a -> a) -> IDorX a -> a)
-> (forall a. IDorX a -> [a])
-> (forall a. IDorX a -> Bool)
-> (forall a. IDorX a -> Int)
-> (forall a. Eq a => a -> IDorX a -> Bool)
-> (forall a. Ord a => IDorX a -> a)
-> (forall a. Ord a => IDorX a -> a)
-> (forall a. Num a => IDorX a -> a)
-> (forall a. Num a => IDorX a -> a)
-> Foldable IDorX
forall a. Eq a => a -> IDorX a -> Bool
forall a. Num a => IDorX a -> a
forall a. Ord a => IDorX a -> a
forall m. Monoid m => IDorX m -> m
forall a. IDorX a -> Bool
forall a. IDorX a -> Int
forall a. IDorX a -> [a]
forall a. (a -> a -> a) -> IDorX a -> a
forall m a. Monoid m => (a -> m) -> IDorX a -> m
forall b a. (b -> a -> b) -> b -> IDorX a -> b
forall a b. (a -> b -> b) -> b -> IDorX a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => IDorX m -> m
fold :: forall m. Monoid m => IDorX m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IDorX a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IDorX a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IDorX a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> IDorX a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> IDorX a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IDorX a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IDorX a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IDorX a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IDorX a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IDorX a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IDorX a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> IDorX a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> IDorX a -> a
foldr1 :: forall a. (a -> a -> a) -> IDorX a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IDorX a -> a
foldl1 :: forall a. (a -> a -> a) -> IDorX a -> a
$ctoList :: forall a. IDorX a -> [a]
toList :: forall a. IDorX a -> [a]
$cnull :: forall a. IDorX a -> Bool
null :: forall a. IDorX a -> Bool
$clength :: forall a. IDorX a -> Int
length :: forall a. IDorX a -> Int
$celem :: forall a. Eq a => a -> IDorX a -> Bool
elem :: forall a. Eq a => a -> IDorX a -> Bool
$cmaximum :: forall a. Ord a => IDorX a -> a
maximum :: forall a. Ord a => IDorX a -> a
$cminimum :: forall a. Ord a => IDorX a -> a
minimum :: forall a. Ord a => IDorX a -> a
$csum :: forall a. Num a => IDorX a -> a
sum :: forall a. Num a => IDorX a -> a
$cproduct :: forall a. Num a => IDorX a -> a
product :: forall a. Num a => IDorX a -> a
Foldable, NonEmpty (IDorX a) -> IDorX a
IDorX a -> IDorX a -> IDorX a
(IDorX a -> IDorX a -> IDorX a)
-> (NonEmpty (IDorX a) -> IDorX a)
-> (forall b. Integral b => b -> IDorX a -> IDorX a)
-> Semigroup (IDorX a)
forall b. Integral b => b -> IDorX a -> IDorX a
forall a. NonEmpty (IDorX a) -> IDorX a
forall a. IDorX a -> IDorX a -> IDorX a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> IDorX a -> IDorX a
$c<> :: forall a. IDorX a -> IDorX a -> IDorX a
<> :: IDorX a -> IDorX a -> IDorX a
$csconcat :: forall a. NonEmpty (IDorX a) -> IDorX a
sconcat :: NonEmpty (IDorX a) -> IDorX a
$cstimes :: forall a b. Integral b => b -> IDorX a -> IDorX a
stimes :: forall b. Integral b => b -> IDorX a -> IDorX a
Semigroup)

instance (Pack a) => Pack (IDorX a) where
  pack :: IDorX a -> Builder
pack = \case
    IDorX (Left Int32
regid) -> Int32 -> Builder
forall a. Integral a => a -> Builder
packleb32 (Int32
regid Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
+ Int32
1) -- Registry ID + 1
    IDorX (Right a
val) -> LEB Int32 -> Builder
forall a. Pack a => a -> Builder
pack (LEB Int32
0 :: LEB Int32) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> a -> Builder
forall a. Pack a => a -> Builder
pack a
val -- Inline value

instance (Unpack a) => Unpack (IDorX a) where
  unpack :: forall (st :: ZeroBitType) r. Parser st r (IDorX a)
unpack = do
    Int32
i <- Parser st r Int32
forall a (st :: ZeroBitType) r. Integral a => Parser st r a
unpackleb32 Parser st r Int32
-> (Int32 -> Parser st r Int32) -> Parser st r Int32
forall a b.
ParserT st r ParseError a
-> (a -> ParserT st r ParseError b) -> ParserT st r ParseError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Int32 -> Parser st r Int32
forall a (st :: ZeroBitType) r.
(Num a, Ord a, Show a) =>
String -> a -> Parser st r a
guardnat String
"IDorX.n"
    if Int32
i Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
0
      then Either Int32 a -> IDorX a
forall a. Either Int32 a -> IDorX a
IDorX (Either Int32 a -> IDorX a)
-> (a -> Either Int32 a) -> a -> IDorX a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either Int32 a
forall a b. b -> Either a b
Right (a -> IDorX a)
-> ParserT st r ParseError a -> Parser st r (IDorX a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT st r ParseError a
forall (st :: ZeroBitType) r. Parser st r a
forall a (st :: ZeroBitType) r. Unpack a => Parser st r a
unpack
      else IDorX a -> Parser st r (IDorX a)
forall a. a -> ParserT st r ParseError a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (IDorX a -> Parser st r (IDorX a))
-> IDorX a -> Parser st r (IDorX a)
forall a b. (a -> b) -> a -> b
$ Either Int32 a -> IDorX a
forall a. Either Int32 a -> IDorX a
IDorX (Either Int32 a -> IDorX a) -> Either Int32 a -> IDorX a
forall a b. (a -> b) -> a -> b
$ Int32 -> Either Int32 a
forall a b. a -> Either a b
Left (Int32
i Int32 -> Int32 -> Int32
forall a. Num a => a -> a -> a
- Int32
1)

-- | potentially unresolved ID set; either an identifier for its location or
-- an inline set of IDs
newtype IDSet = IDSet
  { -- | name of ID set or inline set
    IDSet -> Either Text (Vector Int32)
setnameorids :: Either Text (V.Vector Int32)
  }
  deriving stock ((forall x. IDSet -> Rep IDSet x)
-> (forall x. Rep IDSet x -> IDSet) -> Generic IDSet
forall x. Rep IDSet x -> IDSet
forall x. IDSet -> Rep IDSet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IDSet -> Rep IDSet x
from :: forall x. IDSet -> Rep IDSet x
$cto :: forall x. Rep IDSet x -> IDSet
to :: forall x. Rep IDSet x -> IDSet
Generic, Typeable, Typeable IDSet
Typeable IDSet =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IDSet -> c IDSet)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IDSet)
-> (IDSet -> Constr)
-> (IDSet -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IDSet))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDSet))
-> ((forall b. Data b => b -> b) -> IDSet -> IDSet)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r)
-> (forall u. (forall d. Data d => d -> u) -> IDSet -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IDSet -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IDSet -> m IDSet)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IDSet -> m IDSet)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IDSet -> m IDSet)
-> Data IDSet
IDSet -> Constr
IDSet -> DataType
(forall b. Data b => b -> b) -> IDSet -> IDSet
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IDSet -> u
forall u. (forall d. Data d => d -> u) -> IDSet -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IDSet
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDSet -> c IDSet
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IDSet)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDSet)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDSet -> c IDSet
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDSet -> c IDSet
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IDSet
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IDSet
$ctoConstr :: IDSet -> Constr
toConstr :: IDSet -> Constr
$cdataTypeOf :: IDSet -> DataType
dataTypeOf :: IDSet -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IDSet)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IDSet)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDSet)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDSet)
$cgmapT :: (forall b. Data b => b -> b) -> IDSet -> IDSet
gmapT :: (forall b. Data b => b -> b) -> IDSet -> IDSet
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDSet -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IDSet -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IDSet -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IDSet -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IDSet -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDSet -> m IDSet
Data)
  deriving newtype (IDSet -> IDSet -> Bool
(IDSet -> IDSet -> Bool) -> (IDSet -> IDSet -> Bool) -> Eq IDSet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IDSet -> IDSet -> Bool
== :: IDSet -> IDSet -> Bool
$c/= :: IDSet -> IDSet -> Bool
/= :: IDSet -> IDSet -> Bool
Eq, Eq IDSet
Eq IDSet =>
(IDSet -> IDSet -> Ordering)
-> (IDSet -> IDSet -> Bool)
-> (IDSet -> IDSet -> Bool)
-> (IDSet -> IDSet -> Bool)
-> (IDSet -> IDSet -> Bool)
-> (IDSet -> IDSet -> IDSet)
-> (IDSet -> IDSet -> IDSet)
-> Ord IDSet
IDSet -> IDSet -> Bool
IDSet -> IDSet -> Ordering
IDSet -> IDSet -> IDSet
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IDSet -> IDSet -> Ordering
compare :: IDSet -> IDSet -> Ordering
$c< :: IDSet -> IDSet -> Bool
< :: IDSet -> IDSet -> Bool
$c<= :: IDSet -> IDSet -> Bool
<= :: IDSet -> IDSet -> Bool
$c> :: IDSet -> IDSet -> Bool
> :: IDSet -> IDSet -> Bool
$c>= :: IDSet -> IDSet -> Bool
>= :: IDSet -> IDSet -> Bool
$cmax :: IDSet -> IDSet -> IDSet
max :: IDSet -> IDSet -> IDSet
$cmin :: IDSet -> IDSet -> IDSet
min :: IDSet -> IDSet -> IDSet
Ord, Int -> IDSet -> ShowS
[IDSet] -> ShowS
IDSet -> String
(Int -> IDSet -> ShowS)
-> (IDSet -> String) -> ([IDSet] -> ShowS) -> Show IDSet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IDSet -> ShowS
showsPrec :: Int -> IDSet -> ShowS
$cshow :: IDSet -> String
show :: IDSet -> String
$cshowList :: [IDSet] -> ShowS
showList :: [IDSet] -> ShowS
Show, ReadPrec [IDSet]
ReadPrec IDSet
Int -> ReadS IDSet
ReadS [IDSet]
(Int -> ReadS IDSet)
-> ReadS [IDSet]
-> ReadPrec IDSet
-> ReadPrec [IDSet]
-> Read IDSet
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IDSet
readsPrec :: Int -> ReadS IDSet
$creadList :: ReadS [IDSet]
readList :: ReadS [IDSet]
$creadPrec :: ReadPrec IDSet
readPrec :: ReadPrec IDSet
$creadListPrec :: ReadPrec [IDSet]
readListPrec :: ReadPrec [IDSet]
Read, IDSet -> ()
(IDSet -> ()) -> NFData IDSet
forall a. (a -> ()) -> NFData a
$crnf :: IDSet -> ()
rnf :: IDSet -> ()
NFData, NonEmpty IDSet -> IDSet
IDSet -> IDSet -> IDSet
(IDSet -> IDSet -> IDSet)
-> (NonEmpty IDSet -> IDSet)
-> (forall b. Integral b => b -> IDSet -> IDSet)
-> Semigroup IDSet
forall b. Integral b => b -> IDSet -> IDSet
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: IDSet -> IDSet -> IDSet
<> :: IDSet -> IDSet -> IDSet
$csconcat :: NonEmpty IDSet -> IDSet
sconcat :: NonEmpty IDSet -> IDSet
$cstimes :: forall b. Integral b => b -> IDSet -> IDSet
stimes :: forall b. Integral b => b -> IDSet -> IDSet
Semigroup)

instance Pack IDSet where
  pack :: IDSet -> Builder
pack (IDSet (Left Text
setname)) = Builder
"\0" Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Text -> Builder
forall a. Pack a => a -> Builder
pack Text
setname
  pack (IDSet (Right Vector Int32
ids)) = Int -> Builder
forall a. Integral a => a -> Builder
packleb32 (Vector Int32 -> Int
forall a. Vector a -> Int
V.length Vector Int32
ids Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Int32 -> Builder) -> Vector Int32 -> Builder
forall m a. Monoid m => (a -> m) -> Vector a -> m
V.foldMap' Int32 -> Builder
forall a. Pack a => a -> Builder
pack Vector Int32
ids

instance Unpack IDSet where
  unpack :: forall (st :: ZeroBitType) r. Parser st r IDSet
unpack =
    Parser st r Int
forall a (st :: ZeroBitType) r. Integral a => Parser st r a
unpackleb32 Parser st r Int -> (Int -> Parser st r Int) -> Parser st r Int
forall a b.
ParserT st r ParseError a
-> (a -> ParserT st r ParseError b) -> ParserT st r ParseError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Int -> Parser st r Int
forall a (st :: ZeroBitType) r.
(Num a, Ord a, Show a) =>
String -> a -> Parser st r a
guardnat String
"IDSet.n" Parser st r Int
-> (Int -> ParserT st r ParseError IDSet)
-> ParserT st r ParseError IDSet
forall a b.
ParserT st r ParseError a
-> (a -> ParserT st r ParseError b) -> ParserT st r ParseError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Int
0 -> Either Text (Vector Int32) -> IDSet
IDSet (Either Text (Vector Int32) -> IDSet)
-> (Identifier -> Either Text (Vector Int32))
-> Identifier
-> IDSet
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either Text (Vector Int32)
forall a b. a -> Either a b
Left (Text -> Either Text (Vector Int32))
-> (Identifier -> Text) -> Identifier -> Either Text (Vector Int32)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Text
identifier (Identifier -> IDSet)
-> ParserT st r ParseError Identifier
-> ParserT st r ParseError IDSet
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT st r ParseError Identifier
forall (st :: ZeroBitType) r. Parser st r Identifier
forall a (st :: ZeroBitType) r. Unpack a => Parser st r a
unpack
      Int
n -> Either Text (Vector Int32) -> IDSet
IDSet (Either Text (Vector Int32) -> IDSet)
-> (Vector Int32 -> Either Text (Vector Int32))
-> Vector Int32
-> IDSet
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector Int32 -> Either Text (Vector Int32)
forall a b. b -> Either a b
Right (Vector Int32 -> IDSet)
-> ParserT st r ParseError (Vector Int32)
-> ParserT st r ParseError IDSet
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int
-> ParserT st r ParseError Int32
-> ParserT st r ParseError (Vector Int32)
forall (m :: * -> *) a. Monad m => Int -> m a -> m (Vector a)
V.replicateM (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) ParserT st r ParseError Int32
forall a (st :: ZeroBitType) r. Integral a => Parser st r a
unpackleb32

-- | a newtype wrapper over 'ByteString'; not length-prefixed
newtype TakeRest = TakeRest {TakeRest -> ByteString
gettakerest :: ByteString}
  deriving stock ((forall x. TakeRest -> Rep TakeRest x)
-> (forall x. Rep TakeRest x -> TakeRest) -> Generic TakeRest
forall x. Rep TakeRest x -> TakeRest
forall x. TakeRest -> Rep TakeRest x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TakeRest -> Rep TakeRest x
from :: forall x. TakeRest -> Rep TakeRest x
$cto :: forall x. Rep TakeRest x -> TakeRest
to :: forall x. Rep TakeRest x -> TakeRest
Generic, Typeable, Typeable TakeRest
Typeable TakeRest =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TakeRest -> c TakeRest)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TakeRest)
-> (TakeRest -> Constr)
-> (TakeRest -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TakeRest))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TakeRest))
-> ((forall b. Data b => b -> b) -> TakeRest -> TakeRest)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TakeRest -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TakeRest -> r)
-> (forall u. (forall d. Data d => d -> u) -> TakeRest -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TakeRest -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TakeRest -> m TakeRest)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TakeRest -> m TakeRest)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TakeRest -> m TakeRest)
-> Data TakeRest
TakeRest -> Constr
TakeRest -> DataType
(forall b. Data b => b -> b) -> TakeRest -> TakeRest
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TakeRest -> u
forall u. (forall d. Data d => d -> u) -> TakeRest -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TakeRest -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TakeRest -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TakeRest
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TakeRest -> c TakeRest
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TakeRest)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TakeRest)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TakeRest -> c TakeRest
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TakeRest -> c TakeRest
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TakeRest
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TakeRest
$ctoConstr :: TakeRest -> Constr
toConstr :: TakeRest -> Constr
$cdataTypeOf :: TakeRest -> DataType
dataTypeOf :: TakeRest -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TakeRest)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TakeRest)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TakeRest)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TakeRest)
$cgmapT :: (forall b. Data b => b -> b) -> TakeRest -> TakeRest
gmapT :: (forall b. Data b => b -> b) -> TakeRest -> TakeRest
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TakeRest -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TakeRest -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TakeRest -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TakeRest -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TakeRest -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TakeRest -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TakeRest -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TakeRest -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TakeRest -> m TakeRest
Data, (forall (m :: * -> *). Quote m => TakeRest -> m Exp)
-> (forall (m :: * -> *). Quote m => TakeRest -> Code m TakeRest)
-> Lift TakeRest
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => TakeRest -> m Exp
forall (m :: * -> *). Quote m => TakeRest -> Code m TakeRest
$clift :: forall (m :: * -> *). Quote m => TakeRest -> m Exp
lift :: forall (m :: * -> *). Quote m => TakeRest -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => TakeRest -> Code m TakeRest
liftTyped :: forall (m :: * -> *). Quote m => TakeRest -> Code m TakeRest
Lift)
  deriving newtype (Int -> TakeRest -> ShowS
[TakeRest] -> ShowS
TakeRest -> String
(Int -> TakeRest -> ShowS)
-> (TakeRest -> String) -> ([TakeRest] -> ShowS) -> Show TakeRest
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TakeRest -> ShowS
showsPrec :: Int -> TakeRest -> ShowS
$cshow :: TakeRest -> String
show :: TakeRest -> String
$cshowList :: [TakeRest] -> ShowS
showList :: [TakeRest] -> ShowS
Show, ReadPrec [TakeRest]
ReadPrec TakeRest
Int -> ReadS TakeRest
ReadS [TakeRest]
(Int -> ReadS TakeRest)
-> ReadS [TakeRest]
-> ReadPrec TakeRest
-> ReadPrec [TakeRest]
-> Read TakeRest
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TakeRest
readsPrec :: Int -> ReadS TakeRest
$creadList :: ReadS [TakeRest]
readList :: ReadS [TakeRest]
$creadPrec :: ReadPrec TakeRest
readPrec :: ReadPrec TakeRest
$creadListPrec :: ReadPrec [TakeRest]
readListPrec :: ReadPrec [TakeRest]
Read, TakeRest -> TakeRest -> Bool
(TakeRest -> TakeRest -> Bool)
-> (TakeRest -> TakeRest -> Bool) -> Eq TakeRest
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TakeRest -> TakeRest -> Bool
== :: TakeRest -> TakeRest -> Bool
$c/= :: TakeRest -> TakeRest -> Bool
/= :: TakeRest -> TakeRest -> Bool
Eq, Eq TakeRest
Eq TakeRest =>
(TakeRest -> TakeRest -> Ordering)
-> (TakeRest -> TakeRest -> Bool)
-> (TakeRest -> TakeRest -> Bool)
-> (TakeRest -> TakeRest -> Bool)
-> (TakeRest -> TakeRest -> Bool)
-> (TakeRest -> TakeRest -> TakeRest)
-> (TakeRest -> TakeRest -> TakeRest)
-> Ord TakeRest
TakeRest -> TakeRest -> Bool
TakeRest -> TakeRest -> Ordering
TakeRest -> TakeRest -> TakeRest
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TakeRest -> TakeRest -> Ordering
compare :: TakeRest -> TakeRest -> Ordering
$c< :: TakeRest -> TakeRest -> Bool
< :: TakeRest -> TakeRest -> Bool
$c<= :: TakeRest -> TakeRest -> Bool
<= :: TakeRest -> TakeRest -> Bool
$c> :: TakeRest -> TakeRest -> Bool
> :: TakeRest -> TakeRest -> Bool
$c>= :: TakeRest -> TakeRest -> Bool
>= :: TakeRest -> TakeRest -> Bool
$cmax :: TakeRest -> TakeRest -> TakeRest
max :: TakeRest -> TakeRest -> TakeRest
$cmin :: TakeRest -> TakeRest -> TakeRest
min :: TakeRest -> TakeRest -> TakeRest
Ord, Eq TakeRest
Eq TakeRest =>
(Int -> TakeRest -> Int) -> (TakeRest -> Int) -> Hashable TakeRest
Int -> TakeRest -> Int
TakeRest -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> TakeRest -> Int
hashWithSalt :: Int -> TakeRest -> Int
$chash :: TakeRest -> Int
hash :: TakeRest -> Int
Hashable, TakeRest -> ()
(TakeRest -> ()) -> NFData TakeRest
forall a. (a -> ()) -> NFData a
$crnf :: TakeRest -> ()
rnf :: TakeRest -> ()
NFData, NonEmpty TakeRest -> TakeRest
TakeRest -> TakeRest -> TakeRest
(TakeRest -> TakeRest -> TakeRest)
-> (NonEmpty TakeRest -> TakeRest)
-> (forall b. Integral b => b -> TakeRest -> TakeRest)
-> Semigroup TakeRest
forall b. Integral b => b -> TakeRest -> TakeRest
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: TakeRest -> TakeRest -> TakeRest
<> :: TakeRest -> TakeRest -> TakeRest
$csconcat :: NonEmpty TakeRest -> TakeRest
sconcat :: NonEmpty TakeRest -> TakeRest
$cstimes :: forall b. Integral b => b -> TakeRest -> TakeRest
stimes :: forall b. Integral b => b -> TakeRest -> TakeRest
Semigroup, Semigroup TakeRest
TakeRest
Semigroup TakeRest =>
TakeRest
-> (TakeRest -> TakeRest -> TakeRest)
-> ([TakeRest] -> TakeRest)
-> Monoid TakeRest
[TakeRest] -> TakeRest
TakeRest -> TakeRest -> TakeRest
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: TakeRest
mempty :: TakeRest
$cmappend :: TakeRest -> TakeRest -> TakeRest
mappend :: TakeRest -> TakeRest -> TakeRest
$cmconcat :: [TakeRest] -> TakeRest
mconcat :: [TakeRest] -> TakeRest
Monoid)

-- | 'TakeRest' is serialized as-is
instance Pack TakeRest where
  pack :: TakeRest -> Builder
pack = ByteString -> Builder
BB.byteString (ByteString -> Builder)
-> (TakeRest -> ByteString) -> TakeRest -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TakeRest -> ByteString
gettakerest
  {-# INLINE pack #-}

-- | 'TakeRest' is deserialized as-is and reads the rest of the input
instance Unpack TakeRest where
  unpack :: forall (st :: ZeroBitType) r. Parser st r TakeRest
unpack = ByteString -> TakeRest
TakeRest (ByteString -> TakeRest)
-> ParserT st r ParseError ByteString
-> ParserT st r ParseError TakeRest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT st r ParseError ByteString
forall (st :: ZeroBitType) r e. ParserT st r e ByteString
F.takeRest
  {-# INLINE unpack #-}

-- | General 'Pack' instance provider for 'Foldable's
--
-- length-prefixed ('VarInt'), strict left fold
newtype PackFoldableVI f a = PackFoldableVI {forall {k} (f :: k -> *) (a :: k). PackFoldableVI f a -> f a
getpackfoldablevi :: f a}
  deriving stock ((forall x. PackFoldableVI f a -> Rep (PackFoldableVI f a) x)
-> (forall x. Rep (PackFoldableVI f a) x -> PackFoldableVI f a)
-> Generic (PackFoldableVI f a)
forall x. Rep (PackFoldableVI f a) x -> PackFoldableVI f a
forall x. PackFoldableVI f a -> Rep (PackFoldableVI f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (f :: k -> *) (a :: k) x.
Rep (PackFoldableVI f a) x -> PackFoldableVI f a
forall k (f :: k -> *) (a :: k) x.
PackFoldableVI f a -> Rep (PackFoldableVI f a) x
$cfrom :: forall k (f :: k -> *) (a :: k) x.
PackFoldableVI f a -> Rep (PackFoldableVI f a) x
from :: forall x. PackFoldableVI f a -> Rep (PackFoldableVI f a) x
$cto :: forall k (f :: k -> *) (a :: k) x.
Rep (PackFoldableVI f a) x -> PackFoldableVI f a
to :: forall x. Rep (PackFoldableVI f a) x -> PackFoldableVI f a
Generic, (forall (a :: k). PackFoldableVI f a -> Rep1 (PackFoldableVI f) a)
-> (forall (a :: k).
    Rep1 (PackFoldableVI f) a -> PackFoldableVI f a)
-> Generic1 (PackFoldableVI f)
forall (a :: k). Rep1 (PackFoldableVI f) a -> PackFoldableVI f a
forall (a :: k). PackFoldableVI f a -> Rep1 (PackFoldableVI f) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
forall k (f :: k -> *) (a :: k).
Rep1 (PackFoldableVI f) a -> PackFoldableVI f a
forall k (f :: k -> *) (a :: k).
PackFoldableVI f a -> Rep1 (PackFoldableVI f) a
$cfrom1 :: forall k (f :: k -> *) (a :: k).
PackFoldableVI f a -> Rep1 (PackFoldableVI f) a
from1 :: forall (a :: k). PackFoldableVI f a -> Rep1 (PackFoldableVI f) a
$cto1 :: forall k (f :: k -> *) (a :: k).
Rep1 (PackFoldableVI f) a -> PackFoldableVI f a
to1 :: forall (a :: k). Rep1 (PackFoldableVI f) a -> PackFoldableVI f a
Generic1, Typeable, Typeable (PackFoldableVI f a)
Typeable (PackFoldableVI f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> PackFoldableVI f a
 -> c (PackFoldableVI f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PackFoldableVI f a))
-> (PackFoldableVI f a -> Constr)
-> (PackFoldableVI f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PackFoldableVI f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PackFoldableVI f a)))
-> ((forall b. Data b => b -> b)
    -> PackFoldableVI f a -> PackFoldableVI f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PackFoldableVI f a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PackFoldableVI f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PackFoldableVI f a -> m (PackFoldableVI f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackFoldableVI f a -> m (PackFoldableVI f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackFoldableVI f a -> m (PackFoldableVI f a))
-> Data (PackFoldableVI f a)
PackFoldableVI f a -> Constr
PackFoldableVI f a -> DataType
(forall b. Data b => b -> b)
-> PackFoldableVI f a -> PackFoldableVI f a
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PackFoldableVI f a -> u
forall u. (forall d. Data d => d -> u) -> PackFoldableVI f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldableVI f a -> Constr
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldableVI f a -> DataType
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b)
-> PackFoldableVI f a -> PackFoldableVI f a
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> PackFoldableVI f a -> u
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> PackFoldableVI f a -> [u]
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldableVI f a
-> c (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldableVI f a))
forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldableVI f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldableVI f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldableVI f a
-> c (PackFoldableVI f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldableVI f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldableVI f a))
$cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldableVI f a
-> c (PackFoldableVI f a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldableVI f a
-> c (PackFoldableVI f a)
$cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldableVI f a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldableVI f a)
$ctoConstr :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldableVI f a -> Constr
toConstr :: PackFoldableVI f a -> Constr
$cdataTypeOf :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldableVI f a -> DataType
dataTypeOf :: PackFoldableVI f a -> DataType
$cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldableVI f a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldableVI f a))
$cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldableVI f a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldableVI f a))
$cgmapT :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b)
-> PackFoldableVI f a -> PackFoldableVI f a
gmapT :: (forall b. Data b => b -> b)
-> PackFoldableVI f a -> PackFoldableVI f a
$cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
$cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldableVI f a -> r
$cgmapQ :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> PackFoldableVI f a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PackFoldableVI f a -> [u]
$cgmapQi :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> PackFoldableVI f a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PackFoldableVI f a -> u
$cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
$cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
$cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackFoldableVI f a -> m (PackFoldableVI f a)
Data, (forall (m :: * -> *). Quote m => PackFoldableVI f a -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    PackFoldableVI f a -> Code m (PackFoldableVI f a))
-> Lift (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldableVI f a -> m Exp
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldableVI f a -> Code m (PackFoldableVI f a)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PackFoldableVI f a -> m Exp
forall (m :: * -> *).
Quote m =>
PackFoldableVI f a -> Code m (PackFoldableVI f a)
$clift :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldableVI f a -> m Exp
lift :: forall (m :: * -> *). Quote m => PackFoldableVI f a -> m Exp
$cliftTyped :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldableVI f a -> Code m (PackFoldableVI f a)
liftTyped :: forall (m :: * -> *).
Quote m =>
PackFoldableVI f a -> Code m (PackFoldableVI f a)
Lift)
  deriving newtype (PackFoldableVI f a -> PackFoldableVI f a -> Bool
(PackFoldableVI f a -> PackFoldableVI f a -> Bool)
-> (PackFoldableVI f a -> PackFoldableVI f a -> Bool)
-> Eq (PackFoldableVI f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (f :: k -> *) (a :: k).
Eq (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
$c== :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
== :: PackFoldableVI f a -> PackFoldableVI f a -> Bool
$c/= :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
/= :: PackFoldableVI f a -> PackFoldableVI f a -> Bool
Eq, Eq (PackFoldableVI f a)
Eq (PackFoldableVI f a) =>
(PackFoldableVI f a -> PackFoldableVI f a -> Ordering)
-> (PackFoldableVI f a -> PackFoldableVI f a -> Bool)
-> (PackFoldableVI f a -> PackFoldableVI f a -> Bool)
-> (PackFoldableVI f a -> PackFoldableVI f a -> Bool)
-> (PackFoldableVI f a -> PackFoldableVI f a -> Bool)
-> (PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a)
-> (PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a)
-> Ord (PackFoldableVI f a)
PackFoldableVI f a -> PackFoldableVI f a -> Bool
PackFoldableVI f a -> PackFoldableVI f a -> Ordering
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f 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 k (f :: k -> *) (a :: k).
Ord (f a) =>
Eq (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Ordering
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
$ccompare :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Ordering
compare :: PackFoldableVI f a -> PackFoldableVI f a -> Ordering
$c< :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
< :: PackFoldableVI f a -> PackFoldableVI f a -> Bool
$c<= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
<= :: PackFoldableVI f a -> PackFoldableVI f a -> Bool
$c> :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
> :: PackFoldableVI f a -> PackFoldableVI f a -> Bool
$c>= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> Bool
>= :: PackFoldableVI f a -> PackFoldableVI f a -> Bool
$cmax :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
max :: PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
$cmin :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
min :: PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
Ord, Int -> PackFoldableVI f a -> ShowS
[PackFoldableVI f a] -> ShowS
PackFoldableVI f a -> String
(Int -> PackFoldableVI f a -> ShowS)
-> (PackFoldableVI f a -> String)
-> ([PackFoldableVI f a] -> ShowS)
-> Show (PackFoldableVI f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> PackFoldableVI f a -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
[PackFoldableVI f a] -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
PackFoldableVI f a -> String
$cshowsPrec :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> PackFoldableVI f a -> ShowS
showsPrec :: Int -> PackFoldableVI f a -> ShowS
$cshow :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
PackFoldableVI f a -> String
show :: PackFoldableVI f a -> String
$cshowList :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
[PackFoldableVI f a] -> ShowS
showList :: [PackFoldableVI f a] -> ShowS
Show, ReadPrec [PackFoldableVI f a]
ReadPrec (PackFoldableVI f a)
Int -> ReadS (PackFoldableVI f a)
ReadS [PackFoldableVI f a]
(Int -> ReadS (PackFoldableVI f a))
-> ReadS [PackFoldableVI f a]
-> ReadPrec (PackFoldableVI f a)
-> ReadPrec [PackFoldableVI f a]
-> Read (PackFoldableVI f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [PackFoldableVI f a]
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [PackFoldableVI f a]
$creadsPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (PackFoldableVI f a)
readsPrec :: Int -> ReadS (PackFoldableVI f a)
$creadList :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [PackFoldableVI f a]
readList :: ReadS [PackFoldableVI f a]
$creadPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (PackFoldableVI f a)
readPrec :: ReadPrec (PackFoldableVI f a)
$creadListPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [PackFoldableVI f a]
readListPrec :: ReadPrec [PackFoldableVI f a]
Read, Eq (PackFoldableVI f a)
Eq (PackFoldableVI f a) =>
(Int -> PackFoldableVI f a -> Int)
-> (PackFoldableVI f a -> Int) -> Hashable (PackFoldableVI f a)
Int -> PackFoldableVI f a -> Int
PackFoldableVI f a -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Eq (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Int -> PackFoldableVI f a -> Int
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
PackFoldableVI f a -> Int
$chashWithSalt :: forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Int -> PackFoldableVI f a -> Int
hashWithSalt :: Int -> PackFoldableVI f a -> Int
$chash :: forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
PackFoldableVI f a -> Int
hash :: PackFoldableVI f a -> Int
Hashable, PackFoldableVI f a -> ()
(PackFoldableVI f a -> ()) -> NFData (PackFoldableVI f a)
forall a. (a -> ()) -> NFData a
forall k (f :: k -> *) (a :: k).
NFData (f a) =>
PackFoldableVI f a -> ()
$crnf :: forall k (f :: k -> *) (a :: k).
NFData (f a) =>
PackFoldableVI f a -> ()
rnf :: PackFoldableVI f a -> ()
NFData, (forall a b. (a -> b) -> PackFoldableVI f a -> PackFoldableVI f b)
-> (forall a b. a -> PackFoldableVI f b -> PackFoldableVI f a)
-> Functor (PackFoldableVI f)
forall a b. a -> PackFoldableVI f b -> PackFoldableVI f a
forall a b. (a -> b) -> PackFoldableVI f a -> PackFoldableVI f b
forall (f :: * -> *) a b.
Functor f =>
a -> PackFoldableVI f b -> PackFoldableVI f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> PackFoldableVI f a -> PackFoldableVI f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> PackFoldableVI f a -> PackFoldableVI f b
fmap :: forall a b. (a -> b) -> PackFoldableVI f a -> PackFoldableVI f b
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> PackFoldableVI f b -> PackFoldableVI f a
<$ :: forall a b. a -> PackFoldableVI f b -> PackFoldableVI f a
Functor)
  deriving newtype ((forall a. Eq a => Eq (PackFoldableVI f a)) =>
(forall a b.
 (a -> b -> Bool)
 -> PackFoldableVI f a -> PackFoldableVI f b -> Bool)
-> Eq1 (PackFoldableVI f)
forall a. Eq a => Eq (PackFoldableVI f a)
forall a b.
(a -> b -> Bool)
-> PackFoldableVI f a -> PackFoldableVI f b -> Bool
forall (f :: * -> *) a. (Eq1 f, Eq a) => Eq (PackFoldableVI f a)
forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool)
-> PackFoldableVI f a -> PackFoldableVI f b -> Bool
forall (f :: * -> *).
(forall a. Eq a => Eq (f a)) =>
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
$cliftEq :: forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool)
-> PackFoldableVI f a -> PackFoldableVI f b -> Bool
liftEq :: forall a b.
(a -> b -> Bool)
-> PackFoldableVI f a -> PackFoldableVI f b -> Bool
Eq1, Eq1 (PackFoldableVI f)
(Eq1 (PackFoldableVI f),
 forall a. Ord a => Ord (PackFoldableVI f a)) =>
(forall a b.
 (a -> b -> Ordering)
 -> PackFoldableVI f a -> PackFoldableVI f b -> Ordering)
-> Ord1 (PackFoldableVI f)
forall a. Ord a => Ord (PackFoldableVI f a)
forall a b.
(a -> b -> Ordering)
-> PackFoldableVI f a -> PackFoldableVI f b -> Ordering
forall (f :: * -> *). Ord1 f => Eq1 (PackFoldableVI f)
forall (f :: * -> *) a. (Ord1 f, Ord a) => Ord (PackFoldableVI f a)
forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering)
-> PackFoldableVI f a -> PackFoldableVI f b -> Ordering
forall (f :: * -> *).
(Eq1 f, forall a. Ord a => Ord (f a)) =>
(forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
$cliftCompare :: forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering)
-> PackFoldableVI f a -> PackFoldableVI f b -> Ordering
liftCompare :: forall a b.
(a -> b -> Ordering)
-> PackFoldableVI f a -> PackFoldableVI f b -> Ordering
Ord1, (forall a. Show a => Show (PackFoldableVI f a)) =>
(forall a.
 (Int -> a -> ShowS)
 -> ([a] -> ShowS) -> Int -> PackFoldableVI f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [PackFoldableVI f a] -> ShowS)
-> Show1 (PackFoldableVI f)
forall a. Show a => Show (PackFoldableVI f a)
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldableVI f a -> ShowS
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldableVI f a] -> ShowS
forall (f :: * -> *) a.
(Show1 f, Show a) =>
Show (PackFoldableVI f a)
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldableVI f a -> ShowS
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldableVI f a] -> ShowS
forall (f :: * -> *).
(forall a. Show a => Show (f a)) =>
(forall a.
 (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS)
-> Show1 f
$cliftShowsPrec :: forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldableVI f a -> ShowS
liftShowsPrec :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldableVI f a -> ShowS
$cliftShowList :: forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldableVI f a] -> ShowS
liftShowList :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldableVI f a] -> ShowS
Show1, (forall a. Read a => Read (PackFoldableVI f a)) =>
(forall a.
 (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldableVI f a))
-> (forall a.
    (Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldableVI f a])
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldableVI f a))
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldableVI f a])
-> Read1 (PackFoldableVI f)
forall a. Read a => Read (PackFoldableVI f a)
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldableVI f a]
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldableVI f a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldableVI f a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldableVI f a]
forall (f :: * -> *) a.
(Read1 f, Read a) =>
Read (PackFoldableVI f a)
forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldableVI f a]
forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldableVI f a)
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldableVI f a)
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldableVI f a]
forall (f :: * -> *).
(forall a. Read a => Read (f a)) =>
(forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a))
-> (forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [f a])
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (f a))
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [f a])
-> Read1 f
$cliftReadsPrec :: forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldableVI f a)
liftReadsPrec :: forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldableVI f a)
$cliftReadList :: forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldableVI f a]
liftReadList :: forall a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldableVI f a]
$cliftReadPrec :: forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldableVI f a)
liftReadPrec :: forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldableVI f a)
$cliftReadListPrec :: forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldableVI f a]
liftReadListPrec :: forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldableVI f a]
Read1, NonEmpty (PackFoldableVI f a) -> PackFoldableVI f a
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
(PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a)
-> (NonEmpty (PackFoldableVI f a) -> PackFoldableVI f a)
-> (forall b.
    Integral b =>
    b -> PackFoldableVI f a -> PackFoldableVI f a)
-> Semigroup (PackFoldableVI f a)
forall b.
Integral b =>
b -> PackFoldableVI f a -> PackFoldableVI f a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
NonEmpty (PackFoldableVI f a) -> PackFoldableVI f a
forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
forall k (f :: k -> *) (a :: k) b.
(Semigroup (f a), Integral b) =>
b -> PackFoldableVI f a -> PackFoldableVI f a
$c<> :: forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
<> :: PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
$csconcat :: forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
NonEmpty (PackFoldableVI f a) -> PackFoldableVI f a
sconcat :: NonEmpty (PackFoldableVI f a) -> PackFoldableVI f a
$cstimes :: forall k (f :: k -> *) (a :: k) b.
(Semigroup (f a), Integral b) =>
b -> PackFoldableVI f a -> PackFoldableVI f a
stimes :: forall b.
Integral b =>
b -> PackFoldableVI f a -> PackFoldableVI f a
Semigroup, Semigroup (PackFoldableVI f a)
PackFoldableVI f a
Semigroup (PackFoldableVI f a) =>
PackFoldableVI f a
-> (PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a)
-> ([PackFoldableVI f a] -> PackFoldableVI f a)
-> Monoid (PackFoldableVI f a)
[PackFoldableVI f a] -> PackFoldableVI f a
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
Semigroup (PackFoldableVI f a)
forall k (f :: k -> *) (a :: k). Monoid (f a) => PackFoldableVI f a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
[PackFoldableVI f a] -> PackFoldableVI f a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
$cmempty :: forall k (f :: k -> *) (a :: k). Monoid (f a) => PackFoldableVI f a
mempty :: PackFoldableVI f a
$cmappend :: forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
mappend :: PackFoldableVI f a -> PackFoldableVI f a -> PackFoldableVI f a
$cmconcat :: forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
[PackFoldableVI f a] -> PackFoldableVI f a
mconcat :: [PackFoldableVI f a] -> PackFoldableVI f a
Monoid)
  deriving newtype ((forall m. Monoid m => PackFoldableVI f m -> m)
-> (forall m a. Monoid m => (a -> m) -> PackFoldableVI f a -> m)
-> (forall m a. Monoid m => (a -> m) -> PackFoldableVI f a -> m)
-> (forall a b. (a -> b -> b) -> b -> PackFoldableVI f a -> b)
-> (forall a b. (a -> b -> b) -> b -> PackFoldableVI f a -> b)
-> (forall b a. (b -> a -> b) -> b -> PackFoldableVI f a -> b)
-> (forall b a. (b -> a -> b) -> b -> PackFoldableVI f a -> b)
-> (forall a. (a -> a -> a) -> PackFoldableVI f a -> a)
-> (forall a. (a -> a -> a) -> PackFoldableVI f a -> a)
-> (forall a. PackFoldableVI f a -> [a])
-> (forall a. PackFoldableVI f a -> Bool)
-> (forall a. PackFoldableVI f a -> Int)
-> (forall a. Eq a => a -> PackFoldableVI f a -> Bool)
-> (forall a. Ord a => PackFoldableVI f a -> a)
-> (forall a. Ord a => PackFoldableVI f a -> a)
-> (forall a. Num a => PackFoldableVI f a -> a)
-> (forall a. Num a => PackFoldableVI f a -> a)
-> Foldable (PackFoldableVI f)
forall a. Eq a => a -> PackFoldableVI f a -> Bool
forall a. Num a => PackFoldableVI f a -> a
forall a. Ord a => PackFoldableVI f a -> a
forall m. Monoid m => PackFoldableVI f m -> m
forall a. PackFoldableVI f a -> Bool
forall a. PackFoldableVI f a -> Int
forall a. PackFoldableVI f a -> [a]
forall a. (a -> a -> a) -> PackFoldableVI f a -> a
forall m a. Monoid m => (a -> m) -> PackFoldableVI f a -> m
forall b a. (b -> a -> b) -> b -> PackFoldableVI f a -> b
forall a b. (a -> b -> b) -> b -> PackFoldableVI f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> PackFoldableVI f a -> Bool
forall (f :: * -> *) a.
(Foldable f, Num a) =>
PackFoldableVI f a -> a
forall (f :: * -> *) a.
(Foldable f, Ord a) =>
PackFoldableVI f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
PackFoldableVI f m -> m
forall (f :: * -> *) a. Foldable f => PackFoldableVI f a -> Bool
forall (f :: * -> *) a. Foldable f => PackFoldableVI f a -> Int
forall (f :: * -> *) a. Foldable f => PackFoldableVI f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> PackFoldableVI f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> PackFoldableVI f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> PackFoldableVI f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> PackFoldableVI f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
PackFoldableVI f m -> m
fold :: forall m. Monoid m => PackFoldableVI f m -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> PackFoldableVI f a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PackFoldableVI f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> PackFoldableVI f a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PackFoldableVI f a -> m
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> PackFoldableVI f a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PackFoldableVI f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> PackFoldableVI f a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PackFoldableVI f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> PackFoldableVI f a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PackFoldableVI f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> PackFoldableVI f a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PackFoldableVI f a -> b
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> PackFoldableVI f a -> a
foldr1 :: forall a. (a -> a -> a) -> PackFoldableVI f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> PackFoldableVI f a -> a
foldl1 :: forall a. (a -> a -> a) -> PackFoldableVI f a -> a
$ctoList :: forall (f :: * -> *) a. Foldable f => PackFoldableVI f a -> [a]
toList :: forall a. PackFoldableVI f a -> [a]
$cnull :: forall (f :: * -> *) a. Foldable f => PackFoldableVI f a -> Bool
null :: forall a. PackFoldableVI f a -> Bool
$clength :: forall (f :: * -> *) a. Foldable f => PackFoldableVI f a -> Int
length :: forall a. PackFoldableVI f a -> Int
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> PackFoldableVI f a -> Bool
elem :: forall a. Eq a => a -> PackFoldableVI f a -> Bool
$cmaximum :: forall (f :: * -> *) a.
(Foldable f, Ord a) =>
PackFoldableVI f a -> a
maximum :: forall a. Ord a => PackFoldableVI f a -> a
$cminimum :: forall (f :: * -> *) a.
(Foldable f, Ord a) =>
PackFoldableVI f a -> a
minimum :: forall a. Ord a => PackFoldableVI f a -> a
$csum :: forall (f :: * -> *) a.
(Foldable f, Num a) =>
PackFoldableVI f a -> a
sum :: forall a. Num a => PackFoldableVI f a -> a
$cproduct :: forall (f :: * -> *) a.
(Foldable f, Num a) =>
PackFoldableVI f a -> a
product :: forall a. Num a => PackFoldableVI f a -> a
Foldable, Foldable (PackFoldableVI f)
Foldable (PackFoldableVI f) =>
(forall m. Semigroup m => PackFoldableVI f m -> m)
-> (forall m a. Semigroup m => (a -> m) -> PackFoldableVI f a -> m)
-> (forall m a. Semigroup m => (a -> m) -> PackFoldableVI f a -> m)
-> (forall a. PackFoldableVI f a -> NonEmpty a)
-> (forall a. Ord a => PackFoldableVI f a -> a)
-> (forall a. Ord a => PackFoldableVI f a -> a)
-> (forall a. PackFoldableVI f a -> a)
-> (forall a. PackFoldableVI f a -> a)
-> (forall a b.
    (a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b)
-> (forall a b.
    (a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b)
-> (forall a b.
    (a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b)
-> (forall a b.
    (a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b)
-> Foldable1 (PackFoldableVI f)
forall a. Ord a => PackFoldableVI f a -> a
forall m. Semigroup m => PackFoldableVI f m -> m
forall a. PackFoldableVI f a -> a
forall a. PackFoldableVI f a -> NonEmpty a
forall m a. Semigroup m => (a -> m) -> PackFoldableVI f a -> m
forall a b. (a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b
forall a b. (a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b
forall (t :: * -> *).
Foldable t =>
(forall m. Semigroup m => t m -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall a. t a -> NonEmpty a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. t a -> a)
-> (forall a. t a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> Foldable1 t
forall (f :: * -> *). Foldable1 f => Foldable (PackFoldableVI f)
forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
PackFoldableVI f a -> a
forall (f :: * -> *) m.
(Foldable1 f, Semigroup m) =>
PackFoldableVI f m -> m
forall (f :: * -> *) a. Foldable1 f => PackFoldableVI f a -> a
forall (f :: * -> *) a.
Foldable1 f =>
PackFoldableVI f a -> NonEmpty a
forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> PackFoldableVI f a -> m
forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b
forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b
$cfold1 :: forall (f :: * -> *) m.
(Foldable1 f, Semigroup m) =>
PackFoldableVI f m -> m
fold1 :: forall m. Semigroup m => PackFoldableVI f m -> m
$cfoldMap1 :: forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> PackFoldableVI f a -> m
foldMap1 :: forall m a. Semigroup m => (a -> m) -> PackFoldableVI f a -> m
$cfoldMap1' :: forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> PackFoldableVI f a -> m
foldMap1' :: forall m a. Semigroup m => (a -> m) -> PackFoldableVI f a -> m
$ctoNonEmpty :: forall (f :: * -> *) a.
Foldable1 f =>
PackFoldableVI f a -> NonEmpty a
toNonEmpty :: forall a. PackFoldableVI f a -> NonEmpty a
$cmaximum :: forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
PackFoldableVI f a -> a
maximum :: forall a. Ord a => PackFoldableVI f a -> a
$cminimum :: forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
PackFoldableVI f a -> a
minimum :: forall a. Ord a => PackFoldableVI f a -> a
$chead :: forall (f :: * -> *) a. Foldable1 f => PackFoldableVI f a -> a
head :: forall a. PackFoldableVI f a -> a
$clast :: forall (f :: * -> *) a. Foldable1 f => PackFoldableVI f a -> a
last :: forall a. PackFoldableVI f a -> a
$cfoldrMap1 :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b
foldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b
$cfoldlMap1' :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b
foldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b
$cfoldlMap1 :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b
foldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> PackFoldableVI f a -> b
$cfoldrMap1' :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b
foldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> PackFoldableVI f a -> b
Foldable1, Functor (PackFoldableVI f)
Functor (PackFoldableVI f) =>
(forall a. a -> PackFoldableVI f a)
-> (forall a b.
    PackFoldableVI f (a -> b)
    -> PackFoldableVI f a -> PackFoldableVI f b)
-> (forall a b c.
    (a -> b -> c)
    -> PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f c)
-> (forall a b.
    PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b)
-> (forall a b.
    PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f a)
-> Applicative (PackFoldableVI f)
forall a. a -> PackFoldableVI f a
forall a b.
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f a
forall a b.
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
forall a b.
PackFoldableVI f (a -> b)
-> PackFoldableVI f a -> PackFoldableVI f b
forall a b c.
(a -> b -> c)
-> PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f 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
forall (f :: * -> *). Applicative f => Functor (PackFoldableVI f)
forall (f :: * -> *) a. Applicative f => a -> PackFoldableVI f a
forall (f :: * -> *) a b.
Applicative f =>
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f a
forall (f :: * -> *) a b.
Applicative f =>
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
forall (f :: * -> *) a b.
Applicative f =>
PackFoldableVI f (a -> b)
-> PackFoldableVI f a -> PackFoldableVI f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f c
$cpure :: forall (f :: * -> *) a. Applicative f => a -> PackFoldableVI f a
pure :: forall a. a -> PackFoldableVI f a
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
PackFoldableVI f (a -> b)
-> PackFoldableVI f a -> PackFoldableVI f b
<*> :: forall a b.
PackFoldableVI f (a -> b)
-> PackFoldableVI f a -> PackFoldableVI f b
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f c
liftA2 :: forall a b c.
(a -> b -> c)
-> PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f c
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
*> :: forall a b.
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f a
<* :: forall a b.
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f a
Applicative, Applicative (PackFoldableVI f)
Applicative (PackFoldableVI f) =>
(forall a b.
 PackFoldableVI f a
 -> (a -> PackFoldableVI f b) -> PackFoldableVI f b)
-> (forall a b.
    PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b)
-> (forall a. a -> PackFoldableVI f a)
-> Monad (PackFoldableVI f)
forall a. a -> PackFoldableVI f a
forall a b.
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
forall a b.
PackFoldableVI f a
-> (a -> PackFoldableVI f b) -> PackFoldableVI f b
forall (f :: * -> *). Monad f => Applicative (PackFoldableVI f)
forall (f :: * -> *) a. Monad f => a -> PackFoldableVI f a
forall (f :: * -> *) a b.
Monad f =>
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
forall (f :: * -> *) a b.
Monad f =>
PackFoldableVI f a
-> (a -> PackFoldableVI f b) -> PackFoldableVI f b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (f :: * -> *) a b.
Monad f =>
PackFoldableVI f a
-> (a -> PackFoldableVI f b) -> PackFoldableVI f b
>>= :: forall a b.
PackFoldableVI f a
-> (a -> PackFoldableVI f b) -> PackFoldableVI f b
$c>> :: forall (f :: * -> *) a b.
Monad f =>
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
>> :: forall a b.
PackFoldableVI f a -> PackFoldableVI f b -> PackFoldableVI f b
$creturn :: forall (f :: * -> *) a. Monad f => a -> PackFoldableVI f a
return :: forall a. a -> PackFoldableVI f a
Monad)

instance (Pack a, Foldable f) => Pack (PackFoldableVI f a) where
  pack :: PackFoldableVI f a -> Builder
pack =
    Int -> Builder
forall a. Integral a => a -> Builder
packleb32 (Int -> Builder)
-> (PackFoldableVI f a -> Int) -> PackFoldableVI f a -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> Int
forall a. f a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (f a -> Int)
-> (PackFoldableVI f a -> f a) -> PackFoldableVI f a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackFoldableVI f a -> f a
forall {k} (f :: k -> *) (a :: k). PackFoldableVI f a -> f a
getpackfoldablevi
      (PackFoldableVI f a -> Builder)
-> (PackFoldableVI f a -> Builder) -> PackFoldableVI f a -> Builder
forall a. Semigroup a => a -> a -> a
<> (a -> Builder) -> f a -> Builder
forall m a. Monoid m => (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap' a -> Builder
forall a. Pack a => a -> Builder
pack (f a -> Builder)
-> (PackFoldableVI f a -> f a) -> PackFoldableVI f a -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackFoldableVI f a -> f a
forall {k} (f :: k -> *) (a :: k). PackFoldableVI f a -> f a
getpackfoldablevi
  {-# INLINEABLE pack #-}

-- | General 'Pack' instance provider for 'Foldable's
--
-- no length prefix, strict left fold
newtype PackFoldable0 f a = PackFoldable0 {forall {k} (f :: k -> *) (a :: k). PackFoldable0 f a -> f a
getpackfoldable0 :: f a}
  deriving stock ((forall x. PackFoldable0 f a -> Rep (PackFoldable0 f a) x)
-> (forall x. Rep (PackFoldable0 f a) x -> PackFoldable0 f a)
-> Generic (PackFoldable0 f a)
forall x. Rep (PackFoldable0 f a) x -> PackFoldable0 f a
forall x. PackFoldable0 f a -> Rep (PackFoldable0 f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (f :: k -> *) (a :: k) x.
Rep (PackFoldable0 f a) x -> PackFoldable0 f a
forall k (f :: k -> *) (a :: k) x.
PackFoldable0 f a -> Rep (PackFoldable0 f a) x
$cfrom :: forall k (f :: k -> *) (a :: k) x.
PackFoldable0 f a -> Rep (PackFoldable0 f a) x
from :: forall x. PackFoldable0 f a -> Rep (PackFoldable0 f a) x
$cto :: forall k (f :: k -> *) (a :: k) x.
Rep (PackFoldable0 f a) x -> PackFoldable0 f a
to :: forall x. Rep (PackFoldable0 f a) x -> PackFoldable0 f a
Generic, (forall (a :: k). PackFoldable0 f a -> Rep1 (PackFoldable0 f) a)
-> (forall (a :: k). Rep1 (PackFoldable0 f) a -> PackFoldable0 f a)
-> Generic1 (PackFoldable0 f)
forall (a :: k). Rep1 (PackFoldable0 f) a -> PackFoldable0 f a
forall (a :: k). PackFoldable0 f a -> Rep1 (PackFoldable0 f) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
forall k (f :: k -> *) (a :: k).
Rep1 (PackFoldable0 f) a -> PackFoldable0 f a
forall k (f :: k -> *) (a :: k).
PackFoldable0 f a -> Rep1 (PackFoldable0 f) a
$cfrom1 :: forall k (f :: k -> *) (a :: k).
PackFoldable0 f a -> Rep1 (PackFoldable0 f) a
from1 :: forall (a :: k). PackFoldable0 f a -> Rep1 (PackFoldable0 f) a
$cto1 :: forall k (f :: k -> *) (a :: k).
Rep1 (PackFoldable0 f) a -> PackFoldable0 f a
to1 :: forall (a :: k). Rep1 (PackFoldable0 f) a -> PackFoldable0 f a
Generic1, Typeable, Typeable (PackFoldable0 f a)
Typeable (PackFoldable0 f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> PackFoldable0 f a
 -> c (PackFoldable0 f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PackFoldable0 f a))
-> (PackFoldable0 f a -> Constr)
-> (PackFoldable0 f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PackFoldable0 f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PackFoldable0 f a)))
-> ((forall b. Data b => b -> b)
    -> PackFoldable0 f a -> PackFoldable0 f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PackFoldable0 f a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PackFoldable0 f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PackFoldable0 f a -> m (PackFoldable0 f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackFoldable0 f a -> m (PackFoldable0 f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackFoldable0 f a -> m (PackFoldable0 f a))
-> Data (PackFoldable0 f a)
PackFoldable0 f a -> Constr
PackFoldable0 f a -> DataType
(forall b. Data b => b -> b)
-> PackFoldable0 f a -> PackFoldable0 f a
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PackFoldable0 f a -> u
forall u. (forall d. Data d => d -> u) -> PackFoldable0 f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldable0 f a -> Constr
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldable0 f a -> DataType
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b)
-> PackFoldable0 f a -> PackFoldable0 f a
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> PackFoldable0 f a -> u
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> PackFoldable0 f a -> [u]
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldable0 f a
-> c (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldable0 f a))
forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldable0 f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldable0 f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldable0 f a
-> c (PackFoldable0 f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldable0 f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldable0 f a))
$cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldable0 f a
-> c (PackFoldable0 f a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackFoldable0 f a
-> c (PackFoldable0 f a)
$cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldable0 f a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PackFoldable0 f a)
$ctoConstr :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldable0 f a -> Constr
toConstr :: PackFoldable0 f a -> Constr
$cdataTypeOf :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
PackFoldable0 f a -> DataType
dataTypeOf :: PackFoldable0 f a -> DataType
$cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldable0 f a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PackFoldable0 f a))
$cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldable0 f a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PackFoldable0 f a))
$cgmapT :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b)
-> PackFoldable0 f a -> PackFoldable0 f a
gmapT :: (forall b. Data b => b -> b)
-> PackFoldable0 f a -> PackFoldable0 f a
$cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
$cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackFoldable0 f a -> r
$cgmapQ :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> PackFoldable0 f a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PackFoldable0 f a -> [u]
$cgmapQi :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> PackFoldable0 f a -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PackFoldable0 f a -> u
$cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
$cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
$cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackFoldable0 f a -> m (PackFoldable0 f a)
Data, (forall (m :: * -> *). Quote m => PackFoldable0 f a -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    PackFoldable0 f a -> Code m (PackFoldable0 f a))
-> Lift (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldable0 f a -> m Exp
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldable0 f a -> Code m (PackFoldable0 f a)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PackFoldable0 f a -> m Exp
forall (m :: * -> *).
Quote m =>
PackFoldable0 f a -> Code m (PackFoldable0 f a)
$clift :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldable0 f a -> m Exp
lift :: forall (m :: * -> *). Quote m => PackFoldable0 f a -> m Exp
$cliftTyped :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
PackFoldable0 f a -> Code m (PackFoldable0 f a)
liftTyped :: forall (m :: * -> *).
Quote m =>
PackFoldable0 f a -> Code m (PackFoldable0 f a)
Lift)
  deriving newtype (PackFoldable0 f a -> PackFoldable0 f a -> Bool
(PackFoldable0 f a -> PackFoldable0 f a -> Bool)
-> (PackFoldable0 f a -> PackFoldable0 f a -> Bool)
-> Eq (PackFoldable0 f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (f :: k -> *) (a :: k).
Eq (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
$c== :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
== :: PackFoldable0 f a -> PackFoldable0 f a -> Bool
$c/= :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
/= :: PackFoldable0 f a -> PackFoldable0 f a -> Bool
Eq, Eq (PackFoldable0 f a)
Eq (PackFoldable0 f a) =>
(PackFoldable0 f a -> PackFoldable0 f a -> Ordering)
-> (PackFoldable0 f a -> PackFoldable0 f a -> Bool)
-> (PackFoldable0 f a -> PackFoldable0 f a -> Bool)
-> (PackFoldable0 f a -> PackFoldable0 f a -> Bool)
-> (PackFoldable0 f a -> PackFoldable0 f a -> Bool)
-> (PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a)
-> (PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a)
-> Ord (PackFoldable0 f a)
PackFoldable0 f a -> PackFoldable0 f a -> Bool
PackFoldable0 f a -> PackFoldable0 f a -> Ordering
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f 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 k (f :: k -> *) (a :: k).
Ord (f a) =>
Eq (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Ordering
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
$ccompare :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Ordering
compare :: PackFoldable0 f a -> PackFoldable0 f a -> Ordering
$c< :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
< :: PackFoldable0 f a -> PackFoldable0 f a -> Bool
$c<= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
<= :: PackFoldable0 f a -> PackFoldable0 f a -> Bool
$c> :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
> :: PackFoldable0 f a -> PackFoldable0 f a -> Bool
$c>= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> Bool
>= :: PackFoldable0 f a -> PackFoldable0 f a -> Bool
$cmax :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
max :: PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
$cmin :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
min :: PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
Ord, Int -> PackFoldable0 f a -> ShowS
[PackFoldable0 f a] -> ShowS
PackFoldable0 f a -> String
(Int -> PackFoldable0 f a -> ShowS)
-> (PackFoldable0 f a -> String)
-> ([PackFoldable0 f a] -> ShowS)
-> Show (PackFoldable0 f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> PackFoldable0 f a -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
[PackFoldable0 f a] -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
PackFoldable0 f a -> String
$cshowsPrec :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> PackFoldable0 f a -> ShowS
showsPrec :: Int -> PackFoldable0 f a -> ShowS
$cshow :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
PackFoldable0 f a -> String
show :: PackFoldable0 f a -> String
$cshowList :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
[PackFoldable0 f a] -> ShowS
showList :: [PackFoldable0 f a] -> ShowS
Show, ReadPrec [PackFoldable0 f a]
ReadPrec (PackFoldable0 f a)
Int -> ReadS (PackFoldable0 f a)
ReadS [PackFoldable0 f a]
(Int -> ReadS (PackFoldable0 f a))
-> ReadS [PackFoldable0 f a]
-> ReadPrec (PackFoldable0 f a)
-> ReadPrec [PackFoldable0 f a]
-> Read (PackFoldable0 f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [PackFoldable0 f a]
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [PackFoldable0 f a]
$creadsPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (PackFoldable0 f a)
readsPrec :: Int -> ReadS (PackFoldable0 f a)
$creadList :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [PackFoldable0 f a]
readList :: ReadS [PackFoldable0 f a]
$creadPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (PackFoldable0 f a)
readPrec :: ReadPrec (PackFoldable0 f a)
$creadListPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [PackFoldable0 f a]
readListPrec :: ReadPrec [PackFoldable0 f a]
Read, Eq (PackFoldable0 f a)
Eq (PackFoldable0 f a) =>
(Int -> PackFoldable0 f a -> Int)
-> (PackFoldable0 f a -> Int) -> Hashable (PackFoldable0 f a)
Int -> PackFoldable0 f a -> Int
PackFoldable0 f a -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Eq (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Int -> PackFoldable0 f a -> Int
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
PackFoldable0 f a -> Int
$chashWithSalt :: forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Int -> PackFoldable0 f a -> Int
hashWithSalt :: Int -> PackFoldable0 f a -> Int
$chash :: forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
PackFoldable0 f a -> Int
hash :: PackFoldable0 f a -> Int
Hashable, PackFoldable0 f a -> ()
(PackFoldable0 f a -> ()) -> NFData (PackFoldable0 f a)
forall a. (a -> ()) -> NFData a
forall k (f :: k -> *) (a :: k).
NFData (f a) =>
PackFoldable0 f a -> ()
$crnf :: forall k (f :: k -> *) (a :: k).
NFData (f a) =>
PackFoldable0 f a -> ()
rnf :: PackFoldable0 f a -> ()
NFData, (forall a b. (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b)
-> (forall a b. a -> PackFoldable0 f b -> PackFoldable0 f a)
-> Functor (PackFoldable0 f)
forall a b. a -> PackFoldable0 f b -> PackFoldable0 f a
forall a b. (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
forall (f :: * -> *) a b.
Functor f =>
a -> PackFoldable0 f b -> PackFoldable0 f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
fmap :: forall a b. (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> PackFoldable0 f b -> PackFoldable0 f a
<$ :: forall a b. a -> PackFoldable0 f b -> PackFoldable0 f a
Functor)
  deriving newtype ((forall a. Eq a => Eq (PackFoldable0 f a)) =>
(forall a b.
 (a -> b -> Bool) -> PackFoldable0 f a -> PackFoldable0 f b -> Bool)
-> Eq1 (PackFoldable0 f)
forall a. Eq a => Eq (PackFoldable0 f a)
forall a b.
(a -> b -> Bool) -> PackFoldable0 f a -> PackFoldable0 f b -> Bool
forall (f :: * -> *) a. (Eq1 f, Eq a) => Eq (PackFoldable0 f a)
forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> PackFoldable0 f a -> PackFoldable0 f b -> Bool
forall (f :: * -> *).
(forall a. Eq a => Eq (f a)) =>
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
$cliftEq :: forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> PackFoldable0 f a -> PackFoldable0 f b -> Bool
liftEq :: forall a b.
(a -> b -> Bool) -> PackFoldable0 f a -> PackFoldable0 f b -> Bool
Eq1, Eq1 (PackFoldable0 f)
(Eq1 (PackFoldable0 f),
 forall a. Ord a => Ord (PackFoldable0 f a)) =>
(forall a b.
 (a -> b -> Ordering)
 -> PackFoldable0 f a -> PackFoldable0 f b -> Ordering)
-> Ord1 (PackFoldable0 f)
forall a. Ord a => Ord (PackFoldable0 f a)
forall a b.
(a -> b -> Ordering)
-> PackFoldable0 f a -> PackFoldable0 f b -> Ordering
forall (f :: * -> *). Ord1 f => Eq1 (PackFoldable0 f)
forall (f :: * -> *) a. (Ord1 f, Ord a) => Ord (PackFoldable0 f a)
forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering)
-> PackFoldable0 f a -> PackFoldable0 f b -> Ordering
forall (f :: * -> *).
(Eq1 f, forall a. Ord a => Ord (f a)) =>
(forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
$cliftCompare :: forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering)
-> PackFoldable0 f a -> PackFoldable0 f b -> Ordering
liftCompare :: forall a b.
(a -> b -> Ordering)
-> PackFoldable0 f a -> PackFoldable0 f b -> Ordering
Ord1, (forall a. Show a => Show (PackFoldable0 f a)) =>
(forall a.
 (Int -> a -> ShowS)
 -> ([a] -> ShowS) -> Int -> PackFoldable0 f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [PackFoldable0 f a] -> ShowS)
-> Show1 (PackFoldable0 f)
forall a. Show a => Show (PackFoldable0 f a)
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldable0 f a -> ShowS
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldable0 f a] -> ShowS
forall (f :: * -> *) a.
(Show1 f, Show a) =>
Show (PackFoldable0 f a)
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldable0 f a -> ShowS
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldable0 f a] -> ShowS
forall (f :: * -> *).
(forall a. Show a => Show (f a)) =>
(forall a.
 (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS)
-> Show1 f
$cliftShowsPrec :: forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldable0 f a -> ShowS
liftShowsPrec :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> PackFoldable0 f a -> ShowS
$cliftShowList :: forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldable0 f a] -> ShowS
liftShowList :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [PackFoldable0 f a] -> ShowS
Show1, (forall a. Read a => Read (PackFoldable0 f a)) =>
(forall a.
 (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldable0 f a))
-> (forall a.
    (Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldable0 f a])
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldable0 f a))
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldable0 f a])
-> Read1 (PackFoldable0 f)
forall a. Read a => Read (PackFoldable0 f a)
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldable0 f a]
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldable0 f a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldable0 f a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldable0 f a]
forall (f :: * -> *) a.
(Read1 f, Read a) =>
Read (PackFoldable0 f a)
forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldable0 f a]
forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldable0 f a)
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldable0 f a)
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldable0 f a]
forall (f :: * -> *).
(forall a. Read a => Read (f a)) =>
(forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a))
-> (forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [f a])
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (f a))
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [f a])
-> Read1 f
$cliftReadsPrec :: forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldable0 f a)
liftReadsPrec :: forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (PackFoldable0 f a)
$cliftReadList :: forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldable0 f a]
liftReadList :: forall a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [PackFoldable0 f a]
$cliftReadPrec :: forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldable0 f a)
liftReadPrec :: forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (PackFoldable0 f a)
$cliftReadListPrec :: forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldable0 f a]
liftReadListPrec :: forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [PackFoldable0 f a]
Read1, NonEmpty (PackFoldable0 f a) -> PackFoldable0 f a
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
(PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a)
-> (NonEmpty (PackFoldable0 f a) -> PackFoldable0 f a)
-> (forall b.
    Integral b =>
    b -> PackFoldable0 f a -> PackFoldable0 f a)
-> Semigroup (PackFoldable0 f a)
forall b. Integral b => b -> PackFoldable0 f a -> PackFoldable0 f a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
NonEmpty (PackFoldable0 f a) -> PackFoldable0 f a
forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
forall k (f :: k -> *) (a :: k) b.
(Semigroup (f a), Integral b) =>
b -> PackFoldable0 f a -> PackFoldable0 f a
$c<> :: forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
<> :: PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
$csconcat :: forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
NonEmpty (PackFoldable0 f a) -> PackFoldable0 f a
sconcat :: NonEmpty (PackFoldable0 f a) -> PackFoldable0 f a
$cstimes :: forall k (f :: k -> *) (a :: k) b.
(Semigroup (f a), Integral b) =>
b -> PackFoldable0 f a -> PackFoldable0 f a
stimes :: forall b. Integral b => b -> PackFoldable0 f a -> PackFoldable0 f a
Semigroup, Semigroup (PackFoldable0 f a)
PackFoldable0 f a
Semigroup (PackFoldable0 f a) =>
PackFoldable0 f a
-> (PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a)
-> ([PackFoldable0 f a] -> PackFoldable0 f a)
-> Monoid (PackFoldable0 f a)
[PackFoldable0 f a] -> PackFoldable0 f a
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
Semigroup (PackFoldable0 f a)
forall k (f :: k -> *) (a :: k). Monoid (f a) => PackFoldable0 f a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
[PackFoldable0 f a] -> PackFoldable0 f a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
$cmempty :: forall k (f :: k -> *) (a :: k). Monoid (f a) => PackFoldable0 f a
mempty :: PackFoldable0 f a
$cmappend :: forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
mappend :: PackFoldable0 f a -> PackFoldable0 f a -> PackFoldable0 f a
$cmconcat :: forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
[PackFoldable0 f a] -> PackFoldable0 f a
mconcat :: [PackFoldable0 f a] -> PackFoldable0 f a
Monoid)
  deriving newtype ((forall m. Monoid m => PackFoldable0 f m -> m)
-> (forall m a. Monoid m => (a -> m) -> PackFoldable0 f a -> m)
-> (forall m a. Monoid m => (a -> m) -> PackFoldable0 f a -> m)
-> (forall a b. (a -> b -> b) -> b -> PackFoldable0 f a -> b)
-> (forall a b. (a -> b -> b) -> b -> PackFoldable0 f a -> b)
-> (forall b a. (b -> a -> b) -> b -> PackFoldable0 f a -> b)
-> (forall b a. (b -> a -> b) -> b -> PackFoldable0 f a -> b)
-> (forall a. (a -> a -> a) -> PackFoldable0 f a -> a)
-> (forall a. (a -> a -> a) -> PackFoldable0 f a -> a)
-> (forall a. PackFoldable0 f a -> [a])
-> (forall a. PackFoldable0 f a -> Bool)
-> (forall a. PackFoldable0 f a -> Int)
-> (forall a. Eq a => a -> PackFoldable0 f a -> Bool)
-> (forall a. Ord a => PackFoldable0 f a -> a)
-> (forall a. Ord a => PackFoldable0 f a -> a)
-> (forall a. Num a => PackFoldable0 f a -> a)
-> (forall a. Num a => PackFoldable0 f a -> a)
-> Foldable (PackFoldable0 f)
forall a. Eq a => a -> PackFoldable0 f a -> Bool
forall a. Num a => PackFoldable0 f a -> a
forall a. Ord a => PackFoldable0 f a -> a
forall m. Monoid m => PackFoldable0 f m -> m
forall a. PackFoldable0 f a -> Bool
forall a. PackFoldable0 f a -> Int
forall a. PackFoldable0 f a -> [a]
forall a. (a -> a -> a) -> PackFoldable0 f a -> a
forall m a. Monoid m => (a -> m) -> PackFoldable0 f a -> m
forall b a. (b -> a -> b) -> b -> PackFoldable0 f a -> b
forall a b. (a -> b -> b) -> b -> PackFoldable0 f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> PackFoldable0 f a -> Bool
forall (f :: * -> *) a.
(Foldable f, Num a) =>
PackFoldable0 f a -> a
forall (f :: * -> *) a.
(Foldable f, Ord a) =>
PackFoldable0 f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
PackFoldable0 f m -> m
forall (f :: * -> *) a. Foldable f => PackFoldable0 f a -> Bool
forall (f :: * -> *) a. Foldable f => PackFoldable0 f a -> Int
forall (f :: * -> *) a. Foldable f => PackFoldable0 f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> PackFoldable0 f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> PackFoldable0 f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> PackFoldable0 f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> PackFoldable0 f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
PackFoldable0 f m -> m
fold :: forall m. Monoid m => PackFoldable0 f m -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> PackFoldable0 f a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PackFoldable0 f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> PackFoldable0 f a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> PackFoldable0 f a -> m
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> PackFoldable0 f a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PackFoldable0 f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> PackFoldable0 f a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PackFoldable0 f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> PackFoldable0 f a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PackFoldable0 f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> PackFoldable0 f a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> PackFoldable0 f a -> b
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> PackFoldable0 f a -> a
foldr1 :: forall a. (a -> a -> a) -> PackFoldable0 f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> PackFoldable0 f a -> a
foldl1 :: forall a. (a -> a -> a) -> PackFoldable0 f a -> a
$ctoList :: forall (f :: * -> *) a. Foldable f => PackFoldable0 f a -> [a]
toList :: forall a. PackFoldable0 f a -> [a]
$cnull :: forall (f :: * -> *) a. Foldable f => PackFoldable0 f a -> Bool
null :: forall a. PackFoldable0 f a -> Bool
$clength :: forall (f :: * -> *) a. Foldable f => PackFoldable0 f a -> Int
length :: forall a. PackFoldable0 f a -> Int
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> PackFoldable0 f a -> Bool
elem :: forall a. Eq a => a -> PackFoldable0 f a -> Bool
$cmaximum :: forall (f :: * -> *) a.
(Foldable f, Ord a) =>
PackFoldable0 f a -> a
maximum :: forall a. Ord a => PackFoldable0 f a -> a
$cminimum :: forall (f :: * -> *) a.
(Foldable f, Ord a) =>
PackFoldable0 f a -> a
minimum :: forall a. Ord a => PackFoldable0 f a -> a
$csum :: forall (f :: * -> *) a.
(Foldable f, Num a) =>
PackFoldable0 f a -> a
sum :: forall a. Num a => PackFoldable0 f a -> a
$cproduct :: forall (f :: * -> *) a.
(Foldable f, Num a) =>
PackFoldable0 f a -> a
product :: forall a. Num a => PackFoldable0 f a -> a
Foldable, Foldable (PackFoldable0 f)
Foldable (PackFoldable0 f) =>
(forall m. Semigroup m => PackFoldable0 f m -> m)
-> (forall m a. Semigroup m => (a -> m) -> PackFoldable0 f a -> m)
-> (forall m a. Semigroup m => (a -> m) -> PackFoldable0 f a -> m)
-> (forall a. PackFoldable0 f a -> NonEmpty a)
-> (forall a. Ord a => PackFoldable0 f a -> a)
-> (forall a. Ord a => PackFoldable0 f a -> a)
-> (forall a. PackFoldable0 f a -> a)
-> (forall a. PackFoldable0 f a -> a)
-> (forall a b.
    (a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b)
-> (forall a b.
    (a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b)
-> (forall a b.
    (a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b)
-> (forall a b.
    (a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b)
-> Foldable1 (PackFoldable0 f)
forall a. Ord a => PackFoldable0 f a -> a
forall m. Semigroup m => PackFoldable0 f m -> m
forall a. PackFoldable0 f a -> a
forall a. PackFoldable0 f a -> NonEmpty a
forall m a. Semigroup m => (a -> m) -> PackFoldable0 f a -> m
forall a b. (a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b
forall a b. (a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b
forall (t :: * -> *).
Foldable t =>
(forall m. Semigroup m => t m -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall a. t a -> NonEmpty a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. t a -> a)
-> (forall a. t a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> Foldable1 t
forall (f :: * -> *). Foldable1 f => Foldable (PackFoldable0 f)
forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
PackFoldable0 f a -> a
forall (f :: * -> *) m.
(Foldable1 f, Semigroup m) =>
PackFoldable0 f m -> m
forall (f :: * -> *) a. Foldable1 f => PackFoldable0 f a -> a
forall (f :: * -> *) a.
Foldable1 f =>
PackFoldable0 f a -> NonEmpty a
forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> PackFoldable0 f a -> m
forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b
forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b
$cfold1 :: forall (f :: * -> *) m.
(Foldable1 f, Semigroup m) =>
PackFoldable0 f m -> m
fold1 :: forall m. Semigroup m => PackFoldable0 f m -> m
$cfoldMap1 :: forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> PackFoldable0 f a -> m
foldMap1 :: forall m a. Semigroup m => (a -> m) -> PackFoldable0 f a -> m
$cfoldMap1' :: forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> PackFoldable0 f a -> m
foldMap1' :: forall m a. Semigroup m => (a -> m) -> PackFoldable0 f a -> m
$ctoNonEmpty :: forall (f :: * -> *) a.
Foldable1 f =>
PackFoldable0 f a -> NonEmpty a
toNonEmpty :: forall a. PackFoldable0 f a -> NonEmpty a
$cmaximum :: forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
PackFoldable0 f a -> a
maximum :: forall a. Ord a => PackFoldable0 f a -> a
$cminimum :: forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
PackFoldable0 f a -> a
minimum :: forall a. Ord a => PackFoldable0 f a -> a
$chead :: forall (f :: * -> *) a. Foldable1 f => PackFoldable0 f a -> a
head :: forall a. PackFoldable0 f a -> a
$clast :: forall (f :: * -> *) a. Foldable1 f => PackFoldable0 f a -> a
last :: forall a. PackFoldable0 f a -> a
$cfoldrMap1 :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b
foldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b
$cfoldlMap1' :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b
foldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b
$cfoldlMap1 :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b
foldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> PackFoldable0 f a -> b
$cfoldrMap1' :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b
foldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> PackFoldable0 f a -> b
Foldable1, Functor (PackFoldable0 f)
Functor (PackFoldable0 f) =>
(forall a. a -> PackFoldable0 f a)
-> (forall a b.
    PackFoldable0 f (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b)
-> (forall a b c.
    (a -> b -> c)
    -> PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f c)
-> (forall a b.
    PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b)
-> (forall a b.
    PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f a)
-> Applicative (PackFoldable0 f)
forall a. a -> PackFoldable0 f a
forall a b.
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f a
forall a b.
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
forall a b.
PackFoldable0 f (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
forall a b c.
(a -> b -> c)
-> PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f 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
forall (f :: * -> *). Applicative f => Functor (PackFoldable0 f)
forall (f :: * -> *) a. Applicative f => a -> PackFoldable0 f a
forall (f :: * -> *) a b.
Applicative f =>
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f a
forall (f :: * -> *) a b.
Applicative f =>
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
forall (f :: * -> *) a b.
Applicative f =>
PackFoldable0 f (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f c
$cpure :: forall (f :: * -> *) a. Applicative f => a -> PackFoldable0 f a
pure :: forall a. a -> PackFoldable0 f a
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
PackFoldable0 f (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
<*> :: forall a b.
PackFoldable0 f (a -> b) -> PackFoldable0 f a -> PackFoldable0 f b
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f c
liftA2 :: forall a b c.
(a -> b -> c)
-> PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f c
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
*> :: forall a b.
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f a
<* :: forall a b.
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f a
Applicative, Applicative (PackFoldable0 f)
Applicative (PackFoldable0 f) =>
(forall a b.
 PackFoldable0 f a -> (a -> PackFoldable0 f b) -> PackFoldable0 f b)
-> (forall a b.
    PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b)
-> (forall a. a -> PackFoldable0 f a)
-> Monad (PackFoldable0 f)
forall a. a -> PackFoldable0 f a
forall a b.
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
forall a b.
PackFoldable0 f a -> (a -> PackFoldable0 f b) -> PackFoldable0 f b
forall (f :: * -> *). Monad f => Applicative (PackFoldable0 f)
forall (f :: * -> *) a. Monad f => a -> PackFoldable0 f a
forall (f :: * -> *) a b.
Monad f =>
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
forall (f :: * -> *) a b.
Monad f =>
PackFoldable0 f a -> (a -> PackFoldable0 f b) -> PackFoldable0 f b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (f :: * -> *) a b.
Monad f =>
PackFoldable0 f a -> (a -> PackFoldable0 f b) -> PackFoldable0 f b
>>= :: forall a b.
PackFoldable0 f a -> (a -> PackFoldable0 f b) -> PackFoldable0 f b
$c>> :: forall (f :: * -> *) a b.
Monad f =>
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
>> :: forall a b.
PackFoldable0 f a -> PackFoldable0 f b -> PackFoldable0 f b
$creturn :: forall (f :: * -> *) a. Monad f => a -> PackFoldable0 f a
return :: forall a. a -> PackFoldable0 f a
Monad)

-- | @'foldMap' 'pack'@
instance (Pack a, Foldable f) => Pack (PackFoldable0 f a) where
  pack :: PackFoldable0 f a -> Builder
pack = (a -> Builder) -> f a -> Builder
forall m a. Monoid m => (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap' a -> Builder
forall a. Pack a => a -> Builder
pack (f a -> Builder)
-> (PackFoldable0 f a -> f a) -> PackFoldable0 f a -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackFoldable0 f a -> f a
forall {k} (f :: k -> *) (a :: k). PackFoldable0 f a -> f a
getpackfoldable0
  {-# INLINEABLE pack #-}

-- | General 'Unpack' instance provider for 'Representable's that are also
-- 'Traversable'
newtype UnpackRepresentable0 f a = UnpackRepresentable0
  {forall {k} (f :: k -> *) (a :: k). UnpackRepresentable0 f a -> f a
getunpackrepresentable0 :: f a}
  deriving stock ((forall x.
 UnpackRepresentable0 f a -> Rep (UnpackRepresentable0 f a) x)
-> (forall x.
    Rep (UnpackRepresentable0 f a) x -> UnpackRepresentable0 f a)
-> Generic (UnpackRepresentable0 f a)
forall x.
Rep (UnpackRepresentable0 f a) x -> UnpackRepresentable0 f a
forall x.
UnpackRepresentable0 f a -> Rep (UnpackRepresentable0 f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (f :: k -> *) (a :: k) x.
Rep (UnpackRepresentable0 f a) x -> UnpackRepresentable0 f a
forall k (f :: k -> *) (a :: k) x.
UnpackRepresentable0 f a -> Rep (UnpackRepresentable0 f a) x
$cfrom :: forall k (f :: k -> *) (a :: k) x.
UnpackRepresentable0 f a -> Rep (UnpackRepresentable0 f a) x
from :: forall x.
UnpackRepresentable0 f a -> Rep (UnpackRepresentable0 f a) x
$cto :: forall k (f :: k -> *) (a :: k) x.
Rep (UnpackRepresentable0 f a) x -> UnpackRepresentable0 f a
to :: forall x.
Rep (UnpackRepresentable0 f a) x -> UnpackRepresentable0 f a
Generic, (forall (a :: k).
 UnpackRepresentable0 f a -> Rep1 (UnpackRepresentable0 f) a)
-> (forall (a :: k).
    Rep1 (UnpackRepresentable0 f) a -> UnpackRepresentable0 f a)
-> Generic1 (UnpackRepresentable0 f)
forall (a :: k).
Rep1 (UnpackRepresentable0 f) a -> UnpackRepresentable0 f a
forall (a :: k).
UnpackRepresentable0 f a -> Rep1 (UnpackRepresentable0 f) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
forall k (f :: k -> *) (a :: k).
Rep1 (UnpackRepresentable0 f) a -> UnpackRepresentable0 f a
forall k (f :: k -> *) (a :: k).
UnpackRepresentable0 f a -> Rep1 (UnpackRepresentable0 f) a
$cfrom1 :: forall k (f :: k -> *) (a :: k).
UnpackRepresentable0 f a -> Rep1 (UnpackRepresentable0 f) a
from1 :: forall (a :: k).
UnpackRepresentable0 f a -> Rep1 (UnpackRepresentable0 f) a
$cto1 :: forall k (f :: k -> *) (a :: k).
Rep1 (UnpackRepresentable0 f) a -> UnpackRepresentable0 f a
to1 :: forall (a :: k).
Rep1 (UnpackRepresentable0 f) a -> UnpackRepresentable0 f a
Generic1, Typeable, Typeable (UnpackRepresentable0 f a)
Typeable (UnpackRepresentable0 f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> UnpackRepresentable0 f a
 -> c (UnpackRepresentable0 f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (UnpackRepresentable0 f a))
-> (UnpackRepresentable0 f a -> Constr)
-> (UnpackRepresentable0 f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (UnpackRepresentable0 f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (UnpackRepresentable0 f a)))
-> ((forall b. Data b => b -> b)
    -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> UnpackRepresentable0 f a
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> UnpackRepresentable0 f a
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a))
-> Data (UnpackRepresentable0 f a)
UnpackRepresentable0 f a -> Constr
UnpackRepresentable0 f a -> DataType
(forall b. Data b => b -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> u
forall u.
(forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
UnpackRepresentable0 f a -> Constr
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
UnpackRepresentable0 f a -> DataType
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int
-> (forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> u
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> [u]
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UnpackRepresentable0 f a
-> c (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (UnpackRepresentable0 f a))
forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UnpackRepresentable0 f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UnpackRepresentable0 f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UnpackRepresentable0 f a
-> c (UnpackRepresentable0 f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (UnpackRepresentable0 f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UnpackRepresentable0 f a))
$cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UnpackRepresentable0 f a
-> c (UnpackRepresentable0 f a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UnpackRepresentable0 f a
-> c (UnpackRepresentable0 f a)
$cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UnpackRepresentable0 f a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (UnpackRepresentable0 f a)
$ctoConstr :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
UnpackRepresentable0 f a -> Constr
toConstr :: UnpackRepresentable0 f a -> Constr
$cdataTypeOf :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
UnpackRepresentable0 f a -> DataType
dataTypeOf :: UnpackRepresentable0 f a -> DataType
$cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (UnpackRepresentable0 f a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (UnpackRepresentable0 f a))
$cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UnpackRepresentable0 f a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (UnpackRepresentable0 f a))
$cgmapT :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
gmapT :: (forall b. Data b => b -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
$cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
$cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> UnpackRepresentable0 f a
-> r
$cgmapQ :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> [u]
$cgmapQi :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int
-> (forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> UnpackRepresentable0 f a -> u
$cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
$cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
$cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UnpackRepresentable0 f a -> m (UnpackRepresentable0 f a)
Data, (forall (m :: * -> *).
 Quote m =>
 UnpackRepresentable0 f a -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    UnpackRepresentable0 f a -> Code m (UnpackRepresentable0 f a))
-> Lift (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
UnpackRepresentable0 f a -> m Exp
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
UnpackRepresentable0 f a -> Code m (UnpackRepresentable0 f a)
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => UnpackRepresentable0 f a -> m Exp
forall (m :: * -> *).
Quote m =>
UnpackRepresentable0 f a -> Code m (UnpackRepresentable0 f a)
$clift :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
UnpackRepresentable0 f a -> m Exp
lift :: forall (m :: * -> *). Quote m => UnpackRepresentable0 f a -> m Exp
$cliftTyped :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Lift (f a), Quote m) =>
UnpackRepresentable0 f a -> Code m (UnpackRepresentable0 f a)
liftTyped :: forall (m :: * -> *).
Quote m =>
UnpackRepresentable0 f a -> Code m (UnpackRepresentable0 f a)
Lift)
  deriving newtype (UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
(UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool)
-> (UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool)
-> Eq (UnpackRepresentable0 f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (f :: k -> *) (a :: k).
Eq (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
$c== :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
== :: UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
$c/= :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
/= :: UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
Eq, Eq (UnpackRepresentable0 f a)
Eq (UnpackRepresentable0 f a) =>
(UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Ordering)
-> (UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool)
-> (UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool)
-> (UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool)
-> (UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool)
-> (UnpackRepresentable0 f a
    -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a)
-> (UnpackRepresentable0 f a
    -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a)
-> Ord (UnpackRepresentable0 f a)
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Ordering
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f 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 k (f :: k -> *) (a :: k).
Ord (f a) =>
Eq (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Ordering
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
$ccompare :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Ordering
compare :: UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Ordering
$c< :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
< :: UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
$c<= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
<= :: UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
$c> :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
> :: UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
$c>= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
>= :: UnpackRepresentable0 f a -> UnpackRepresentable0 f a -> Bool
$cmax :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
max :: UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
$cmin :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
min :: UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
Ord, Int -> UnpackRepresentable0 f a -> ShowS
[UnpackRepresentable0 f a] -> ShowS
UnpackRepresentable0 f a -> String
(Int -> UnpackRepresentable0 f a -> ShowS)
-> (UnpackRepresentable0 f a -> String)
-> ([UnpackRepresentable0 f a] -> ShowS)
-> Show (UnpackRepresentable0 f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> UnpackRepresentable0 f a -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
[UnpackRepresentable0 f a] -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
UnpackRepresentable0 f a -> String
$cshowsPrec :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> UnpackRepresentable0 f a -> ShowS
showsPrec :: Int -> UnpackRepresentable0 f a -> ShowS
$cshow :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
UnpackRepresentable0 f a -> String
show :: UnpackRepresentable0 f a -> String
$cshowList :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
[UnpackRepresentable0 f a] -> ShowS
showList :: [UnpackRepresentable0 f a] -> ShowS
Show, ReadPrec [UnpackRepresentable0 f a]
ReadPrec (UnpackRepresentable0 f a)
Int -> ReadS (UnpackRepresentable0 f a)
ReadS [UnpackRepresentable0 f a]
(Int -> ReadS (UnpackRepresentable0 f a))
-> ReadS [UnpackRepresentable0 f a]
-> ReadPrec (UnpackRepresentable0 f a)
-> ReadPrec [UnpackRepresentable0 f a]
-> Read (UnpackRepresentable0 f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [UnpackRepresentable0 f a]
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [UnpackRepresentable0 f a]
$creadsPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (UnpackRepresentable0 f a)
readsPrec :: Int -> ReadS (UnpackRepresentable0 f a)
$creadList :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [UnpackRepresentable0 f a]
readList :: ReadS [UnpackRepresentable0 f a]
$creadPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (UnpackRepresentable0 f a)
readPrec :: ReadPrec (UnpackRepresentable0 f a)
$creadListPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [UnpackRepresentable0 f a]
readListPrec :: ReadPrec [UnpackRepresentable0 f a]
Read, Eq (UnpackRepresentable0 f a)
Eq (UnpackRepresentable0 f a) =>
(Int -> UnpackRepresentable0 f a -> Int)
-> (UnpackRepresentable0 f a -> Int)
-> Hashable (UnpackRepresentable0 f a)
Int -> UnpackRepresentable0 f a -> Int
UnpackRepresentable0 f a -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Eq (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Int -> UnpackRepresentable0 f a -> Int
forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
UnpackRepresentable0 f a -> Int
$chashWithSalt :: forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
Int -> UnpackRepresentable0 f a -> Int
hashWithSalt :: Int -> UnpackRepresentable0 f a -> Int
$chash :: forall k (f :: k -> *) (a :: k).
Hashable (f a) =>
UnpackRepresentable0 f a -> Int
hash :: UnpackRepresentable0 f a -> Int
Hashable, UnpackRepresentable0 f a -> ()
(UnpackRepresentable0 f a -> ())
-> NFData (UnpackRepresentable0 f a)
forall a. (a -> ()) -> NFData a
forall k (f :: k -> *) (a :: k).
NFData (f a) =>
UnpackRepresentable0 f a -> ()
$crnf :: forall k (f :: k -> *) (a :: k).
NFData (f a) =>
UnpackRepresentable0 f a -> ()
rnf :: UnpackRepresentable0 f a -> ()
NFData, (forall a b.
 (a -> b) -> UnpackRepresentable0 f a -> UnpackRepresentable0 f b)
-> (forall a b.
    a -> UnpackRepresentable0 f b -> UnpackRepresentable0 f a)
-> Functor (UnpackRepresentable0 f)
forall a b.
a -> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
forall a b.
(a -> b) -> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
forall (f :: * -> *) a b.
Functor f =>
a -> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
fmap :: forall a b.
(a -> b) -> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
<$ :: forall a b.
a -> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
Functor)
  deriving newtype ((forall a. Eq a => Eq (UnpackRepresentable0 f a)) =>
(forall a b.
 (a -> b -> Bool)
 -> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Bool)
-> Eq1 (UnpackRepresentable0 f)
forall a. Eq a => Eq (UnpackRepresentable0 f a)
forall a b.
(a -> b -> Bool)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Bool
forall (f :: * -> *) a.
(Eq1 f, Eq a) =>
Eq (UnpackRepresentable0 f a)
forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Bool
forall (f :: * -> *).
(forall a. Eq a => Eq (f a)) =>
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
$cliftEq :: forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Bool
liftEq :: forall a b.
(a -> b -> Bool)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Bool
Eq1, Eq1 (UnpackRepresentable0 f)
(Eq1 (UnpackRepresentable0 f),
 forall a. Ord a => Ord (UnpackRepresentable0 f a)) =>
(forall a b.
 (a -> b -> Ordering)
 -> UnpackRepresentable0 f a
 -> UnpackRepresentable0 f b
 -> Ordering)
-> Ord1 (UnpackRepresentable0 f)
forall a. Ord a => Ord (UnpackRepresentable0 f a)
forall a b.
(a -> b -> Ordering)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Ordering
forall (f :: * -> *). Ord1 f => Eq1 (UnpackRepresentable0 f)
forall (f :: * -> *) a.
(Ord1 f, Ord a) =>
Ord (UnpackRepresentable0 f a)
forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Ordering
forall (f :: * -> *).
(Eq1 f, forall a. Ord a => Ord (f a)) =>
(forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
$cliftCompare :: forall (f :: * -> *) a b.
Ord1 f =>
(a -> b -> Ordering)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Ordering
liftCompare :: forall a b.
(a -> b -> Ordering)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b -> Ordering
Ord1, (forall a. Show a => Show (UnpackRepresentable0 f a)) =>
(forall a.
 (Int -> a -> ShowS)
 -> ([a] -> ShowS) -> Int -> UnpackRepresentable0 f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [UnpackRepresentable0 f a] -> ShowS)
-> Show1 (UnpackRepresentable0 f)
forall a. Show a => Show (UnpackRepresentable0 f a)
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> UnpackRepresentable0 f a -> ShowS
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [UnpackRepresentable0 f a] -> ShowS
forall (f :: * -> *) a.
(Show1 f, Show a) =>
Show (UnpackRepresentable0 f a)
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> UnpackRepresentable0 f a -> ShowS
forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [UnpackRepresentable0 f a] -> ShowS
forall (f :: * -> *).
(forall a. Show a => Show (f a)) =>
(forall a.
 (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS)
-> Show1 f
$cliftShowsPrec :: forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> UnpackRepresentable0 f a -> ShowS
liftShowsPrec :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> UnpackRepresentable0 f a -> ShowS
$cliftShowList :: forall (f :: * -> *) a.
Show1 f =>
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [UnpackRepresentable0 f a] -> ShowS
liftShowList :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [UnpackRepresentable0 f a] -> ShowS
Show1, (forall a. Read a => Read (UnpackRepresentable0 f a)) =>
(forall a.
 (Int -> ReadS a)
 -> ReadS [a] -> Int -> ReadS (UnpackRepresentable0 f a))
-> (forall a.
    (Int -> ReadS a) -> ReadS [a] -> ReadS [UnpackRepresentable0 f a])
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec (UnpackRepresentable0 f a))
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec [UnpackRepresentable0 f a])
-> Read1 (UnpackRepresentable0 f)
forall a. Read a => Read (UnpackRepresentable0 f a)
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [UnpackRepresentable0 f a]
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (UnpackRepresentable0 f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> Int -> ReadS (UnpackRepresentable0 f a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [UnpackRepresentable0 f a]
forall (f :: * -> *) a.
(Read1 f, Read a) =>
Read (UnpackRepresentable0 f a)
forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec [UnpackRepresentable0 f a]
forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec (UnpackRepresentable0 f a)
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a)
-> ReadS [a] -> Int -> ReadS (UnpackRepresentable0 f a)
forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> ReadS [UnpackRepresentable0 f a]
forall (f :: * -> *).
(forall a. Read a => Read (f a)) =>
(forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a))
-> (forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [f a])
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (f a))
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [f a])
-> Read1 f
$cliftReadsPrec :: forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a)
-> ReadS [a] -> Int -> ReadS (UnpackRepresentable0 f a)
liftReadsPrec :: forall a.
(Int -> ReadS a)
-> ReadS [a] -> Int -> ReadS (UnpackRepresentable0 f a)
$cliftReadList :: forall (f :: * -> *) a.
Read1 f =>
(Int -> ReadS a) -> ReadS [a] -> ReadS [UnpackRepresentable0 f a]
liftReadList :: forall a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [UnpackRepresentable0 f a]
$cliftReadPrec :: forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec (UnpackRepresentable0 f a)
liftReadPrec :: forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (UnpackRepresentable0 f a)
$cliftReadListPrec :: forall (f :: * -> *) a.
Read1 f =>
ReadPrec a -> ReadPrec [a] -> ReadPrec [UnpackRepresentable0 f a]
liftReadListPrec :: forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [UnpackRepresentable0 f a]
Read1, NonEmpty (UnpackRepresentable0 f a) -> UnpackRepresentable0 f a
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
(UnpackRepresentable0 f a
 -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a)
-> (NonEmpty (UnpackRepresentable0 f a)
    -> UnpackRepresentable0 f a)
-> (forall b.
    Integral b =>
    b -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a)
-> Semigroup (UnpackRepresentable0 f a)
forall b.
Integral b =>
b -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
NonEmpty (UnpackRepresentable0 f a) -> UnpackRepresentable0 f a
forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
forall k (f :: k -> *) (a :: k) b.
(Semigroup (f a), Integral b) =>
b -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
$c<> :: forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
<> :: UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
$csconcat :: forall k (f :: k -> *) (a :: k).
Semigroup (f a) =>
NonEmpty (UnpackRepresentable0 f a) -> UnpackRepresentable0 f a
sconcat :: NonEmpty (UnpackRepresentable0 f a) -> UnpackRepresentable0 f a
$cstimes :: forall k (f :: k -> *) (a :: k) b.
(Semigroup (f a), Integral b) =>
b -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
stimes :: forall b.
Integral b =>
b -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
Semigroup, Semigroup (UnpackRepresentable0 f a)
UnpackRepresentable0 f a
Semigroup (UnpackRepresentable0 f a) =>
UnpackRepresentable0 f a
-> (UnpackRepresentable0 f a
    -> UnpackRepresentable0 f a -> UnpackRepresentable0 f a)
-> ([UnpackRepresentable0 f a] -> UnpackRepresentable0 f a)
-> Monoid (UnpackRepresentable0 f a)
[UnpackRepresentable0 f a] -> UnpackRepresentable0 f a
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
Semigroup (UnpackRepresentable0 f a)
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
UnpackRepresentable0 f a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
[UnpackRepresentable0 f a] -> UnpackRepresentable0 f a
forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
$cmempty :: forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
UnpackRepresentable0 f a
mempty :: UnpackRepresentable0 f a
$cmappend :: forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
mappend :: UnpackRepresentable0 f a
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f a
$cmconcat :: forall k (f :: k -> *) (a :: k).
Monoid (f a) =>
[UnpackRepresentable0 f a] -> UnpackRepresentable0 f a
mconcat :: [UnpackRepresentable0 f a] -> UnpackRepresentable0 f a
Monoid)
  deriving newtype ((forall m. Monoid m => UnpackRepresentable0 f m -> m)
-> (forall m a.
    Monoid m =>
    (a -> m) -> UnpackRepresentable0 f a -> m)
-> (forall m a.
    Monoid m =>
    (a -> m) -> UnpackRepresentable0 f a -> m)
-> (forall a b.
    (a -> b -> b) -> b -> UnpackRepresentable0 f a -> b)
-> (forall a b.
    (a -> b -> b) -> b -> UnpackRepresentable0 f a -> b)
-> (forall b a.
    (b -> a -> b) -> b -> UnpackRepresentable0 f a -> b)
-> (forall b a.
    (b -> a -> b) -> b -> UnpackRepresentable0 f a -> b)
-> (forall a. (a -> a -> a) -> UnpackRepresentable0 f a -> a)
-> (forall a. (a -> a -> a) -> UnpackRepresentable0 f a -> a)
-> (forall a. UnpackRepresentable0 f a -> [a])
-> (forall a. UnpackRepresentable0 f a -> Bool)
-> (forall a. UnpackRepresentable0 f a -> Int)
-> (forall a. Eq a => a -> UnpackRepresentable0 f a -> Bool)
-> (forall a. Ord a => UnpackRepresentable0 f a -> a)
-> (forall a. Ord a => UnpackRepresentable0 f a -> a)
-> (forall a. Num a => UnpackRepresentable0 f a -> a)
-> (forall a. Num a => UnpackRepresentable0 f a -> a)
-> Foldable (UnpackRepresentable0 f)
forall a. Eq a => a -> UnpackRepresentable0 f a -> Bool
forall a. Num a => UnpackRepresentable0 f a -> a
forall a. Ord a => UnpackRepresentable0 f a -> a
forall m. Monoid m => UnpackRepresentable0 f m -> m
forall a. UnpackRepresentable0 f a -> Bool
forall a. UnpackRepresentable0 f a -> Int
forall a. UnpackRepresentable0 f a -> [a]
forall a. (a -> a -> a) -> UnpackRepresentable0 f a -> a
forall m a. Monoid m => (a -> m) -> UnpackRepresentable0 f a -> m
forall b a. (b -> a -> b) -> b -> UnpackRepresentable0 f a -> b
forall a b. (a -> b -> b) -> b -> UnpackRepresentable0 f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> UnpackRepresentable0 f a -> Bool
forall (f :: * -> *) a.
(Foldable f, Num a) =>
UnpackRepresentable0 f a -> a
forall (f :: * -> *) a.
(Foldable f, Ord a) =>
UnpackRepresentable0 f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
UnpackRepresentable0 f m -> m
forall (f :: * -> *) a.
Foldable f =>
UnpackRepresentable0 f a -> Bool
forall (f :: * -> *) a.
Foldable f =>
UnpackRepresentable0 f a -> Int
forall (f :: * -> *) a.
Foldable f =>
UnpackRepresentable0 f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> UnpackRepresentable0 f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> UnpackRepresentable0 f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> UnpackRepresentable0 f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> UnpackRepresentable0 f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
UnpackRepresentable0 f m -> m
fold :: forall m. Monoid m => UnpackRepresentable0 f m -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> UnpackRepresentable0 f a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> UnpackRepresentable0 f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> UnpackRepresentable0 f a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> UnpackRepresentable0 f a -> m
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> UnpackRepresentable0 f a -> b
foldr :: forall a b. (a -> b -> b) -> b -> UnpackRepresentable0 f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> UnpackRepresentable0 f a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> UnpackRepresentable0 f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> UnpackRepresentable0 f a -> b
foldl :: forall b a. (b -> a -> b) -> b -> UnpackRepresentable0 f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> UnpackRepresentable0 f a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> UnpackRepresentable0 f a -> b
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> UnpackRepresentable0 f a -> a
foldr1 :: forall a. (a -> a -> a) -> UnpackRepresentable0 f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> UnpackRepresentable0 f a -> a
foldl1 :: forall a. (a -> a -> a) -> UnpackRepresentable0 f a -> a
$ctoList :: forall (f :: * -> *) a.
Foldable f =>
UnpackRepresentable0 f a -> [a]
toList :: forall a. UnpackRepresentable0 f a -> [a]
$cnull :: forall (f :: * -> *) a.
Foldable f =>
UnpackRepresentable0 f a -> Bool
null :: forall a. UnpackRepresentable0 f a -> Bool
$clength :: forall (f :: * -> *) a.
Foldable f =>
UnpackRepresentable0 f a -> Int
length :: forall a. UnpackRepresentable0 f a -> Int
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> UnpackRepresentable0 f a -> Bool
elem :: forall a. Eq a => a -> UnpackRepresentable0 f a -> Bool
$cmaximum :: forall (f :: * -> *) a.
(Foldable f, Ord a) =>
UnpackRepresentable0 f a -> a
maximum :: forall a. Ord a => UnpackRepresentable0 f a -> a
$cminimum :: forall (f :: * -> *) a.
(Foldable f, Ord a) =>
UnpackRepresentable0 f a -> a
minimum :: forall a. Ord a => UnpackRepresentable0 f a -> a
$csum :: forall (f :: * -> *) a.
(Foldable f, Num a) =>
UnpackRepresentable0 f a -> a
sum :: forall a. Num a => UnpackRepresentable0 f a -> a
$cproduct :: forall (f :: * -> *) a.
(Foldable f, Num a) =>
UnpackRepresentable0 f a -> a
product :: forall a. Num a => UnpackRepresentable0 f a -> a
Foldable, Foldable (UnpackRepresentable0 f)
Foldable (UnpackRepresentable0 f) =>
(forall m. Semigroup m => UnpackRepresentable0 f m -> m)
-> (forall m a.
    Semigroup m =>
    (a -> m) -> UnpackRepresentable0 f a -> m)
-> (forall m a.
    Semigroup m =>
    (a -> m) -> UnpackRepresentable0 f a -> m)
-> (forall a. UnpackRepresentable0 f a -> NonEmpty a)
-> (forall a. Ord a => UnpackRepresentable0 f a -> a)
-> (forall a. Ord a => UnpackRepresentable0 f a -> a)
-> (forall a. UnpackRepresentable0 f a -> a)
-> (forall a. UnpackRepresentable0 f a -> a)
-> (forall a b.
    (a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b)
-> (forall a b.
    (a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b)
-> (forall a b.
    (a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b)
-> (forall a b.
    (a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b)
-> Foldable1 (UnpackRepresentable0 f)
forall a. Ord a => UnpackRepresentable0 f a -> a
forall m. Semigroup m => UnpackRepresentable0 f m -> m
forall a. UnpackRepresentable0 f a -> a
forall a. UnpackRepresentable0 f a -> NonEmpty a
forall m a.
Semigroup m =>
(a -> m) -> UnpackRepresentable0 f a -> m
forall a b.
(a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b
forall a b.
(a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b
forall (t :: * -> *).
Foldable t =>
(forall m. Semigroup m => t m -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall m a. Semigroup m => (a -> m) -> t a -> m)
-> (forall a. t a -> NonEmpty a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. t a -> a)
-> (forall a. t a -> a)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (b -> a -> b) -> t a -> b)
-> (forall a b. (a -> b) -> (a -> b -> b) -> t a -> b)
-> Foldable1 t
forall (f :: * -> *).
Foldable1 f =>
Foldable (UnpackRepresentable0 f)
forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
UnpackRepresentable0 f a -> a
forall (f :: * -> *) m.
(Foldable1 f, Semigroup m) =>
UnpackRepresentable0 f m -> m
forall (f :: * -> *) a.
Foldable1 f =>
UnpackRepresentable0 f a -> a
forall (f :: * -> *) a.
Foldable1 f =>
UnpackRepresentable0 f a -> NonEmpty a
forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> UnpackRepresentable0 f a -> m
forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b
forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b
$cfold1 :: forall (f :: * -> *) m.
(Foldable1 f, Semigroup m) =>
UnpackRepresentable0 f m -> m
fold1 :: forall m. Semigroup m => UnpackRepresentable0 f m -> m
$cfoldMap1 :: forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> UnpackRepresentable0 f a -> m
foldMap1 :: forall m a.
Semigroup m =>
(a -> m) -> UnpackRepresentable0 f a -> m
$cfoldMap1' :: forall (f :: * -> *) m a.
(Foldable1 f, Semigroup m) =>
(a -> m) -> UnpackRepresentable0 f a -> m
foldMap1' :: forall m a.
Semigroup m =>
(a -> m) -> UnpackRepresentable0 f a -> m
$ctoNonEmpty :: forall (f :: * -> *) a.
Foldable1 f =>
UnpackRepresentable0 f a -> NonEmpty a
toNonEmpty :: forall a. UnpackRepresentable0 f a -> NonEmpty a
$cmaximum :: forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
UnpackRepresentable0 f a -> a
maximum :: forall a. Ord a => UnpackRepresentable0 f a -> a
$cminimum :: forall (f :: * -> *) a.
(Foldable1 f, Ord a) =>
UnpackRepresentable0 f a -> a
minimum :: forall a. Ord a => UnpackRepresentable0 f a -> a
$chead :: forall (f :: * -> *) a.
Foldable1 f =>
UnpackRepresentable0 f a -> a
head :: forall a. UnpackRepresentable0 f a -> a
$clast :: forall (f :: * -> *) a.
Foldable1 f =>
UnpackRepresentable0 f a -> a
last :: forall a. UnpackRepresentable0 f a -> a
$cfoldrMap1 :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b
foldrMap1 :: forall a b.
(a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b
$cfoldlMap1' :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b
foldlMap1' :: forall a b.
(a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b
$cfoldlMap1 :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b
foldlMap1 :: forall a b.
(a -> b) -> (b -> a -> b) -> UnpackRepresentable0 f a -> b
$cfoldrMap1' :: forall (f :: * -> *) a b.
Foldable1 f =>
(a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b
foldrMap1' :: forall a b.
(a -> b) -> (a -> b -> b) -> UnpackRepresentable0 f a -> b
Foldable1, Functor (UnpackRepresentable0 f)
Functor (UnpackRepresentable0 f) =>
(forall a. a -> UnpackRepresentable0 f a)
-> (forall a b.
    UnpackRepresentable0 f (a -> b)
    -> UnpackRepresentable0 f a -> UnpackRepresentable0 f b)
-> (forall a b c.
    (a -> b -> c)
    -> UnpackRepresentable0 f a
    -> UnpackRepresentable0 f b
    -> UnpackRepresentable0 f c)
-> (forall a b.
    UnpackRepresentable0 f a
    -> UnpackRepresentable0 f b -> UnpackRepresentable0 f b)
-> (forall a b.
    UnpackRepresentable0 f a
    -> UnpackRepresentable0 f b -> UnpackRepresentable0 f a)
-> Applicative (UnpackRepresentable0 f)
forall a. a -> UnpackRepresentable0 f a
forall a b.
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
forall a b.
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
forall a b.
UnpackRepresentable0 f (a -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
forall a b c.
(a -> b -> c)
-> UnpackRepresentable0 f a
-> UnpackRepresentable0 f b
-> UnpackRepresentable0 f 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
forall (f :: * -> *).
Applicative f =>
Functor (UnpackRepresentable0 f)
forall (f :: * -> *) a.
Applicative f =>
a -> UnpackRepresentable0 f a
forall (f :: * -> *) a b.
Applicative f =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
forall (f :: * -> *) a b.
Applicative f =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
forall (f :: * -> *) a b.
Applicative f =>
UnpackRepresentable0 f (a -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> UnpackRepresentable0 f a
-> UnpackRepresentable0 f b
-> UnpackRepresentable0 f c
$cpure :: forall (f :: * -> *) a.
Applicative f =>
a -> UnpackRepresentable0 f a
pure :: forall a. a -> UnpackRepresentable0 f a
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
UnpackRepresentable0 f (a -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
<*> :: forall a b.
UnpackRepresentable0 f (a -> b)
-> UnpackRepresentable0 f a -> UnpackRepresentable0 f b
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> UnpackRepresentable0 f a
-> UnpackRepresentable0 f b
-> UnpackRepresentable0 f c
liftA2 :: forall a b c.
(a -> b -> c)
-> UnpackRepresentable0 f a
-> UnpackRepresentable0 f b
-> UnpackRepresentable0 f c
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
*> :: forall a b.
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
<* :: forall a b.
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f a
Applicative, Applicative (UnpackRepresentable0 f)
Applicative (UnpackRepresentable0 f) =>
(forall a b.
 UnpackRepresentable0 f a
 -> (a -> UnpackRepresentable0 f b) -> UnpackRepresentable0 f b)
-> (forall a b.
    UnpackRepresentable0 f a
    -> UnpackRepresentable0 f b -> UnpackRepresentable0 f b)
-> (forall a. a -> UnpackRepresentable0 f a)
-> Monad (UnpackRepresentable0 f)
forall a. a -> UnpackRepresentable0 f a
forall a b.
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
forall a b.
UnpackRepresentable0 f a
-> (a -> UnpackRepresentable0 f b) -> UnpackRepresentable0 f b
forall (f :: * -> *).
Monad f =>
Applicative (UnpackRepresentable0 f)
forall (f :: * -> *) a. Monad f => a -> UnpackRepresentable0 f a
forall (f :: * -> *) a b.
Monad f =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
forall (f :: * -> *) a b.
Monad f =>
UnpackRepresentable0 f a
-> (a -> UnpackRepresentable0 f b) -> UnpackRepresentable0 f b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall (f :: * -> *) a b.
Monad f =>
UnpackRepresentable0 f a
-> (a -> UnpackRepresentable0 f b) -> UnpackRepresentable0 f b
>>= :: forall a b.
UnpackRepresentable0 f a
-> (a -> UnpackRepresentable0 f b) -> UnpackRepresentable0 f b
$c>> :: forall (f :: * -> *) a b.
Monad f =>
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
>> :: forall a b.
UnpackRepresentable0 f a
-> UnpackRepresentable0 f b -> UnpackRepresentable0 f b
$creturn :: forall (f :: * -> *) a. Monad f => a -> UnpackRepresentable0 f a
return :: forall a. a -> UnpackRepresentable0 f a
Monad)

-- | @'sequenceA' ('tabulate' ('const' 'unpack'))@
instance
  (Unpack a, Representable f, Traversable f) =>
  Unpack (UnpackRepresentable0 f a)
  where
  unpack :: forall (st :: ZeroBitType) r.
Parser st r (UnpackRepresentable0 f a)
unpack = f a -> UnpackRepresentable0 f a
forall {k} (f :: k -> *) (a :: k). f a -> UnpackRepresentable0 f a
UnpackRepresentable0 (f a -> UnpackRepresentable0 f a)
-> ParserT st r ParseError (f a)
-> ParserT st r ParseError (UnpackRepresentable0 f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (ParserT st r ParseError a) -> ParserT st r ParseError (f a)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => f (f a) -> f (f a)
sequenceA ((Rep f -> ParserT st r ParseError a)
-> f (ParserT st r ParseError a)
forall a. (Rep f -> a) -> f a
forall (f :: * -> *) a. Representable f => (Rep f -> a) -> f a
tabulate (ParserT st r ParseError a -> Rep f -> ParserT st r ParseError a
forall a b. a -> b -> a
const ParserT st r ParseError a
forall (st :: ZeroBitType) r. Parser st r a
forall a (st :: ZeroBitType) r. Unpack a => Parser st r a
unpack))
  {-# INLINEABLE unpack #-}