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

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

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

import GHC.TypeLits

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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