-- | Indicate that something is `Consistent`.
module NewtypeZoo.Consistent
  ( Consistent(Consistent)
  , _theConsistent
  , theConsistent
  , ConsistentTo(ConsistentTo)
  , _theConsistentTo
  , theConsistentTo
  ) where

import           Control.Comonad (Comonad)
import           Control.DeepSeq (NFData)
import           Control.Monad.Fix (MonadFix)
import           Control.Monad.Zip (MonadZip)
import           Data.Bits       (Bits,FiniteBits)
import           Data.Copointed  (Copointed)
import           Data.Default    (Default)
import           Data.Functor.Classes (Eq1, Ord1, Read1, Show1)
import           Data.Functor.Identity
import           Data.Ix         (Ix)
import           Data.Profunctor (Profunctor, dimap)
import           Data.Pointed    (Pointed)
import           Data.String     (IsString)
import           Data.Typeable   (Typeable)
import           Foreign.Storable (Storable)
import           GHC.Generics    (Generic, Generic1)
import           System.Random   (Random)
import           Test.QuickCheck (Arbitrary)

-- | A wrapper for something that is `Consistent`.
newtype Consistent a = Consistent a
  deriving ( Consistent a -> Consistent a -> Bool
(Consistent a -> Consistent a -> Bool)
-> (Consistent a -> Consistent a -> Bool) -> Eq (Consistent a)
forall a. Eq a => Consistent a -> Consistent a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Consistent a -> Consistent a -> Bool
$c/= :: forall a. Eq a => Consistent a -> Consistent a -> Bool
== :: Consistent a -> Consistent a -> Bool
$c== :: forall a. Eq a => Consistent a -> Consistent a -> Bool
Eq
           , Eq (Consistent a)
Eq (Consistent a)
-> (Consistent a -> Consistent a -> Ordering)
-> (Consistent a -> Consistent a -> Bool)
-> (Consistent a -> Consistent a -> Bool)
-> (Consistent a -> Consistent a -> Bool)
-> (Consistent a -> Consistent a -> Bool)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> Ord (Consistent a)
Consistent a -> Consistent a -> Bool
Consistent a -> Consistent a -> Ordering
Consistent a -> Consistent a -> Consistent 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 (Consistent a)
forall a. Ord a => Consistent a -> Consistent a -> Bool
forall a. Ord a => Consistent a -> Consistent a -> Ordering
forall a. Ord a => Consistent a -> Consistent a -> Consistent a
min :: Consistent a -> Consistent a -> Consistent a
$cmin :: forall a. Ord a => Consistent a -> Consistent a -> Consistent a
max :: Consistent a -> Consistent a -> Consistent a
$cmax :: forall a. Ord a => Consistent a -> Consistent a -> Consistent a
>= :: Consistent a -> Consistent a -> Bool
$c>= :: forall a. Ord a => Consistent a -> Consistent a -> Bool
> :: Consistent a -> Consistent a -> Bool
$c> :: forall a. Ord a => Consistent a -> Consistent a -> Bool
<= :: Consistent a -> Consistent a -> Bool
$c<= :: forall a. Ord a => Consistent a -> Consistent a -> Bool
< :: Consistent a -> Consistent a -> Bool
$c< :: forall a. Ord a => Consistent a -> Consistent a -> Bool
compare :: Consistent a -> Consistent a -> Ordering
$ccompare :: forall a. Ord a => Consistent a -> Consistent a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Consistent a)
Ord
           , ReadPrec [Consistent a]
ReadPrec (Consistent a)
Int -> ReadS (Consistent a)
ReadS [Consistent a]
(Int -> ReadS (Consistent a))
-> ReadS [Consistent a]
-> ReadPrec (Consistent a)
-> ReadPrec [Consistent a]
-> Read (Consistent a)
forall a. Read a => ReadPrec [Consistent a]
forall a. Read a => ReadPrec (Consistent a)
forall a. Read a => Int -> ReadS (Consistent a)
forall a. Read a => ReadS [Consistent a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Consistent a]
$creadListPrec :: forall a. Read a => ReadPrec [Consistent a]
readPrec :: ReadPrec (Consistent a)
$creadPrec :: forall a. Read a => ReadPrec (Consistent a)
readList :: ReadS [Consistent a]
$creadList :: forall a. Read a => ReadS [Consistent a]
readsPrec :: Int -> ReadS (Consistent a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Consistent a)
Read
           , Int -> Consistent a -> ShowS
[Consistent a] -> ShowS
Consistent a -> String
(Int -> Consistent a -> ShowS)
-> (Consistent a -> String)
-> ([Consistent a] -> ShowS)
-> Show (Consistent a)
forall a. Show a => Int -> Consistent a -> ShowS
forall a. Show a => [Consistent a] -> ShowS
forall a. Show a => Consistent a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Consistent a] -> ShowS
$cshowList :: forall a. Show a => [Consistent a] -> ShowS
show :: Consistent a -> String
$cshow :: forall a. Show a => Consistent a -> String
showsPrec :: Int -> Consistent a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Consistent a -> ShowS
Show
           , Consistent a -> ()
(Consistent a -> ()) -> NFData (Consistent a)
forall a. NFData a => Consistent a -> ()
forall a. (a -> ()) -> NFData a
rnf :: Consistent a -> ()
$crnf :: forall a. NFData a => Consistent a -> ()
NFData
           , Consistent a -> Bool
(a -> m) -> Consistent a -> m
(a -> b -> b) -> b -> Consistent a -> b
(forall m. Monoid m => Consistent m -> m)
-> (forall m a. Monoid m => (a -> m) -> Consistent a -> m)
-> (forall m a. Monoid m => (a -> m) -> Consistent a -> m)
-> (forall a b. (a -> b -> b) -> b -> Consistent a -> b)
-> (forall a b. (a -> b -> b) -> b -> Consistent a -> b)
-> (forall b a. (b -> a -> b) -> b -> Consistent a -> b)
-> (forall b a. (b -> a -> b) -> b -> Consistent a -> b)
-> (forall a. (a -> a -> a) -> Consistent a -> a)
-> (forall a. (a -> a -> a) -> Consistent a -> a)
-> (forall a. Consistent a -> [a])
-> (forall a. Consistent a -> Bool)
-> (forall a. Consistent a -> Int)
-> (forall a. Eq a => a -> Consistent a -> Bool)
-> (forall a. Ord a => Consistent a -> a)
-> (forall a. Ord a => Consistent a -> a)
-> (forall a. Num a => Consistent a -> a)
-> (forall a. Num a => Consistent a -> a)
-> Foldable Consistent
forall a. Eq a => a -> Consistent a -> Bool
forall a. Num a => Consistent a -> a
forall a. Ord a => Consistent a -> a
forall m. Monoid m => Consistent m -> m
forall a. Consistent a -> Bool
forall a. Consistent a -> Int
forall a. Consistent a -> [a]
forall a. (a -> a -> a) -> Consistent a -> a
forall m a. Monoid m => (a -> m) -> Consistent a -> m
forall b a. (b -> a -> b) -> b -> Consistent a -> b
forall a b. (a -> b -> b) -> b -> Consistent 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 :: Consistent a -> a
$cproduct :: forall a. Num a => Consistent a -> a
sum :: Consistent a -> a
$csum :: forall a. Num a => Consistent a -> a
minimum :: Consistent a -> a
$cminimum :: forall a. Ord a => Consistent a -> a
maximum :: Consistent a -> a
$cmaximum :: forall a. Ord a => Consistent a -> a
elem :: a -> Consistent a -> Bool
$celem :: forall a. Eq a => a -> Consistent a -> Bool
length :: Consistent a -> Int
$clength :: forall a. Consistent a -> Int
null :: Consistent a -> Bool
$cnull :: forall a. Consistent a -> Bool
toList :: Consistent a -> [a]
$ctoList :: forall a. Consistent a -> [a]
foldl1 :: (a -> a -> a) -> Consistent a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Consistent a -> a
foldr1 :: (a -> a -> a) -> Consistent a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Consistent a -> a
foldl' :: (b -> a -> b) -> b -> Consistent a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Consistent a -> b
foldl :: (b -> a -> b) -> b -> Consistent a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Consistent a -> b
foldr' :: (a -> b -> b) -> b -> Consistent a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Consistent a -> b
foldr :: (a -> b -> b) -> b -> Consistent a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Consistent a -> b
foldMap' :: (a -> m) -> Consistent a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Consistent a -> m
foldMap :: (a -> m) -> Consistent a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Consistent a -> m
fold :: Consistent m -> m
$cfold :: forall m. Monoid m => Consistent m -> m
Foldable
           , Functor Consistent
Foldable Consistent
Functor Consistent
-> Foldable Consistent
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Consistent a -> f (Consistent b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Consistent (f a) -> f (Consistent a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Consistent a -> m (Consistent b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Consistent (m a) -> m (Consistent a))
-> Traversable Consistent
(a -> f b) -> Consistent a -> f (Consistent 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 =>
Consistent (m a) -> m (Consistent a)
forall (f :: * -> *) a.
Applicative f =>
Consistent (f a) -> f (Consistent a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Consistent a -> m (Consistent b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Consistent a -> f (Consistent b)
sequence :: Consistent (m a) -> m (Consistent a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Consistent (m a) -> m (Consistent a)
mapM :: (a -> m b) -> Consistent a -> m (Consistent b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Consistent a -> m (Consistent b)
sequenceA :: Consistent (f a) -> f (Consistent a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Consistent (f a) -> f (Consistent a)
traverse :: (a -> f b) -> Consistent a -> f (Consistent b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Consistent a -> f (Consistent b)
$cp2Traversable :: Foldable Consistent
$cp1Traversable :: Functor Consistent
Traversable
           , a -> Consistent b -> Consistent a
(a -> b) -> Consistent a -> Consistent b
(forall a b. (a -> b) -> Consistent a -> Consistent b)
-> (forall a b. a -> Consistent b -> Consistent a)
-> Functor Consistent
forall a b. a -> Consistent b -> Consistent a
forall a b. (a -> b) -> Consistent a -> Consistent b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Consistent b -> Consistent a
$c<$ :: forall a b. a -> Consistent b -> Consistent a
fmap :: (a -> b) -> Consistent a -> Consistent b
$cfmap :: forall a b. (a -> b) -> Consistent a -> Consistent b
Functor
           , Consistent a
Consistent a -> Default (Consistent a)
forall a. a -> Default a
forall a. Default a => Consistent a
def :: Consistent a
$cdef :: forall a. Default a => Consistent a
Default
           , Semigroup (Consistent a)
Consistent a
Semigroup (Consistent a)
-> Consistent a
-> (Consistent a -> Consistent a -> Consistent a)
-> ([Consistent a] -> Consistent a)
-> Monoid (Consistent a)
[Consistent a] -> Consistent a
Consistent a -> Consistent a -> Consistent a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (Consistent a)
forall a. Monoid a => Consistent a
forall a. Monoid a => [Consistent a] -> Consistent a
forall a. Monoid a => Consistent a -> Consistent a -> Consistent a
mconcat :: [Consistent a] -> Consistent a
$cmconcat :: forall a. Monoid a => [Consistent a] -> Consistent a
mappend :: Consistent a -> Consistent a -> Consistent a
$cmappend :: forall a. Monoid a => Consistent a -> Consistent a -> Consistent a
mempty :: Consistent a
$cmempty :: forall a. Monoid a => Consistent a
$cp1Monoid :: forall a. Monoid a => Semigroup (Consistent a)
Monoid
           , b -> Consistent a -> Consistent a
NonEmpty (Consistent a) -> Consistent a
Consistent a -> Consistent a -> Consistent a
(Consistent a -> Consistent a -> Consistent a)
-> (NonEmpty (Consistent a) -> Consistent a)
-> (forall b. Integral b => b -> Consistent a -> Consistent a)
-> Semigroup (Consistent a)
forall b. Integral b => b -> Consistent a -> Consistent a
forall a. Semigroup a => NonEmpty (Consistent a) -> Consistent a
forall a.
Semigroup a =>
Consistent a -> Consistent a -> Consistent a
forall a b.
(Semigroup a, Integral b) =>
b -> Consistent a -> Consistent a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Consistent a -> Consistent a
$cstimes :: forall a b.
(Semigroup a, Integral b) =>
b -> Consistent a -> Consistent a
sconcat :: NonEmpty (Consistent a) -> Consistent a
$csconcat :: forall a. Semigroup a => NonEmpty (Consistent a) -> Consistent a
<> :: Consistent a -> Consistent a -> Consistent a
$c<> :: forall a.
Semigroup a =>
Consistent a -> Consistent a -> Consistent a
Semigroup
           , Typeable
           , (forall x. Consistent a -> Rep (Consistent a) x)
-> (forall x. Rep (Consistent a) x -> Consistent a)
-> Generic (Consistent a)
forall x. Rep (Consistent a) x -> Consistent a
forall x. Consistent a -> Rep (Consistent a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Consistent a) x -> Consistent a
forall a x. Consistent a -> Rep (Consistent a) x
$cto :: forall a x. Rep (Consistent a) x -> Consistent a
$cfrom :: forall a x. Consistent a -> Rep (Consistent a) x
Generic
           , (forall a. Consistent a -> Rep1 Consistent a)
-> (forall a. Rep1 Consistent a -> Consistent a)
-> Generic1 Consistent
forall a. Rep1 Consistent a -> Consistent a
forall a. Consistent a -> Rep1 Consistent a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall a. Rep1 Consistent a -> Consistent a
$cfrom1 :: forall a. Consistent a -> Rep1 Consistent a
Generic1
           , g -> (Consistent a, g)
g -> [Consistent a]
(Consistent a, Consistent a) -> g -> (Consistent a, g)
(Consistent a, Consistent a) -> g -> [Consistent a]
(forall g.
 RandomGen g =>
 (Consistent a, Consistent a) -> g -> (Consistent a, g))
-> (forall g. RandomGen g => g -> (Consistent a, g))
-> (forall g.
    RandomGen g =>
    (Consistent a, Consistent a) -> g -> [Consistent a])
-> (forall g. RandomGen g => g -> [Consistent a])
-> Random (Consistent a)
forall a g. (Random a, RandomGen g) => g -> [Consistent a]
forall a g. (Random a, RandomGen g) => g -> (Consistent a, g)
forall a g.
(Random a, RandomGen g) =>
(Consistent a, Consistent a) -> g -> [Consistent a]
forall a g.
(Random a, RandomGen g) =>
(Consistent a, Consistent a) -> g -> (Consistent a, g)
forall g. RandomGen g => g -> [Consistent a]
forall g. RandomGen g => g -> (Consistent a, g)
forall g.
RandomGen g =>
(Consistent a, Consistent a) -> g -> [Consistent a]
forall g.
RandomGen g =>
(Consistent a, Consistent a) -> g -> (Consistent a, g)
forall a.
(forall g. RandomGen g => (a, a) -> g -> (a, g))
-> (forall g. RandomGen g => g -> (a, g))
-> (forall g. RandomGen g => (a, a) -> g -> [a])
-> (forall g. RandomGen g => g -> [a])
-> Random a
randoms :: g -> [Consistent a]
$crandoms :: forall a g. (Random a, RandomGen g) => g -> [Consistent a]
randomRs :: (Consistent a, Consistent a) -> g -> [Consistent a]
$crandomRs :: forall a g.
(Random a, RandomGen g) =>
(Consistent a, Consistent a) -> g -> [Consistent a]
random :: g -> (Consistent a, g)
$crandom :: forall a g. (Random a, RandomGen g) => g -> (Consistent a, g)
randomR :: (Consistent a, Consistent a) -> g -> (Consistent a, g)
$crandomR :: forall a g.
(Random a, RandomGen g) =>
(Consistent a, Consistent a) -> g -> (Consistent a, g)
Random
           , Gen (Consistent a)
Gen (Consistent a)
-> (Consistent a -> [Consistent a]) -> Arbitrary (Consistent a)
Consistent a -> [Consistent a]
forall a. Arbitrary a => Gen (Consistent a)
forall a. Arbitrary a => Consistent a -> [Consistent a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
shrink :: Consistent a -> [Consistent a]
$cshrink :: forall a. Arbitrary a => Consistent a -> [Consistent a]
arbitrary :: Gen (Consistent a)
$carbitrary :: forall a. Arbitrary a => Gen (Consistent a)
Arbitrary
           , Consistent a
Consistent a -> Consistent a -> Bounded (Consistent a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Consistent a
maxBound :: Consistent a
$cmaxBound :: forall a. Bounded a => Consistent a
minBound :: Consistent a
$cminBound :: forall a. Bounded a => Consistent a
Bounded
           , Int -> Consistent a
Consistent a -> Int
Consistent a -> [Consistent a]
Consistent a -> Consistent a
Consistent a -> Consistent a -> [Consistent a]
Consistent a -> Consistent a -> Consistent a -> [Consistent a]
(Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Int -> Consistent a)
-> (Consistent a -> Int)
-> (Consistent a -> [Consistent a])
-> (Consistent a -> Consistent a -> [Consistent a])
-> (Consistent a -> Consistent a -> [Consistent a])
-> (Consistent a -> Consistent a -> Consistent a -> [Consistent a])
-> Enum (Consistent a)
forall a. Enum a => Int -> Consistent a
forall a. Enum a => Consistent a -> Int
forall a. Enum a => Consistent a -> [Consistent a]
forall a. Enum a => Consistent a -> Consistent a
forall a. Enum a => Consistent a -> Consistent a -> [Consistent a]
forall a.
Enum a =>
Consistent a -> Consistent a -> Consistent a -> [Consistent 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 :: Consistent a -> Consistent a -> Consistent a -> [Consistent a]
$cenumFromThenTo :: forall a.
Enum a =>
Consistent a -> Consistent a -> Consistent a -> [Consistent a]
enumFromTo :: Consistent a -> Consistent a -> [Consistent a]
$cenumFromTo :: forall a. Enum a => Consistent a -> Consistent a -> [Consistent a]
enumFromThen :: Consistent a -> Consistent a -> [Consistent a]
$cenumFromThen :: forall a. Enum a => Consistent a -> Consistent a -> [Consistent a]
enumFrom :: Consistent a -> [Consistent a]
$cenumFrom :: forall a. Enum a => Consistent a -> [Consistent a]
fromEnum :: Consistent a -> Int
$cfromEnum :: forall a. Enum a => Consistent a -> Int
toEnum :: Int -> Consistent a
$ctoEnum :: forall a. Enum a => Int -> Consistent a
pred :: Consistent a -> Consistent a
$cpred :: forall a. Enum a => Consistent a -> Consistent a
succ :: Consistent a -> Consistent a
$csucc :: forall a. Enum a => Consistent a -> Consistent a
Enum
           , Fractional (Consistent a)
Consistent a
Fractional (Consistent a)
-> Consistent a
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> Floating (Consistent a)
Consistent a -> Consistent a
Consistent a -> Consistent a -> Consistent a
forall a. Floating a => Fractional (Consistent a)
forall a. Floating a => Consistent a
forall a. Floating a => Consistent a -> Consistent a
forall a.
Floating a =>
Consistent a -> Consistent a -> Consistent 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 :: Consistent a -> Consistent a
$clog1mexp :: forall a. Floating a => Consistent a -> Consistent a
log1pexp :: Consistent a -> Consistent a
$clog1pexp :: forall a. Floating a => Consistent a -> Consistent a
expm1 :: Consistent a -> Consistent a
$cexpm1 :: forall a. Floating a => Consistent a -> Consistent a
log1p :: Consistent a -> Consistent a
$clog1p :: forall a. Floating a => Consistent a -> Consistent a
atanh :: Consistent a -> Consistent a
$catanh :: forall a. Floating a => Consistent a -> Consistent a
acosh :: Consistent a -> Consistent a
$cacosh :: forall a. Floating a => Consistent a -> Consistent a
asinh :: Consistent a -> Consistent a
$casinh :: forall a. Floating a => Consistent a -> Consistent a
tanh :: Consistent a -> Consistent a
$ctanh :: forall a. Floating a => Consistent a -> Consistent a
cosh :: Consistent a -> Consistent a
$ccosh :: forall a. Floating a => Consistent a -> Consistent a
sinh :: Consistent a -> Consistent a
$csinh :: forall a. Floating a => Consistent a -> Consistent a
atan :: Consistent a -> Consistent a
$catan :: forall a. Floating a => Consistent a -> Consistent a
acos :: Consistent a -> Consistent a
$cacos :: forall a. Floating a => Consistent a -> Consistent a
asin :: Consistent a -> Consistent a
$casin :: forall a. Floating a => Consistent a -> Consistent a
tan :: Consistent a -> Consistent a
$ctan :: forall a. Floating a => Consistent a -> Consistent a
cos :: Consistent a -> Consistent a
$ccos :: forall a. Floating a => Consistent a -> Consistent a
sin :: Consistent a -> Consistent a
$csin :: forall a. Floating a => Consistent a -> Consistent a
logBase :: Consistent a -> Consistent a -> Consistent a
$clogBase :: forall a.
Floating a =>
Consistent a -> Consistent a -> Consistent a
** :: Consistent a -> Consistent a -> Consistent a
$c** :: forall a.
Floating a =>
Consistent a -> Consistent a -> Consistent a
sqrt :: Consistent a -> Consistent a
$csqrt :: forall a. Floating a => Consistent a -> Consistent a
log :: Consistent a -> Consistent a
$clog :: forall a. Floating a => Consistent a -> Consistent a
exp :: Consistent a -> Consistent a
$cexp :: forall a. Floating a => Consistent a -> Consistent a
pi :: Consistent a
$cpi :: forall a. Floating a => Consistent a
$cp1Floating :: forall a. Floating a => Fractional (Consistent a)
Floating
           , Num (Consistent a)
Num (Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Rational -> Consistent a)
-> Fractional (Consistent a)
Rational -> Consistent a
Consistent a -> Consistent a
Consistent a -> Consistent a -> Consistent a
forall a. Fractional a => Num (Consistent a)
forall a. Fractional a => Rational -> Consistent a
forall a. Fractional a => Consistent a -> Consistent a
forall a.
Fractional a =>
Consistent a -> Consistent a -> Consistent a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Consistent a
$cfromRational :: forall a. Fractional a => Rational -> Consistent a
recip :: Consistent a -> Consistent a
$crecip :: forall a. Fractional a => Consistent a -> Consistent a
/ :: Consistent a -> Consistent a -> Consistent a
$c/ :: forall a.
Fractional a =>
Consistent a -> Consistent a -> Consistent a
$cp1Fractional :: forall a. Fractional a => Num (Consistent a)
Fractional
           , Enum (Consistent a)
Real (Consistent a)
Real (Consistent a)
-> Enum (Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> (Consistent a, Consistent a))
-> (Consistent a -> Consistent a -> (Consistent a, Consistent a))
-> (Consistent a -> Integer)
-> Integral (Consistent a)
Consistent a -> Integer
Consistent a -> Consistent a -> (Consistent a, Consistent a)
Consistent a -> Consistent a -> Consistent a
forall a. Integral a => Enum (Consistent a)
forall a. Integral a => Real (Consistent a)
forall a. Integral a => Consistent a -> Integer
forall a.
Integral a =>
Consistent a -> Consistent a -> (Consistent a, Consistent a)
forall a.
Integral a =>
Consistent a -> Consistent a -> Consistent 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 :: Consistent a -> Integer
$ctoInteger :: forall a. Integral a => Consistent a -> Integer
divMod :: Consistent a -> Consistent a -> (Consistent a, Consistent a)
$cdivMod :: forall a.
Integral a =>
Consistent a -> Consistent a -> (Consistent a, Consistent a)
quotRem :: Consistent a -> Consistent a -> (Consistent a, Consistent a)
$cquotRem :: forall a.
Integral a =>
Consistent a -> Consistent a -> (Consistent a, Consistent a)
mod :: Consistent a -> Consistent a -> Consistent a
$cmod :: forall a.
Integral a =>
Consistent a -> Consistent a -> Consistent a
div :: Consistent a -> Consistent a -> Consistent a
$cdiv :: forall a.
Integral a =>
Consistent a -> Consistent a -> Consistent a
rem :: Consistent a -> Consistent a -> Consistent a
$crem :: forall a.
Integral a =>
Consistent a -> Consistent a -> Consistent a
quot :: Consistent a -> Consistent a -> Consistent a
$cquot :: forall a.
Integral a =>
Consistent a -> Consistent a -> Consistent a
$cp2Integral :: forall a. Integral a => Enum (Consistent a)
$cp1Integral :: forall a. Integral a => Real (Consistent a)
Integral
           , Integer -> Consistent a
Consistent a -> Consistent a
Consistent a -> Consistent a -> Consistent a
(Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Integer -> Consistent a)
-> Num (Consistent a)
forall a. Num a => Integer -> Consistent a
forall a. Num a => Consistent a -> Consistent a
forall a. Num a => Consistent a -> Consistent a -> Consistent a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Consistent a
$cfromInteger :: forall a. Num a => Integer -> Consistent a
signum :: Consistent a -> Consistent a
$csignum :: forall a. Num a => Consistent a -> Consistent a
abs :: Consistent a -> Consistent a
$cabs :: forall a. Num a => Consistent a -> Consistent a
negate :: Consistent a -> Consistent a
$cnegate :: forall a. Num a => Consistent a -> Consistent a
* :: Consistent a -> Consistent a -> Consistent a
$c* :: forall a. Num a => Consistent a -> Consistent a -> Consistent a
- :: Consistent a -> Consistent a -> Consistent a
$c- :: forall a. Num a => Consistent a -> Consistent a -> Consistent a
+ :: Consistent a -> Consistent a -> Consistent a
$c+ :: forall a. Num a => Consistent a -> Consistent a -> Consistent a
Num
           , Num (Consistent a)
Ord (Consistent a)
Num (Consistent a)
-> Ord (Consistent a)
-> (Consistent a -> Rational)
-> Real (Consistent a)
Consistent a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall a. Real a => Num (Consistent a)
forall a. Real a => Ord (Consistent a)
forall a. Real a => Consistent a -> Rational
toRational :: Consistent a -> Rational
$ctoRational :: forall a. Real a => Consistent a -> Rational
$cp2Real :: forall a. Real a => Ord (Consistent a)
$cp1Real :: forall a. Real a => Num (Consistent a)
Real
           , Floating (Consistent a)
RealFrac (Consistent a)
RealFrac (Consistent a)
-> Floating (Consistent a)
-> (Consistent a -> Integer)
-> (Consistent a -> Int)
-> (Consistent a -> (Int, Int))
-> (Consistent a -> (Integer, Int))
-> (Integer -> Int -> Consistent a)
-> (Consistent a -> Int)
-> (Consistent a -> Consistent a)
-> (Int -> Consistent a -> Consistent a)
-> (Consistent a -> Bool)
-> (Consistent a -> Bool)
-> (Consistent a -> Bool)
-> (Consistent a -> Bool)
-> (Consistent a -> Bool)
-> (Consistent a -> Consistent a -> Consistent a)
-> RealFloat (Consistent a)
Int -> Consistent a -> Consistent a
Integer -> Int -> Consistent a
Consistent a -> Bool
Consistent a -> Int
Consistent a -> Integer
Consistent a -> (Int, Int)
Consistent a -> (Integer, Int)
Consistent a -> Consistent a
Consistent a -> Consistent a -> Consistent a
forall a. RealFloat a => Floating (Consistent a)
forall a. RealFloat a => RealFrac (Consistent a)
forall a. RealFloat a => Int -> Consistent a -> Consistent a
forall a. RealFloat a => Integer -> Int -> Consistent a
forall a. RealFloat a => Consistent a -> Bool
forall a. RealFloat a => Consistent a -> Int
forall a. RealFloat a => Consistent a -> Integer
forall a. RealFloat a => Consistent a -> (Int, Int)
forall a. RealFloat a => Consistent a -> (Integer, Int)
forall a. RealFloat a => Consistent a -> Consistent a
forall a.
RealFloat a =>
Consistent a -> Consistent a -> Consistent 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 :: Consistent a -> Consistent a -> Consistent a
$catan2 :: forall a.
RealFloat a =>
Consistent a -> Consistent a -> Consistent a
isIEEE :: Consistent a -> Bool
$cisIEEE :: forall a. RealFloat a => Consistent a -> Bool
isNegativeZero :: Consistent a -> Bool
$cisNegativeZero :: forall a. RealFloat a => Consistent a -> Bool
isDenormalized :: Consistent a -> Bool
$cisDenormalized :: forall a. RealFloat a => Consistent a -> Bool
isInfinite :: Consistent a -> Bool
$cisInfinite :: forall a. RealFloat a => Consistent a -> Bool
isNaN :: Consistent a -> Bool
$cisNaN :: forall a. RealFloat a => Consistent a -> Bool
scaleFloat :: Int -> Consistent a -> Consistent a
$cscaleFloat :: forall a. RealFloat a => Int -> Consistent a -> Consistent a
significand :: Consistent a -> Consistent a
$csignificand :: forall a. RealFloat a => Consistent a -> Consistent a
exponent :: Consistent a -> Int
$cexponent :: forall a. RealFloat a => Consistent a -> Int
encodeFloat :: Integer -> Int -> Consistent a
$cencodeFloat :: forall a. RealFloat a => Integer -> Int -> Consistent a
decodeFloat :: Consistent a -> (Integer, Int)
$cdecodeFloat :: forall a. RealFloat a => Consistent a -> (Integer, Int)
floatRange :: Consistent a -> (Int, Int)
$cfloatRange :: forall a. RealFloat a => Consistent a -> (Int, Int)
floatDigits :: Consistent a -> Int
$cfloatDigits :: forall a. RealFloat a => Consistent a -> Int
floatRadix :: Consistent a -> Integer
$cfloatRadix :: forall a. RealFloat a => Consistent a -> Integer
$cp2RealFloat :: forall a. RealFloat a => Floating (Consistent a)
$cp1RealFloat :: forall a. RealFloat a => RealFrac (Consistent a)
RealFloat
           , Fractional (Consistent a)
Real (Consistent a)
Real (Consistent a)
-> Fractional (Consistent a)
-> (forall b. Integral b => Consistent a -> (b, Consistent a))
-> (forall b. Integral b => Consistent a -> b)
-> (forall b. Integral b => Consistent a -> b)
-> (forall b. Integral b => Consistent a -> b)
-> (forall b. Integral b => Consistent a -> b)
-> RealFrac (Consistent a)
Consistent a -> b
Consistent a -> b
Consistent a -> b
Consistent a -> b
Consistent a -> (b, Consistent a)
forall b. Integral b => Consistent a -> b
forall b. Integral b => Consistent a -> (b, Consistent 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 (Consistent a)
forall a. RealFrac a => Real (Consistent a)
forall a b. (RealFrac a, Integral b) => Consistent a -> b
forall a b.
(RealFrac a, Integral b) =>
Consistent a -> (b, Consistent a)
floor :: Consistent a -> b
$cfloor :: forall a b. (RealFrac a, Integral b) => Consistent a -> b
ceiling :: Consistent a -> b
$cceiling :: forall a b. (RealFrac a, Integral b) => Consistent a -> b
round :: Consistent a -> b
$cround :: forall a b. (RealFrac a, Integral b) => Consistent a -> b
truncate :: Consistent a -> b
$ctruncate :: forall a b. (RealFrac a, Integral b) => Consistent a -> b
properFraction :: Consistent a -> (b, Consistent a)
$cproperFraction :: forall a b.
(RealFrac a, Integral b) =>
Consistent a -> (b, Consistent a)
$cp2RealFrac :: forall a. RealFrac a => Fractional (Consistent a)
$cp1RealFrac :: forall a. RealFrac a => Real (Consistent a)
RealFrac
           , Ord (Consistent a)
Ord (Consistent a)
-> ((Consistent a, Consistent a) -> [Consistent a])
-> ((Consistent a, Consistent a) -> Consistent a -> Int)
-> ((Consistent a, Consistent a) -> Consistent a -> Int)
-> ((Consistent a, Consistent a) -> Consistent a -> Bool)
-> ((Consistent a, Consistent a) -> Int)
-> ((Consistent a, Consistent a) -> Int)
-> Ix (Consistent a)
(Consistent a, Consistent a) -> Int
(Consistent a, Consistent a) -> [Consistent a]
(Consistent a, Consistent a) -> Consistent a -> Bool
(Consistent a, Consistent a) -> Consistent a -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall a. Ix a => Ord (Consistent a)
forall a. Ix a => (Consistent a, Consistent a) -> Int
forall a. Ix a => (Consistent a, Consistent a) -> [Consistent a]
forall a.
Ix a =>
(Consistent a, Consistent a) -> Consistent a -> Bool
forall a.
Ix a =>
(Consistent a, Consistent a) -> Consistent a -> Int
unsafeRangeSize :: (Consistent a, Consistent a) -> Int
$cunsafeRangeSize :: forall a. Ix a => (Consistent a, Consistent a) -> Int
rangeSize :: (Consistent a, Consistent a) -> Int
$crangeSize :: forall a. Ix a => (Consistent a, Consistent a) -> Int
inRange :: (Consistent a, Consistent a) -> Consistent a -> Bool
$cinRange :: forall a.
Ix a =>
(Consistent a, Consistent a) -> Consistent a -> Bool
unsafeIndex :: (Consistent a, Consistent a) -> Consistent a -> Int
$cunsafeIndex :: forall a.
Ix a =>
(Consistent a, Consistent a) -> Consistent a -> Int
index :: (Consistent a, Consistent a) -> Consistent a -> Int
$cindex :: forall a.
Ix a =>
(Consistent a, Consistent a) -> Consistent a -> Int
range :: (Consistent a, Consistent a) -> [Consistent a]
$crange :: forall a. Ix a => (Consistent a, Consistent a) -> [Consistent a]
$cp1Ix :: forall a. Ix a => Ord (Consistent a)
Ix
           , String -> Consistent a
(String -> Consistent a) -> IsString (Consistent a)
forall a. IsString a => String -> Consistent a
forall a. (String -> a) -> IsString a
fromString :: String -> Consistent a
$cfromString :: forall a. IsString a => String -> Consistent a
IsString
           , Eq (Consistent a)
Consistent a
Eq (Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a -> Consistent a)
-> (Consistent a -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> Consistent a
-> (Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Bool)
-> (Consistent a -> Maybe Int)
-> (Consistent a -> Int)
-> (Consistent a -> Bool)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int -> Consistent a)
-> (Consistent a -> Int)
-> Bits (Consistent a)
Int -> Consistent a
Consistent a -> Bool
Consistent a -> Int
Consistent a -> Maybe Int
Consistent a -> Consistent a
Consistent a -> Int -> Bool
Consistent a -> Int -> Consistent a
Consistent a -> Consistent a -> Consistent 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 (Consistent a)
forall a. Bits a => Consistent a
forall a. Bits a => Int -> Consistent a
forall a. Bits a => Consistent a -> Bool
forall a. Bits a => Consistent a -> Int
forall a. Bits a => Consistent a -> Maybe Int
forall a. Bits a => Consistent a -> Consistent a
forall a. Bits a => Consistent a -> Int -> Bool
forall a. Bits a => Consistent a -> Int -> Consistent a
forall a. Bits a => Consistent a -> Consistent a -> Consistent a
popCount :: Consistent a -> Int
$cpopCount :: forall a. Bits a => Consistent a -> Int
rotateR :: Consistent a -> Int -> Consistent a
$crotateR :: forall a. Bits a => Consistent a -> Int -> Consistent a
rotateL :: Consistent a -> Int -> Consistent a
$crotateL :: forall a. Bits a => Consistent a -> Int -> Consistent a
unsafeShiftR :: Consistent a -> Int -> Consistent a
$cunsafeShiftR :: forall a. Bits a => Consistent a -> Int -> Consistent a
shiftR :: Consistent a -> Int -> Consistent a
$cshiftR :: forall a. Bits a => Consistent a -> Int -> Consistent a
unsafeShiftL :: Consistent a -> Int -> Consistent a
$cunsafeShiftL :: forall a. Bits a => Consistent a -> Int -> Consistent a
shiftL :: Consistent a -> Int -> Consistent a
$cshiftL :: forall a. Bits a => Consistent a -> Int -> Consistent a
isSigned :: Consistent a -> Bool
$cisSigned :: forall a. Bits a => Consistent a -> Bool
bitSize :: Consistent a -> Int
$cbitSize :: forall a. Bits a => Consistent a -> Int
bitSizeMaybe :: Consistent a -> Maybe Int
$cbitSizeMaybe :: forall a. Bits a => Consistent a -> Maybe Int
testBit :: Consistent a -> Int -> Bool
$ctestBit :: forall a. Bits a => Consistent a -> Int -> Bool
complementBit :: Consistent a -> Int -> Consistent a
$ccomplementBit :: forall a. Bits a => Consistent a -> Int -> Consistent a
clearBit :: Consistent a -> Int -> Consistent a
$cclearBit :: forall a. Bits a => Consistent a -> Int -> Consistent a
setBit :: Consistent a -> Int -> Consistent a
$csetBit :: forall a. Bits a => Consistent a -> Int -> Consistent a
bit :: Int -> Consistent a
$cbit :: forall a. Bits a => Int -> Consistent a
zeroBits :: Consistent a
$czeroBits :: forall a. Bits a => Consistent a
rotate :: Consistent a -> Int -> Consistent a
$crotate :: forall a. Bits a => Consistent a -> Int -> Consistent a
shift :: Consistent a -> Int -> Consistent a
$cshift :: forall a. Bits a => Consistent a -> Int -> Consistent a
complement :: Consistent a -> Consistent a
$ccomplement :: forall a. Bits a => Consistent a -> Consistent a
xor :: Consistent a -> Consistent a -> Consistent a
$cxor :: forall a. Bits a => Consistent a -> Consistent a -> Consistent a
.|. :: Consistent a -> Consistent a -> Consistent a
$c.|. :: forall a. Bits a => Consistent a -> Consistent a -> Consistent a
.&. :: Consistent a -> Consistent a -> Consistent a
$c.&. :: forall a. Bits a => Consistent a -> Consistent a -> Consistent a
$cp1Bits :: forall a. Bits a => Eq (Consistent a)
Bits
           , Bits (Consistent a)
Bits (Consistent a)
-> (Consistent a -> Int)
-> (Consistent a -> Int)
-> (Consistent a -> Int)
-> FiniteBits (Consistent a)
Consistent a -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
forall a. FiniteBits a => Bits (Consistent a)
forall a. FiniteBits a => Consistent a -> Int
countTrailingZeros :: Consistent a -> Int
$ccountTrailingZeros :: forall a. FiniteBits a => Consistent a -> Int
countLeadingZeros :: Consistent a -> Int
$ccountLeadingZeros :: forall a. FiniteBits a => Consistent a -> Int
finiteBitSize :: Consistent a -> Int
$cfiniteBitSize :: forall a. FiniteBits a => Consistent a -> Int
$cp1FiniteBits :: forall a. FiniteBits a => Bits (Consistent a)
FiniteBits
           )
  deriving ( (a -> b -> Bool) -> Consistent a -> Consistent b -> Bool
(forall a b.
 (a -> b -> Bool) -> Consistent a -> Consistent b -> Bool)
-> Eq1 Consistent
forall a b.
(a -> b -> Bool) -> Consistent a -> Consistent b -> Bool
forall (f :: * -> *).
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
liftEq :: (a -> b -> Bool) -> Consistent a -> Consistent b -> Bool
$cliftEq :: forall a b.
(a -> b -> Bool) -> Consistent a -> Consistent b -> Bool
Eq1
           , Eq1 Consistent
Eq1 Consistent
-> (forall a b.
    (a -> b -> Ordering) -> Consistent a -> Consistent b -> Ordering)
-> Ord1 Consistent
(a -> b -> Ordering) -> Consistent a -> Consistent b -> Ordering
forall a b.
(a -> b -> Ordering) -> Consistent a -> Consistent b -> Ordering
forall (f :: * -> *).
Eq1 f
-> (forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
liftCompare :: (a -> b -> Ordering) -> Consistent a -> Consistent b -> Ordering
$cliftCompare :: forall a b.
(a -> b -> Ordering) -> Consistent a -> Consistent b -> Ordering
$cp1Ord1 :: Eq1 Consistent
Ord1
           , ReadPrec a -> ReadPrec [a] -> ReadPrec (Consistent a)
ReadPrec a -> ReadPrec [a] -> ReadPrec [Consistent a]
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Consistent a)
(Int -> ReadS a) -> ReadS [a] -> ReadS [Consistent a]
(forall a.
 (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Consistent a))
-> (forall a.
    (Int -> ReadS a) -> ReadS [a] -> ReadS [Consistent a])
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec (Consistent a))
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec [Consistent a])
-> Read1 Consistent
forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [Consistent a]
forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (Consistent a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Consistent a)
forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [Consistent a]
forall (f :: * -> *).
(forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a))
-> (forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [f a])
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (f a))
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [f a])
-> Read1 f
liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Consistent a]
$cliftReadListPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [Consistent a]
liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Consistent a)
$cliftReadPrec :: forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (Consistent a)
liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Consistent a]
$cliftReadList :: forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [Consistent a]
liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Consistent a)
$cliftReadsPrec :: forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Consistent a)
Read1
           , (Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> Consistent a -> ShowS
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [Consistent a] -> ShowS
(forall a.
 (Int -> a -> ShowS)
 -> ([a] -> ShowS) -> Int -> Consistent a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Consistent a] -> ShowS)
-> Show1 Consistent
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> Consistent a -> ShowS
forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [Consistent a] -> ShowS
forall (f :: * -> *).
(forall a.
 (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS)
-> Show1 f
liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Consistent a] -> ShowS
$cliftShowList :: forall a.
(Int -> a -> ShowS) -> ([a] -> ShowS) -> [Consistent a] -> ShowS
liftShowsPrec :: (Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> Consistent a -> ShowS
$cliftShowsPrec :: forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> Consistent a -> ShowS
Show1
           , a -> Consistent a
(forall a. a -> Consistent a) -> Pointed Consistent
forall a. a -> Consistent a
forall (p :: * -> *). (forall a. a -> p a) -> Pointed p
point :: a -> Consistent a
$cpoint :: forall a. a -> Consistent a
Pointed
           , Consistent a -> a
(forall a. Consistent a -> a) -> Copointed Consistent
forall a. Consistent a -> a
forall (p :: * -> *). (forall a. p a -> a) -> Copointed p
copoint :: Consistent a -> a
$ccopoint :: forall a. Consistent a -> a
Copointed
           , Functor Consistent
a -> Consistent a
Functor Consistent
-> (forall a. a -> Consistent a)
-> (forall a b.
    Consistent (a -> b) -> Consistent a -> Consistent b)
-> (forall a b c.
    (a -> b -> c) -> Consistent a -> Consistent b -> Consistent c)
-> (forall a b. Consistent a -> Consistent b -> Consistent b)
-> (forall a b. Consistent a -> Consistent b -> Consistent a)
-> Applicative Consistent
Consistent a -> Consistent b -> Consistent b
Consistent a -> Consistent b -> Consistent a
Consistent (a -> b) -> Consistent a -> Consistent b
(a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
forall a. a -> Consistent a
forall a b. Consistent a -> Consistent b -> Consistent a
forall a b. Consistent a -> Consistent b -> Consistent b
forall a b. Consistent (a -> b) -> Consistent a -> Consistent b
forall a b c.
(a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Consistent a -> Consistent b -> Consistent a
$c<* :: forall a b. Consistent a -> Consistent b -> Consistent a
*> :: Consistent a -> Consistent b -> Consistent b
$c*> :: forall a b. Consistent a -> Consistent b -> Consistent b
liftA2 :: (a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
$cliftA2 :: forall a b c.
(a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
<*> :: Consistent (a -> b) -> Consistent a -> Consistent b
$c<*> :: forall a b. Consistent (a -> b) -> Consistent a -> Consistent b
pure :: a -> Consistent a
$cpure :: forall a. a -> Consistent a
$cp1Applicative :: Functor Consistent
Applicative
           , Monad Consistent
Monad Consistent
-> (forall a. (a -> Consistent a) -> Consistent a)
-> MonadFix Consistent
(a -> Consistent a) -> Consistent a
forall a. (a -> Consistent a) -> Consistent a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> Consistent a) -> Consistent a
$cmfix :: forall a. (a -> Consistent a) -> Consistent a
$cp1MonadFix :: Monad Consistent
MonadFix
           , Applicative Consistent
a -> Consistent a
Applicative Consistent
-> (forall a b.
    Consistent a -> (a -> Consistent b) -> Consistent b)
-> (forall a b. Consistent a -> Consistent b -> Consistent b)
-> (forall a. a -> Consistent a)
-> Monad Consistent
Consistent a -> (a -> Consistent b) -> Consistent b
Consistent a -> Consistent b -> Consistent b
forall a. a -> Consistent a
forall a b. Consistent a -> Consistent b -> Consistent b
forall a b. Consistent a -> (a -> Consistent b) -> Consistent b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Consistent a
$creturn :: forall a. a -> Consistent a
>> :: Consistent a -> Consistent b -> Consistent b
$c>> :: forall a b. Consistent a -> Consistent b -> Consistent b
>>= :: Consistent a -> (a -> Consistent b) -> Consistent b
$c>>= :: forall a b. Consistent a -> (a -> Consistent b) -> Consistent b
$cp1Monad :: Applicative Consistent
Monad
           , Monad Consistent
Monad Consistent
-> (forall a b. Consistent a -> Consistent b -> Consistent (a, b))
-> (forall a b c.
    (a -> b -> c) -> Consistent a -> Consistent b -> Consistent c)
-> (forall a b. Consistent (a, b) -> (Consistent a, Consistent b))
-> MonadZip Consistent
Consistent a -> Consistent b -> Consistent (a, b)
Consistent (a, b) -> (Consistent a, Consistent b)
(a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
forall a b. Consistent a -> Consistent b -> Consistent (a, b)
forall a b. Consistent (a, b) -> (Consistent a, Consistent b)
forall a b c.
(a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
forall (m :: * -> *).
Monad m
-> (forall a b. m a -> m b -> m (a, b))
-> (forall a b c. (a -> b -> c) -> m a -> m b -> m c)
-> (forall a b. m (a, b) -> (m a, m b))
-> MonadZip m
munzip :: Consistent (a, b) -> (Consistent a, Consistent b)
$cmunzip :: forall a b. Consistent (a, b) -> (Consistent a, Consistent b)
mzipWith :: (a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
$cmzipWith :: forall a b c.
(a -> b -> c) -> Consistent a -> Consistent b -> Consistent c
mzip :: Consistent a -> Consistent b -> Consistent (a, b)
$cmzip :: forall a b. Consistent a -> Consistent b -> Consistent (a, b)
$cp1MonadZip :: Monad Consistent
MonadZip
           , Functor Consistent
Functor Consistent
-> (forall a. Consistent a -> a)
-> (forall a. Consistent a -> Consistent (Consistent a))
-> (forall a b.
    (Consistent a -> b) -> Consistent a -> Consistent b)
-> Comonad Consistent
Consistent a -> a
Consistent a -> Consistent (Consistent a)
(Consistent a -> b) -> Consistent a -> Consistent b
forall a. Consistent a -> a
forall a. Consistent a -> Consistent (Consistent a)
forall a b. (Consistent a -> b) -> Consistent a -> Consistent b
forall (w :: * -> *).
Functor w
-> (forall a. w a -> a)
-> (forall a. w a -> w (w a))
-> (forall a b. (w a -> b) -> w a -> w b)
-> Comonad w
extend :: (Consistent a -> b) -> Consistent a -> Consistent b
$cextend :: forall a b. (Consistent a -> b) -> Consistent a -> Consistent b
duplicate :: Consistent a -> Consistent (Consistent a)
$cduplicate :: forall a. Consistent a -> Consistent (Consistent a)
extract :: Consistent a -> a
$cextract :: forall a. Consistent a -> a
$cp1Comonad :: Functor Consistent
Comonad
           )
           via Identity

-- | An accessor function for something 'Consistent'.
_theConsistent :: Consistent x -> x
_theConsistent :: Consistent x -> x
_theConsistent (Consistent !x
x) = x
x
{-# INLINE _theConsistent #-}

-- | A lens for something 'Consistent'.
theConsistent :: forall a b p f. (Profunctor p, Functor f) => p a (f b) -> p (Consistent a) (f (Consistent b))
theConsistent :: p a (f b) -> p (Consistent a) (f (Consistent b))
theConsistent = (Consistent a -> a)
-> (f b -> f (Consistent b))
-> p a (f b)
-> p (Consistent a) (f (Consistent b))
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap Consistent a -> a
forall a. Consistent a -> a
_theConsistent ((b -> Consistent b) -> f b -> f (Consistent b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> Consistent b
forall a. a -> Consistent a
Consistent)
{-# INLINE theConsistent #-}


-- | A wrapper for something that is `ConsistentTo` some context
-- indicated by a (phantom-) type.
newtype ConsistentTo ctx a = ConsistentTo a
  deriving ( ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
(ConsistentTo ctx a -> ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> Bool)
-> Eq (ConsistentTo ctx a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall ctx a.
Eq a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
/= :: ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
$c/= :: forall ctx a.
Eq a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
== :: ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
$c== :: forall ctx a.
Eq a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
Eq
           , Eq (ConsistentTo ctx a)
Eq (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> Ordering)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> Ord (ConsistentTo ctx a)
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
ConsistentTo ctx a -> ConsistentTo ctx a -> Ordering
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx 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 ctx a. Ord a => Eq (ConsistentTo ctx a)
forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Ordering
forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
min :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cmin :: forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
max :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cmax :: forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
>= :: ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
$c>= :: forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
> :: ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
$c> :: forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
<= :: ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
$c<= :: forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
< :: ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
$c< :: forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Bool
compare :: ConsistentTo ctx a -> ConsistentTo ctx a -> Ordering
$ccompare :: forall ctx a.
Ord a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> Ordering
$cp1Ord :: forall ctx a. Ord a => Eq (ConsistentTo ctx a)
Ord
           , ReadPrec [ConsistentTo ctx a]
ReadPrec (ConsistentTo ctx a)
Int -> ReadS (ConsistentTo ctx a)
ReadS [ConsistentTo ctx a]
(Int -> ReadS (ConsistentTo ctx a))
-> ReadS [ConsistentTo ctx a]
-> ReadPrec (ConsistentTo ctx a)
-> ReadPrec [ConsistentTo ctx a]
-> Read (ConsistentTo ctx a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall ctx a. Read a => ReadPrec [ConsistentTo ctx a]
forall ctx a. Read a => ReadPrec (ConsistentTo ctx a)
forall ctx a. Read a => Int -> ReadS (ConsistentTo ctx a)
forall ctx a. Read a => ReadS [ConsistentTo ctx a]
readListPrec :: ReadPrec [ConsistentTo ctx a]
$creadListPrec :: forall ctx a. Read a => ReadPrec [ConsistentTo ctx a]
readPrec :: ReadPrec (ConsistentTo ctx a)
$creadPrec :: forall ctx a. Read a => ReadPrec (ConsistentTo ctx a)
readList :: ReadS [ConsistentTo ctx a]
$creadList :: forall ctx a. Read a => ReadS [ConsistentTo ctx a]
readsPrec :: Int -> ReadS (ConsistentTo ctx a)
$creadsPrec :: forall ctx a. Read a => Int -> ReadS (ConsistentTo ctx a)
Read
           , Int -> ConsistentTo ctx a -> ShowS
[ConsistentTo ctx a] -> ShowS
ConsistentTo ctx a -> String
(Int -> ConsistentTo ctx a -> ShowS)
-> (ConsistentTo ctx a -> String)
-> ([ConsistentTo ctx a] -> ShowS)
-> Show (ConsistentTo ctx a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall ctx a. Show a => Int -> ConsistentTo ctx a -> ShowS
forall ctx a. Show a => [ConsistentTo ctx a] -> ShowS
forall ctx a. Show a => ConsistentTo ctx a -> String
showList :: [ConsistentTo ctx a] -> ShowS
$cshowList :: forall ctx a. Show a => [ConsistentTo ctx a] -> ShowS
show :: ConsistentTo ctx a -> String
$cshow :: forall ctx a. Show a => ConsistentTo ctx a -> String
showsPrec :: Int -> ConsistentTo ctx a -> ShowS
$cshowsPrec :: forall ctx a. Show a => Int -> ConsistentTo ctx a -> ShowS
Show
           , ConsistentTo ctx a -> ()
(ConsistentTo ctx a -> ()) -> NFData (ConsistentTo ctx a)
forall a. (a -> ()) -> NFData a
forall ctx a. NFData a => ConsistentTo ctx a -> ()
rnf :: ConsistentTo ctx a -> ()
$crnf :: forall ctx a. NFData a => ConsistentTo ctx a -> ()
NFData
           , ConsistentTo ctx a -> Bool
(a -> m) -> ConsistentTo ctx a -> m
(a -> b -> b) -> b -> ConsistentTo ctx a -> b
(forall m. Monoid m => ConsistentTo ctx m -> m)
-> (forall m a. Monoid m => (a -> m) -> ConsistentTo ctx a -> m)
-> (forall m a. Monoid m => (a -> m) -> ConsistentTo ctx a -> m)
-> (forall a b. (a -> b -> b) -> b -> ConsistentTo ctx a -> b)
-> (forall a b. (a -> b -> b) -> b -> ConsistentTo ctx a -> b)
-> (forall b a. (b -> a -> b) -> b -> ConsistentTo ctx a -> b)
-> (forall b a. (b -> a -> b) -> b -> ConsistentTo ctx a -> b)
-> (forall a. (a -> a -> a) -> ConsistentTo ctx a -> a)
-> (forall a. (a -> a -> a) -> ConsistentTo ctx a -> a)
-> (forall a. ConsistentTo ctx a -> [a])
-> (forall a. ConsistentTo ctx a -> Bool)
-> (forall a. ConsistentTo ctx a -> Int)
-> (forall a. Eq a => a -> ConsistentTo ctx a -> Bool)
-> (forall a. Ord a => ConsistentTo ctx a -> a)
-> (forall a. Ord a => ConsistentTo ctx a -> a)
-> (forall a. Num a => ConsistentTo ctx a -> a)
-> (forall a. Num a => ConsistentTo ctx a -> a)
-> Foldable (ConsistentTo ctx)
forall a. Eq a => a -> ConsistentTo ctx a -> Bool
forall a. Num a => ConsistentTo ctx a -> a
forall a. Ord a => ConsistentTo ctx a -> a
forall m. Monoid m => ConsistentTo ctx m -> m
forall a. ConsistentTo ctx a -> Bool
forall a. ConsistentTo ctx a -> Int
forall a. ConsistentTo ctx a -> [a]
forall a. (a -> a -> a) -> ConsistentTo ctx a -> a
forall ctx a. Eq a => a -> ConsistentTo ctx a -> Bool
forall ctx a. Num a => ConsistentTo ctx a -> a
forall ctx a. Ord a => ConsistentTo ctx a -> a
forall m a. Monoid m => (a -> m) -> ConsistentTo ctx a -> m
forall ctx m. Monoid m => ConsistentTo ctx m -> m
forall ctx a. ConsistentTo ctx a -> Bool
forall ctx a. ConsistentTo ctx a -> Int
forall ctx a. ConsistentTo ctx a -> [a]
forall b a. (b -> a -> b) -> b -> ConsistentTo ctx a -> b
forall a b. (a -> b -> b) -> b -> ConsistentTo ctx a -> b
forall ctx a. (a -> a -> a) -> ConsistentTo ctx a -> a
forall ctx m a. Monoid m => (a -> m) -> ConsistentTo ctx a -> m
forall ctx b a. (b -> a -> b) -> b -> ConsistentTo ctx a -> b
forall ctx a b. (a -> b -> b) -> b -> ConsistentTo ctx 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 :: ConsistentTo ctx a -> a
$cproduct :: forall ctx a. Num a => ConsistentTo ctx a -> a
sum :: ConsistentTo ctx a -> a
$csum :: forall ctx a. Num a => ConsistentTo ctx a -> a
minimum :: ConsistentTo ctx a -> a
$cminimum :: forall ctx a. Ord a => ConsistentTo ctx a -> a
maximum :: ConsistentTo ctx a -> a
$cmaximum :: forall ctx a. Ord a => ConsistentTo ctx a -> a
elem :: a -> ConsistentTo ctx a -> Bool
$celem :: forall ctx a. Eq a => a -> ConsistentTo ctx a -> Bool
length :: ConsistentTo ctx a -> Int
$clength :: forall ctx a. ConsistentTo ctx a -> Int
null :: ConsistentTo ctx a -> Bool
$cnull :: forall ctx a. ConsistentTo ctx a -> Bool
toList :: ConsistentTo ctx a -> [a]
$ctoList :: forall ctx a. ConsistentTo ctx a -> [a]
foldl1 :: (a -> a -> a) -> ConsistentTo ctx a -> a
$cfoldl1 :: forall ctx a. (a -> a -> a) -> ConsistentTo ctx a -> a
foldr1 :: (a -> a -> a) -> ConsistentTo ctx a -> a
$cfoldr1 :: forall ctx a. (a -> a -> a) -> ConsistentTo ctx a -> a
foldl' :: (b -> a -> b) -> b -> ConsistentTo ctx a -> b
$cfoldl' :: forall ctx b a. (b -> a -> b) -> b -> ConsistentTo ctx a -> b
foldl :: (b -> a -> b) -> b -> ConsistentTo ctx a -> b
$cfoldl :: forall ctx b a. (b -> a -> b) -> b -> ConsistentTo ctx a -> b
foldr' :: (a -> b -> b) -> b -> ConsistentTo ctx a -> b
$cfoldr' :: forall ctx a b. (a -> b -> b) -> b -> ConsistentTo ctx a -> b
foldr :: (a -> b -> b) -> b -> ConsistentTo ctx a -> b
$cfoldr :: forall ctx a b. (a -> b -> b) -> b -> ConsistentTo ctx a -> b
foldMap' :: (a -> m) -> ConsistentTo ctx a -> m
$cfoldMap' :: forall ctx m a. Monoid m => (a -> m) -> ConsistentTo ctx a -> m
foldMap :: (a -> m) -> ConsistentTo ctx a -> m
$cfoldMap :: forall ctx m a. Monoid m => (a -> m) -> ConsistentTo ctx a -> m
fold :: ConsistentTo ctx m -> m
$cfold :: forall ctx m. Monoid m => ConsistentTo ctx m -> m
Foldable
           , Functor (ConsistentTo ctx)
Foldable (ConsistentTo ctx)
Functor (ConsistentTo ctx)
-> Foldable (ConsistentTo ctx)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ConsistentTo ctx a -> f (ConsistentTo ctx b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ConsistentTo ctx (f a) -> f (ConsistentTo ctx a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ConsistentTo ctx a -> m (ConsistentTo ctx b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ConsistentTo ctx (m a) -> m (ConsistentTo ctx a))
-> Traversable (ConsistentTo ctx)
(a -> f b) -> ConsistentTo ctx a -> f (ConsistentTo ctx b)
forall ctx. Functor (ConsistentTo ctx)
forall ctx. Foldable (ConsistentTo ctx)
forall ctx (m :: * -> *) a.
Monad m =>
ConsistentTo ctx (m a) -> m (ConsistentTo ctx a)
forall ctx (f :: * -> *) a.
Applicative f =>
ConsistentTo ctx (f a) -> f (ConsistentTo ctx a)
forall ctx (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ConsistentTo ctx a -> m (ConsistentTo ctx b)
forall ctx (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ConsistentTo ctx a -> f (ConsistentTo ctx 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 =>
ConsistentTo ctx (m a) -> m (ConsistentTo ctx a)
forall (f :: * -> *) a.
Applicative f =>
ConsistentTo ctx (f a) -> f (ConsistentTo ctx a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ConsistentTo ctx a -> m (ConsistentTo ctx b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ConsistentTo ctx a -> f (ConsistentTo ctx b)
sequence :: ConsistentTo ctx (m a) -> m (ConsistentTo ctx a)
$csequence :: forall ctx (m :: * -> *) a.
Monad m =>
ConsistentTo ctx (m a) -> m (ConsistentTo ctx a)
mapM :: (a -> m b) -> ConsistentTo ctx a -> m (ConsistentTo ctx b)
$cmapM :: forall ctx (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ConsistentTo ctx a -> m (ConsistentTo ctx b)
sequenceA :: ConsistentTo ctx (f a) -> f (ConsistentTo ctx a)
$csequenceA :: forall ctx (f :: * -> *) a.
Applicative f =>
ConsistentTo ctx (f a) -> f (ConsistentTo ctx a)
traverse :: (a -> f b) -> ConsistentTo ctx a -> f (ConsistentTo ctx b)
$ctraverse :: forall ctx (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ConsistentTo ctx a -> f (ConsistentTo ctx b)
$cp2Traversable :: forall ctx. Foldable (ConsistentTo ctx)
$cp1Traversable :: forall ctx. Functor (ConsistentTo ctx)
Traversable
           , a -> ConsistentTo ctx b -> ConsistentTo ctx a
(a -> b) -> ConsistentTo ctx a -> ConsistentTo ctx b
(forall a b. (a -> b) -> ConsistentTo ctx a -> ConsistentTo ctx b)
-> (forall a b. a -> ConsistentTo ctx b -> ConsistentTo ctx a)
-> Functor (ConsistentTo ctx)
forall a b. a -> ConsistentTo ctx b -> ConsistentTo ctx a
forall a b. (a -> b) -> ConsistentTo ctx a -> ConsistentTo ctx b
forall ctx a b. a -> ConsistentTo ctx b -> ConsistentTo ctx a
forall ctx a b.
(a -> b) -> ConsistentTo ctx a -> ConsistentTo ctx b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ConsistentTo ctx b -> ConsistentTo ctx a
$c<$ :: forall ctx a b. a -> ConsistentTo ctx b -> ConsistentTo ctx a
fmap :: (a -> b) -> ConsistentTo ctx a -> ConsistentTo ctx b
$cfmap :: forall ctx a b.
(a -> b) -> ConsistentTo ctx a -> ConsistentTo ctx b
Functor
           , ConsistentTo ctx a
ConsistentTo ctx a -> Default (ConsistentTo ctx a)
forall a. a -> Default a
forall ctx a. Default a => ConsistentTo ctx a
def :: ConsistentTo ctx a
$cdef :: forall ctx a. Default a => ConsistentTo ctx a
Default
           , Semigroup (ConsistentTo ctx a)
ConsistentTo ctx a
Semigroup (ConsistentTo ctx a)
-> ConsistentTo ctx a
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> ([ConsistentTo ctx a] -> ConsistentTo ctx a)
-> Monoid (ConsistentTo ctx a)
[ConsistentTo ctx a] -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall ctx a. Monoid a => Semigroup (ConsistentTo ctx a)
forall ctx a. Monoid a => ConsistentTo ctx a
forall ctx a.
Monoid a =>
[ConsistentTo ctx a] -> ConsistentTo ctx a
forall ctx a.
Monoid a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
mconcat :: [ConsistentTo ctx a] -> ConsistentTo ctx a
$cmconcat :: forall ctx a.
Monoid a =>
[ConsistentTo ctx a] -> ConsistentTo ctx a
mappend :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cmappend :: forall ctx a.
Monoid a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
mempty :: ConsistentTo ctx a
$cmempty :: forall ctx a. Monoid a => ConsistentTo ctx a
$cp1Monoid :: forall ctx a. Monoid a => Semigroup (ConsistentTo ctx a)
Monoid
           , b -> ConsistentTo ctx a -> ConsistentTo ctx a
NonEmpty (ConsistentTo ctx a) -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
(ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (NonEmpty (ConsistentTo ctx a) -> ConsistentTo ctx a)
-> (forall b.
    Integral b =>
    b -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> Semigroup (ConsistentTo ctx a)
forall b.
Integral b =>
b -> ConsistentTo ctx a -> ConsistentTo ctx a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall ctx a.
Semigroup a =>
NonEmpty (ConsistentTo ctx a) -> ConsistentTo ctx a
forall ctx a.
Semigroup a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a b.
(Semigroup a, Integral b) =>
b -> ConsistentTo ctx a -> ConsistentTo ctx a
stimes :: b -> ConsistentTo ctx a -> ConsistentTo ctx a
$cstimes :: forall ctx a b.
(Semigroup a, Integral b) =>
b -> ConsistentTo ctx a -> ConsistentTo ctx a
sconcat :: NonEmpty (ConsistentTo ctx a) -> ConsistentTo ctx a
$csconcat :: forall ctx a.
Semigroup a =>
NonEmpty (ConsistentTo ctx a) -> ConsistentTo ctx a
<> :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c<> :: forall ctx a.
Semigroup a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
Semigroup
           , Typeable
           , (forall x. ConsistentTo ctx a -> Rep (ConsistentTo ctx a) x)
-> (forall x. Rep (ConsistentTo ctx a) x -> ConsistentTo ctx a)
-> Generic (ConsistentTo ctx a)
forall x. Rep (ConsistentTo ctx a) x -> ConsistentTo ctx a
forall x. ConsistentTo ctx a -> Rep (ConsistentTo ctx a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ctx a x. Rep (ConsistentTo ctx a) x -> ConsistentTo ctx a
forall ctx a x. ConsistentTo ctx a -> Rep (ConsistentTo ctx a) x
$cto :: forall ctx a x. Rep (ConsistentTo ctx a) x -> ConsistentTo ctx a
$cfrom :: forall ctx a x. ConsistentTo ctx a -> Rep (ConsistentTo ctx a) x
Generic
           , (forall a. ConsistentTo ctx a -> Rep1 (ConsistentTo ctx) a)
-> (forall a. Rep1 (ConsistentTo ctx) a -> ConsistentTo ctx a)
-> Generic1 (ConsistentTo ctx)
forall a. Rep1 (ConsistentTo ctx) a -> ConsistentTo ctx a
forall a. ConsistentTo ctx a -> Rep1 (ConsistentTo ctx) a
forall ctx a. Rep1 (ConsistentTo ctx) a -> ConsistentTo ctx a
forall ctx a. ConsistentTo ctx a -> Rep1 (ConsistentTo ctx) a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cto1 :: forall ctx a. Rep1 (ConsistentTo ctx) a -> ConsistentTo ctx a
$cfrom1 :: forall ctx a. ConsistentTo ctx a -> Rep1 (ConsistentTo ctx) a
Generic1
           , g -> (ConsistentTo ctx a, g)
g -> [ConsistentTo ctx a]
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> (ConsistentTo ctx a, g)
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> [ConsistentTo ctx a]
(forall g.
 RandomGen g =>
 (ConsistentTo ctx a, ConsistentTo ctx a)
 -> g -> (ConsistentTo ctx a, g))
-> (forall g. RandomGen g => g -> (ConsistentTo ctx a, g))
-> (forall g.
    RandomGen g =>
    (ConsistentTo ctx a, ConsistentTo ctx a)
    -> g -> [ConsistentTo ctx a])
-> (forall g. RandomGen g => g -> [ConsistentTo ctx a])
-> Random (ConsistentTo ctx a)
forall g. RandomGen g => g -> [ConsistentTo ctx a]
forall g. RandomGen g => g -> (ConsistentTo ctx a, g)
forall g.
RandomGen g =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> [ConsistentTo ctx a]
forall g.
RandomGen g =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> (ConsistentTo ctx a, g)
forall a.
(forall g. RandomGen g => (a, a) -> g -> (a, g))
-> (forall g. RandomGen g => g -> (a, g))
-> (forall g. RandomGen g => (a, a) -> g -> [a])
-> (forall g. RandomGen g => g -> [a])
-> Random a
forall ctx a g.
(Random a, RandomGen g) =>
g -> [ConsistentTo ctx a]
forall ctx a g.
(Random a, RandomGen g) =>
g -> (ConsistentTo ctx a, g)
forall ctx a g.
(Random a, RandomGen g) =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> [ConsistentTo ctx a]
forall ctx a g.
(Random a, RandomGen g) =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> (ConsistentTo ctx a, g)
randoms :: g -> [ConsistentTo ctx a]
$crandoms :: forall ctx a g.
(Random a, RandomGen g) =>
g -> [ConsistentTo ctx a]
randomRs :: (ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> [ConsistentTo ctx a]
$crandomRs :: forall ctx a g.
(Random a, RandomGen g) =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> [ConsistentTo ctx a]
random :: g -> (ConsistentTo ctx a, g)
$crandom :: forall ctx a g.
(Random a, RandomGen g) =>
g -> (ConsistentTo ctx a, g)
randomR :: (ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> (ConsistentTo ctx a, g)
$crandomR :: forall ctx a g.
(Random a, RandomGen g) =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> g -> (ConsistentTo ctx a, g)
Random
           , Gen (ConsistentTo ctx a)
Gen (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> [ConsistentTo ctx a])
-> Arbitrary (ConsistentTo ctx a)
ConsistentTo ctx a -> [ConsistentTo ctx a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall ctx a. Arbitrary a => Gen (ConsistentTo ctx a)
forall ctx a.
Arbitrary a =>
ConsistentTo ctx a -> [ConsistentTo ctx a]
shrink :: ConsistentTo ctx a -> [ConsistentTo ctx a]
$cshrink :: forall ctx a.
Arbitrary a =>
ConsistentTo ctx a -> [ConsistentTo ctx a]
arbitrary :: Gen (ConsistentTo ctx a)
$carbitrary :: forall ctx a. Arbitrary a => Gen (ConsistentTo ctx a)
Arbitrary
           , ConsistentTo ctx a
ConsistentTo ctx a
-> ConsistentTo ctx a -> Bounded (ConsistentTo ctx a)
forall a. a -> a -> Bounded a
forall ctx a. Bounded a => ConsistentTo ctx a
maxBound :: ConsistentTo ctx a
$cmaxBound :: forall ctx a. Bounded a => ConsistentTo ctx a
minBound :: ConsistentTo ctx a
$cminBound :: forall ctx a. Bounded a => ConsistentTo ctx a
Bounded
           , Int -> ConsistentTo ctx a
ConsistentTo ctx a -> Int
ConsistentTo ctx a -> [ConsistentTo ctx a]
ConsistentTo ctx a -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
ConsistentTo ctx a
-> ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
(ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int)
-> (ConsistentTo ctx a -> [ConsistentTo ctx a])
-> (ConsistentTo ctx a
    -> ConsistentTo ctx a -> [ConsistentTo ctx a])
-> (ConsistentTo ctx a
    -> ConsistentTo ctx a -> [ConsistentTo ctx a])
-> (ConsistentTo ctx a
    -> ConsistentTo ctx a
    -> ConsistentTo ctx a
    -> [ConsistentTo ctx a])
-> Enum (ConsistentTo ctx 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 ctx a. Enum a => Int -> ConsistentTo ctx a
forall ctx a. Enum a => ConsistentTo ctx a -> Int
forall ctx a. Enum a => ConsistentTo ctx a -> [ConsistentTo ctx a]
forall ctx a. Enum a => ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a.
Enum a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
forall ctx a.
Enum a =>
ConsistentTo ctx a
-> ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
enumFromThenTo :: ConsistentTo ctx a
-> ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
$cenumFromThenTo :: forall ctx a.
Enum a =>
ConsistentTo ctx a
-> ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
enumFromTo :: ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
$cenumFromTo :: forall ctx a.
Enum a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
enumFromThen :: ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
$cenumFromThen :: forall ctx a.
Enum a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> [ConsistentTo ctx a]
enumFrom :: ConsistentTo ctx a -> [ConsistentTo ctx a]
$cenumFrom :: forall ctx a. Enum a => ConsistentTo ctx a -> [ConsistentTo ctx a]
fromEnum :: ConsistentTo ctx a -> Int
$cfromEnum :: forall ctx a. Enum a => ConsistentTo ctx a -> Int
toEnum :: Int -> ConsistentTo ctx a
$ctoEnum :: forall ctx a. Enum a => Int -> ConsistentTo ctx a
pred :: ConsistentTo ctx a -> ConsistentTo ctx a
$cpred :: forall ctx a. Enum a => ConsistentTo ctx a -> ConsistentTo ctx a
succ :: ConsistentTo ctx a -> ConsistentTo ctx a
$csucc :: forall ctx a. Enum a => ConsistentTo ctx a -> ConsistentTo ctx a
Enum
           , Fractional (ConsistentTo ctx a)
ConsistentTo ctx a
Fractional (ConsistentTo ctx a)
-> ConsistentTo ctx a
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> Floating (ConsistentTo ctx a)
ConsistentTo ctx a -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx 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
forall ctx a. Floating a => Fractional (ConsistentTo ctx a)
forall ctx a. Floating a => ConsistentTo ctx a
forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
log1mexp :: ConsistentTo ctx a -> ConsistentTo ctx a
$clog1mexp :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
log1pexp :: ConsistentTo ctx a -> ConsistentTo ctx a
$clog1pexp :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
expm1 :: ConsistentTo ctx a -> ConsistentTo ctx a
$cexpm1 :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
log1p :: ConsistentTo ctx a -> ConsistentTo ctx a
$clog1p :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
atanh :: ConsistentTo ctx a -> ConsistentTo ctx a
$catanh :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
acosh :: ConsistentTo ctx a -> ConsistentTo ctx a
$cacosh :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
asinh :: ConsistentTo ctx a -> ConsistentTo ctx a
$casinh :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
tanh :: ConsistentTo ctx a -> ConsistentTo ctx a
$ctanh :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
cosh :: ConsistentTo ctx a -> ConsistentTo ctx a
$ccosh :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
sinh :: ConsistentTo ctx a -> ConsistentTo ctx a
$csinh :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
atan :: ConsistentTo ctx a -> ConsistentTo ctx a
$catan :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
acos :: ConsistentTo ctx a -> ConsistentTo ctx a
$cacos :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
asin :: ConsistentTo ctx a -> ConsistentTo ctx a
$casin :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
tan :: ConsistentTo ctx a -> ConsistentTo ctx a
$ctan :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
cos :: ConsistentTo ctx a -> ConsistentTo ctx a
$ccos :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
sin :: ConsistentTo ctx a -> ConsistentTo ctx a
$csin :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
logBase :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$clogBase :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
** :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c** :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
sqrt :: ConsistentTo ctx a -> ConsistentTo ctx a
$csqrt :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
log :: ConsistentTo ctx a -> ConsistentTo ctx a
$clog :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
exp :: ConsistentTo ctx a -> ConsistentTo ctx a
$cexp :: forall ctx a.
Floating a =>
ConsistentTo ctx a -> ConsistentTo ctx a
pi :: ConsistentTo ctx a
$cpi :: forall ctx a. Floating a => ConsistentTo ctx a
$cp1Floating :: forall ctx a. Floating a => Fractional (ConsistentTo ctx a)
Floating
           , Num (ConsistentTo ctx a)
Num (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (Rational -> ConsistentTo ctx a)
-> Fractional (ConsistentTo ctx a)
Rational -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
forall ctx a. Fractional a => Num (ConsistentTo ctx a)
forall ctx a. Fractional a => Rational -> ConsistentTo ctx a
forall ctx a.
Fractional a =>
ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a.
Fractional a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
fromRational :: Rational -> ConsistentTo ctx a
$cfromRational :: forall ctx a. Fractional a => Rational -> ConsistentTo ctx a
recip :: ConsistentTo ctx a -> ConsistentTo ctx a
$crecip :: forall ctx a.
Fractional a =>
ConsistentTo ctx a -> ConsistentTo ctx a
/ :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c/ :: forall ctx a.
Fractional a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cp1Fractional :: forall ctx a. Fractional a => Num (ConsistentTo ctx a)
Fractional
           , Enum (ConsistentTo ctx a)
Real (ConsistentTo ctx a)
Real (ConsistentTo ctx a)
-> Enum (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a
    -> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a))
-> (ConsistentTo ctx a
    -> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a))
-> (ConsistentTo ctx a -> Integer)
-> Integral (ConsistentTo ctx a)
ConsistentTo ctx a -> Integer
ConsistentTo ctx a
-> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a)
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx 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
forall ctx a. Integral a => Enum (ConsistentTo ctx a)
forall ctx a. Integral a => Real (ConsistentTo ctx a)
forall ctx a. Integral a => ConsistentTo ctx a -> Integer
forall ctx a.
Integral a =>
ConsistentTo ctx a
-> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a)
forall ctx a.
Integral a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
toInteger :: ConsistentTo ctx a -> Integer
$ctoInteger :: forall ctx a. Integral a => ConsistentTo ctx a -> Integer
divMod :: ConsistentTo ctx a
-> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a)
$cdivMod :: forall ctx a.
Integral a =>
ConsistentTo ctx a
-> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a)
quotRem :: ConsistentTo ctx a
-> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a)
$cquotRem :: forall ctx a.
Integral a =>
ConsistentTo ctx a
-> ConsistentTo ctx a -> (ConsistentTo ctx a, ConsistentTo ctx a)
mod :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cmod :: forall ctx a.
Integral a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
div :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cdiv :: forall ctx a.
Integral a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
rem :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$crem :: forall ctx a.
Integral a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
quot :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cquot :: forall ctx a.
Integral a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cp2Integral :: forall ctx a. Integral a => Enum (ConsistentTo ctx a)
$cp1Integral :: forall ctx a. Integral a => Real (ConsistentTo ctx a)
Integral
           , Integer -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
(ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (Integer -> ConsistentTo ctx a)
-> Num (ConsistentTo ctx a)
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
forall ctx a. Num a => Integer -> ConsistentTo ctx a
forall ctx a. Num a => ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a.
Num a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
fromInteger :: Integer -> ConsistentTo ctx a
$cfromInteger :: forall ctx a. Num a => Integer -> ConsistentTo ctx a
signum :: ConsistentTo ctx a -> ConsistentTo ctx a
$csignum :: forall ctx a. Num a => ConsistentTo ctx a -> ConsistentTo ctx a
abs :: ConsistentTo ctx a -> ConsistentTo ctx a
$cabs :: forall ctx a. Num a => ConsistentTo ctx a -> ConsistentTo ctx a
negate :: ConsistentTo ctx a -> ConsistentTo ctx a
$cnegate :: forall ctx a. Num a => ConsistentTo ctx a -> ConsistentTo ctx a
* :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c* :: forall ctx a.
Num a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
- :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c- :: forall ctx a.
Num a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
+ :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c+ :: forall ctx a.
Num a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
Num
           , Num (ConsistentTo ctx a)
Ord (ConsistentTo ctx a)
Num (ConsistentTo ctx a)
-> Ord (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Rational)
-> Real (ConsistentTo ctx a)
ConsistentTo ctx a -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
forall ctx a. Real a => Num (ConsistentTo ctx a)
forall ctx a. Real a => Ord (ConsistentTo ctx a)
forall ctx a. Real a => ConsistentTo ctx a -> Rational
toRational :: ConsistentTo ctx a -> Rational
$ctoRational :: forall ctx a. Real a => ConsistentTo ctx a -> Rational
$cp2Real :: forall ctx a. Real a => Ord (ConsistentTo ctx a)
$cp1Real :: forall ctx a. Real a => Num (ConsistentTo ctx a)
Real
           , Floating (ConsistentTo ctx a)
RealFrac (ConsistentTo ctx a)
RealFrac (ConsistentTo ctx a)
-> Floating (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Integer)
-> (ConsistentTo ctx a -> Int)
-> (ConsistentTo ctx a -> (Int, Int))
-> (ConsistentTo ctx a -> (Integer, Int))
-> (Integer -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (Int -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> RealFloat (ConsistentTo ctx a)
Int -> ConsistentTo ctx a -> ConsistentTo ctx a
Integer -> Int -> ConsistentTo ctx a
ConsistentTo ctx a -> Bool
ConsistentTo ctx a -> Int
ConsistentTo ctx a -> Integer
ConsistentTo ctx a -> (Int, Int)
ConsistentTo ctx a -> (Integer, Int)
ConsistentTo ctx a -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx 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
forall ctx a. RealFloat a => Floating (ConsistentTo ctx a)
forall ctx a. RealFloat a => RealFrac (ConsistentTo ctx a)
forall ctx a.
RealFloat a =>
Int -> ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a. RealFloat a => Integer -> Int -> ConsistentTo ctx a
forall ctx a. RealFloat a => ConsistentTo ctx a -> Bool
forall ctx a. RealFloat a => ConsistentTo ctx a -> Int
forall ctx a. RealFloat a => ConsistentTo ctx a -> Integer
forall ctx a. RealFloat a => ConsistentTo ctx a -> (Int, Int)
forall ctx a. RealFloat a => ConsistentTo ctx a -> (Integer, Int)
forall ctx a.
RealFloat a =>
ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a.
RealFloat a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
atan2 :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$catan2 :: forall ctx a.
RealFloat a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
isIEEE :: ConsistentTo ctx a -> Bool
$cisIEEE :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Bool
isNegativeZero :: ConsistentTo ctx a -> Bool
$cisNegativeZero :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Bool
isDenormalized :: ConsistentTo ctx a -> Bool
$cisDenormalized :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Bool
isInfinite :: ConsistentTo ctx a -> Bool
$cisInfinite :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Bool
isNaN :: ConsistentTo ctx a -> Bool
$cisNaN :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Bool
scaleFloat :: Int -> ConsistentTo ctx a -> ConsistentTo ctx a
$cscaleFloat :: forall ctx a.
RealFloat a =>
Int -> ConsistentTo ctx a -> ConsistentTo ctx a
significand :: ConsistentTo ctx a -> ConsistentTo ctx a
$csignificand :: forall ctx a.
RealFloat a =>
ConsistentTo ctx a -> ConsistentTo ctx a
exponent :: ConsistentTo ctx a -> Int
$cexponent :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Int
encodeFloat :: Integer -> Int -> ConsistentTo ctx a
$cencodeFloat :: forall ctx a. RealFloat a => Integer -> Int -> ConsistentTo ctx a
decodeFloat :: ConsistentTo ctx a -> (Integer, Int)
$cdecodeFloat :: forall ctx a. RealFloat a => ConsistentTo ctx a -> (Integer, Int)
floatRange :: ConsistentTo ctx a -> (Int, Int)
$cfloatRange :: forall ctx a. RealFloat a => ConsistentTo ctx a -> (Int, Int)
floatDigits :: ConsistentTo ctx a -> Int
$cfloatDigits :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Int
floatRadix :: ConsistentTo ctx a -> Integer
$cfloatRadix :: forall ctx a. RealFloat a => ConsistentTo ctx a -> Integer
$cp2RealFloat :: forall ctx a. RealFloat a => Floating (ConsistentTo ctx a)
$cp1RealFloat :: forall ctx a. RealFloat a => RealFrac (ConsistentTo ctx a)
RealFloat
           , Fractional (ConsistentTo ctx a)
Real (ConsistentTo ctx a)
Real (ConsistentTo ctx a)
-> Fractional (ConsistentTo ctx a)
-> (forall b.
    Integral b =>
    ConsistentTo ctx a -> (b, ConsistentTo ctx a))
-> (forall b. Integral b => ConsistentTo ctx a -> b)
-> (forall b. Integral b => ConsistentTo ctx a -> b)
-> (forall b. Integral b => ConsistentTo ctx a -> b)
-> (forall b. Integral b => ConsistentTo ctx a -> b)
-> RealFrac (ConsistentTo ctx a)
ConsistentTo ctx a -> b
ConsistentTo ctx a -> b
ConsistentTo ctx a -> b
ConsistentTo ctx a -> b
ConsistentTo ctx a -> (b, ConsistentTo ctx a)
forall b. Integral b => ConsistentTo ctx a -> b
forall b.
Integral b =>
ConsistentTo ctx a -> (b, ConsistentTo ctx 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 ctx a. RealFrac a => Fractional (ConsistentTo ctx a)
forall ctx a. RealFrac a => Real (ConsistentTo ctx a)
forall ctx a b. (RealFrac a, Integral b) => ConsistentTo ctx a -> b
forall ctx a b.
(RealFrac a, Integral b) =>
ConsistentTo ctx a -> (b, ConsistentTo ctx a)
floor :: ConsistentTo ctx a -> b
$cfloor :: forall ctx a b. (RealFrac a, Integral b) => ConsistentTo ctx a -> b
ceiling :: ConsistentTo ctx a -> b
$cceiling :: forall ctx a b. (RealFrac a, Integral b) => ConsistentTo ctx a -> b
round :: ConsistentTo ctx a -> b
$cround :: forall ctx a b. (RealFrac a, Integral b) => ConsistentTo ctx a -> b
truncate :: ConsistentTo ctx a -> b
$ctruncate :: forall ctx a b. (RealFrac a, Integral b) => ConsistentTo ctx a -> b
properFraction :: ConsistentTo ctx a -> (b, ConsistentTo ctx a)
$cproperFraction :: forall ctx a b.
(RealFrac a, Integral b) =>
ConsistentTo ctx a -> (b, ConsistentTo ctx a)
$cp2RealFrac :: forall ctx a. RealFrac a => Fractional (ConsistentTo ctx a)
$cp1RealFrac :: forall ctx a. RealFrac a => Real (ConsistentTo ctx a)
RealFrac
           , Ord (ConsistentTo ctx a)
Ord (ConsistentTo ctx a)
-> ((ConsistentTo ctx a, ConsistentTo ctx a)
    -> [ConsistentTo ctx a])
-> ((ConsistentTo ctx a, ConsistentTo ctx a)
    -> ConsistentTo ctx a -> Int)
-> ((ConsistentTo ctx a, ConsistentTo ctx a)
    -> ConsistentTo ctx a -> Int)
-> ((ConsistentTo ctx a, ConsistentTo ctx a)
    -> ConsistentTo ctx a -> Bool)
-> ((ConsistentTo ctx a, ConsistentTo ctx a) -> Int)
-> ((ConsistentTo ctx a, ConsistentTo ctx a) -> Int)
-> Ix (ConsistentTo ctx a)
(ConsistentTo ctx a, ConsistentTo ctx a) -> Int
(ConsistentTo ctx a, ConsistentTo ctx a) -> [ConsistentTo ctx a]
(ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Bool
(ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
forall ctx a. Ix a => Ord (ConsistentTo ctx a)
forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a) -> Int
forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a) -> [ConsistentTo ctx a]
forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Bool
forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Int
unsafeRangeSize :: (ConsistentTo ctx a, ConsistentTo ctx a) -> Int
$cunsafeRangeSize :: forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a) -> Int
rangeSize :: (ConsistentTo ctx a, ConsistentTo ctx a) -> Int
$crangeSize :: forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a) -> Int
inRange :: (ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Bool
$cinRange :: forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Bool
unsafeIndex :: (ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Int
$cunsafeIndex :: forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Int
index :: (ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Int
$cindex :: forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a)
-> ConsistentTo ctx a -> Int
range :: (ConsistentTo ctx a, ConsistentTo ctx a) -> [ConsistentTo ctx a]
$crange :: forall ctx a.
Ix a =>
(ConsistentTo ctx a, ConsistentTo ctx a) -> [ConsistentTo ctx a]
$cp1Ix :: forall ctx a. Ix a => Ord (ConsistentTo ctx a)
Ix
           , String -> ConsistentTo ctx a
(String -> ConsistentTo ctx a) -> IsString (ConsistentTo ctx a)
forall a. (String -> a) -> IsString a
forall ctx a. IsString a => String -> ConsistentTo ctx a
fromString :: String -> ConsistentTo ctx a
$cfromString :: forall ctx a. IsString a => String -> ConsistentTo ctx a
IsString
           , Eq (ConsistentTo ctx a)
ConsistentTo ctx a
Eq (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> ConsistentTo ctx a
-> (Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> Bool)
-> (ConsistentTo ctx a -> Maybe Int)
-> (ConsistentTo ctx a -> Int)
-> (ConsistentTo ctx a -> Bool)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int -> ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int)
-> Bits (ConsistentTo ctx a)
Int -> ConsistentTo ctx a
ConsistentTo ctx a -> Bool
ConsistentTo ctx a -> Int
ConsistentTo ctx a -> Maybe Int
ConsistentTo ctx a -> ConsistentTo ctx a
ConsistentTo ctx a -> Int -> Bool
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx 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 ctx a. Bits a => Eq (ConsistentTo ctx a)
forall ctx a. Bits a => ConsistentTo ctx a
forall ctx a. Bits a => Int -> ConsistentTo ctx a
forall ctx a. Bits a => ConsistentTo ctx a -> Bool
forall ctx a. Bits a => ConsistentTo ctx a -> Int
forall ctx a. Bits a => ConsistentTo ctx a -> Maybe Int
forall ctx a. Bits a => ConsistentTo ctx a -> ConsistentTo ctx a
forall ctx a. Bits a => ConsistentTo ctx a -> Int -> Bool
forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
forall ctx a.
Bits a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
popCount :: ConsistentTo ctx a -> Int
$cpopCount :: forall ctx a. Bits a => ConsistentTo ctx a -> Int
rotateR :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$crotateR :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
rotateL :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$crotateL :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
unsafeShiftR :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$cunsafeShiftR :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
shiftR :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$cshiftR :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
unsafeShiftL :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$cunsafeShiftL :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
shiftL :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$cshiftL :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
isSigned :: ConsistentTo ctx a -> Bool
$cisSigned :: forall ctx a. Bits a => ConsistentTo ctx a -> Bool
bitSize :: ConsistentTo ctx a -> Int
$cbitSize :: forall ctx a. Bits a => ConsistentTo ctx a -> Int
bitSizeMaybe :: ConsistentTo ctx a -> Maybe Int
$cbitSizeMaybe :: forall ctx a. Bits a => ConsistentTo ctx a -> Maybe Int
testBit :: ConsistentTo ctx a -> Int -> Bool
$ctestBit :: forall ctx a. Bits a => ConsistentTo ctx a -> Int -> Bool
complementBit :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$ccomplementBit :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
clearBit :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$cclearBit :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
setBit :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$csetBit :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
bit :: Int -> ConsistentTo ctx a
$cbit :: forall ctx a. Bits a => Int -> ConsistentTo ctx a
zeroBits :: ConsistentTo ctx a
$czeroBits :: forall ctx a. Bits a => ConsistentTo ctx a
rotate :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$crotate :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
shift :: ConsistentTo ctx a -> Int -> ConsistentTo ctx a
$cshift :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> Int -> ConsistentTo ctx a
complement :: ConsistentTo ctx a -> ConsistentTo ctx a
$ccomplement :: forall ctx a. Bits a => ConsistentTo ctx a -> ConsistentTo ctx a
xor :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cxor :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
.|. :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c.|. :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
.&. :: ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$c.&. :: forall ctx a.
Bits a =>
ConsistentTo ctx a -> ConsistentTo ctx a -> ConsistentTo ctx a
$cp1Bits :: forall ctx a. Bits a => Eq (ConsistentTo ctx a)
Bits
           , Bits (ConsistentTo ctx a)
Bits (ConsistentTo ctx a)
-> (ConsistentTo ctx a -> Int)
-> (ConsistentTo ctx a -> Int)
-> (ConsistentTo ctx a -> Int)
-> FiniteBits (ConsistentTo ctx a)
ConsistentTo ctx a -> Int
forall b.
Bits b -> (b -> Int) -> (b -> Int) -> (b -> Int) -> FiniteBits b
forall ctx a. FiniteBits a => Bits (ConsistentTo ctx a)
forall ctx a. FiniteBits a => ConsistentTo ctx a -> Int
countTrailingZeros :: ConsistentTo ctx a -> Int
$ccountTrailingZeros :: forall ctx a. FiniteBits a => ConsistentTo ctx a -> Int
countLeadingZeros :: ConsistentTo ctx a -> Int
$ccountLeadingZeros :: forall ctx a. FiniteBits a => ConsistentTo ctx a -> Int
finiteBitSize :: ConsistentTo ctx a -> Int
$cfiniteBitSize :: forall ctx a. FiniteBits a => ConsistentTo ctx a -> Int
$cp1FiniteBits :: forall ctx a. FiniteBits a => Bits (ConsistentTo ctx a)
FiniteBits
           )
  deriving ( (a -> b -> Bool)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Bool
(forall a b.
 (a -> b -> Bool)
 -> ConsistentTo ctx a -> ConsistentTo ctx b -> Bool)
-> Eq1 (ConsistentTo ctx)
forall a b.
(a -> b -> Bool)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Bool
forall ctx a b.
(a -> b -> Bool)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Bool
forall (f :: * -> *).
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
liftEq :: (a -> b -> Bool)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Bool
$cliftEq :: forall ctx a b.
(a -> b -> Bool)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Bool
Eq1
           , Eq1 (ConsistentTo ctx)
Eq1 (ConsistentTo ctx)
-> (forall a b.
    (a -> b -> Ordering)
    -> ConsistentTo ctx a -> ConsistentTo ctx b -> Ordering)
-> Ord1 (ConsistentTo ctx)
(a -> b -> Ordering)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Ordering
forall ctx. Eq1 (ConsistentTo ctx)
forall a b.
(a -> b -> Ordering)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Ordering
forall ctx a b.
(a -> b -> Ordering)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Ordering
forall (f :: * -> *).
Eq1 f
-> (forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
liftCompare :: (a -> b -> Ordering)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Ordering
$cliftCompare :: forall ctx a b.
(a -> b -> Ordering)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> Ordering
$cp1Ord1 :: forall ctx. Eq1 (ConsistentTo ctx)
Ord1
           , ReadPrec a -> ReadPrec [a] -> ReadPrec (ConsistentTo ctx a)
ReadPrec a -> ReadPrec [a] -> ReadPrec [ConsistentTo ctx a]
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ConsistentTo ctx a)
(Int -> ReadS a) -> ReadS [a] -> ReadS [ConsistentTo ctx a]
(forall a.
 (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ConsistentTo ctx a))
-> (forall a.
    (Int -> ReadS a) -> ReadS [a] -> ReadS [ConsistentTo ctx a])
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec (ConsistentTo ctx a))
-> (forall a.
    ReadPrec a -> ReadPrec [a] -> ReadPrec [ConsistentTo ctx a])
-> Read1 (ConsistentTo ctx)
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [ConsistentTo ctx a]
forall a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (ConsistentTo ctx a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ConsistentTo ctx a)
forall a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [ConsistentTo ctx a]
forall ctx a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [ConsistentTo ctx a]
forall ctx a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (ConsistentTo ctx a)
forall ctx a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ConsistentTo ctx a)
forall ctx a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [ConsistentTo ctx a]
forall (f :: * -> *).
(forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a))
-> (forall a. (Int -> ReadS a) -> ReadS [a] -> ReadS [f a])
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec (f a))
-> (forall a. ReadPrec a -> ReadPrec [a] -> ReadPrec [f a])
-> Read1 f
liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ConsistentTo ctx a]
$cliftReadListPrec :: forall ctx a.
ReadPrec a -> ReadPrec [a] -> ReadPrec [ConsistentTo ctx a]
liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ConsistentTo ctx a)
$cliftReadPrec :: forall ctx a.
ReadPrec a -> ReadPrec [a] -> ReadPrec (ConsistentTo ctx a)
liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ConsistentTo ctx a]
$cliftReadList :: forall ctx a.
(Int -> ReadS a) -> ReadS [a] -> ReadS [ConsistentTo ctx a]
liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ConsistentTo ctx a)
$cliftReadsPrec :: forall ctx a.
(Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ConsistentTo ctx a)
Read1
           , (Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ConsistentTo ctx a -> ShowS
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [ConsistentTo ctx a] -> ShowS
(forall a.
 (Int -> a -> ShowS)
 -> ([a] -> ShowS) -> Int -> ConsistentTo ctx a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS)
    -> ([a] -> ShowS) -> [ConsistentTo ctx a] -> ShowS)
-> Show1 (ConsistentTo ctx)
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ConsistentTo ctx a -> ShowS
forall a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [ConsistentTo ctx a] -> ShowS
forall ctx a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ConsistentTo ctx a -> ShowS
forall ctx a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [ConsistentTo ctx a] -> ShowS
forall (f :: * -> *).
(forall a.
 (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS)
-> (forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS)
-> Show1 f
liftShowList :: (Int -> a -> ShowS)
-> ([a] -> ShowS) -> [ConsistentTo ctx a] -> ShowS
$cliftShowList :: forall ctx a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> [ConsistentTo ctx a] -> ShowS
liftShowsPrec :: (Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ConsistentTo ctx a -> ShowS
$cliftShowsPrec :: forall ctx a.
(Int -> a -> ShowS)
-> ([a] -> ShowS) -> Int -> ConsistentTo ctx a -> ShowS
Show1
           , a -> ConsistentTo ctx a
(forall a. a -> ConsistentTo ctx a) -> Pointed (ConsistentTo ctx)
forall a. a -> ConsistentTo ctx a
forall ctx a. a -> ConsistentTo ctx a
forall (p :: * -> *). (forall a. a -> p a) -> Pointed p
point :: a -> ConsistentTo ctx a
$cpoint :: forall ctx a. a -> ConsistentTo ctx a
Pointed
           , ConsistentTo ctx a -> a
(forall a. ConsistentTo ctx a -> a) -> Copointed (ConsistentTo ctx)
forall a. ConsistentTo ctx a -> a
forall ctx a. ConsistentTo ctx a -> a
forall (p :: * -> *). (forall a. p a -> a) -> Copointed p
copoint :: ConsistentTo ctx a -> a
$ccopoint :: forall ctx a. ConsistentTo ctx a -> a
Copointed
           , Functor (ConsistentTo ctx)
a -> ConsistentTo ctx a
Functor (ConsistentTo ctx)
-> (forall a. a -> ConsistentTo ctx a)
-> (forall a b.
    ConsistentTo ctx (a -> b)
    -> ConsistentTo ctx a -> ConsistentTo ctx b)
-> (forall a b c.
    (a -> b -> c)
    -> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c)
-> (forall a b.
    ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b)
-> (forall a b.
    ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx a)
-> Applicative (ConsistentTo ctx)
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx a
ConsistentTo ctx (a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
forall ctx. Functor (ConsistentTo ctx)
forall a. a -> ConsistentTo ctx a
forall ctx a. a -> ConsistentTo ctx a
forall a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx a
forall a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
forall a b.
ConsistentTo ctx (a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx a
forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
forall ctx a b.
ConsistentTo ctx (a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
forall a b c.
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
forall ctx a b c.
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx a
$c<* :: forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx a
*> :: ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
$c*> :: forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
liftA2 :: (a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
$cliftA2 :: forall ctx a b c.
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
<*> :: ConsistentTo ctx (a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
$c<*> :: forall ctx a b.
ConsistentTo ctx (a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
pure :: a -> ConsistentTo ctx a
$cpure :: forall ctx a. a -> ConsistentTo ctx a
$cp1Applicative :: forall ctx. Functor (ConsistentTo ctx)
Applicative
           , Monad (ConsistentTo ctx)
Monad (ConsistentTo ctx)
-> (forall a. (a -> ConsistentTo ctx a) -> ConsistentTo ctx a)
-> MonadFix (ConsistentTo ctx)
(a -> ConsistentTo ctx a) -> ConsistentTo ctx a
forall ctx. Monad (ConsistentTo ctx)
forall a. (a -> ConsistentTo ctx a) -> ConsistentTo ctx a
forall ctx a. (a -> ConsistentTo ctx a) -> ConsistentTo ctx a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
mfix :: (a -> ConsistentTo ctx a) -> ConsistentTo ctx a
$cmfix :: forall ctx a. (a -> ConsistentTo ctx a) -> ConsistentTo ctx a
$cp1MonadFix :: forall ctx. Monad (ConsistentTo ctx)
MonadFix
           , Applicative (ConsistentTo ctx)
a -> ConsistentTo ctx a
Applicative (ConsistentTo ctx)
-> (forall a b.
    ConsistentTo ctx a
    -> (a -> ConsistentTo ctx b) -> ConsistentTo ctx b)
-> (forall a b.
    ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b)
-> (forall a. a -> ConsistentTo ctx a)
-> Monad (ConsistentTo ctx)
ConsistentTo ctx a
-> (a -> ConsistentTo ctx b) -> ConsistentTo ctx b
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
forall ctx. Applicative (ConsistentTo ctx)
forall a. a -> ConsistentTo ctx a
forall ctx a. a -> ConsistentTo ctx a
forall a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
forall a b.
ConsistentTo ctx a
-> (a -> ConsistentTo ctx b) -> ConsistentTo ctx b
forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
forall ctx a b.
ConsistentTo ctx a
-> (a -> ConsistentTo ctx b) -> ConsistentTo ctx b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> ConsistentTo ctx a
$creturn :: forall ctx a. a -> ConsistentTo ctx a
>> :: ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
$c>> :: forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx b
>>= :: ConsistentTo ctx a
-> (a -> ConsistentTo ctx b) -> ConsistentTo ctx b
$c>>= :: forall ctx a b.
ConsistentTo ctx a
-> (a -> ConsistentTo ctx b) -> ConsistentTo ctx b
$cp1Monad :: forall ctx. Applicative (ConsistentTo ctx)
Monad
           , Monad (ConsistentTo ctx)
Monad (ConsistentTo ctx)
-> (forall a b.
    ConsistentTo ctx a
    -> ConsistentTo ctx b -> ConsistentTo ctx (a, b))
-> (forall a b c.
    (a -> b -> c)
    -> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c)
-> (forall a b.
    ConsistentTo ctx (a, b)
    -> (ConsistentTo ctx a, ConsistentTo ctx b))
-> MonadZip (ConsistentTo ctx)
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx (a, b)
ConsistentTo ctx (a, b) -> (ConsistentTo ctx a, ConsistentTo ctx b)
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
forall ctx. Monad (ConsistentTo ctx)
forall a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx (a, b)
forall a b.
ConsistentTo ctx (a, b) -> (ConsistentTo ctx a, ConsistentTo ctx b)
forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx (a, b)
forall ctx a b.
ConsistentTo ctx (a, b) -> (ConsistentTo ctx a, ConsistentTo ctx b)
forall a b c.
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
forall ctx a b c.
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
forall (m :: * -> *).
Monad m
-> (forall a b. m a -> m b -> m (a, b))
-> (forall a b c. (a -> b -> c) -> m a -> m b -> m c)
-> (forall a b. m (a, b) -> (m a, m b))
-> MonadZip m
munzip :: ConsistentTo ctx (a, b) -> (ConsistentTo ctx a, ConsistentTo ctx b)
$cmunzip :: forall ctx a b.
ConsistentTo ctx (a, b) -> (ConsistentTo ctx a, ConsistentTo ctx b)
mzipWith :: (a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
$cmzipWith :: forall ctx a b c.
(a -> b -> c)
-> ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx c
mzip :: ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx (a, b)
$cmzip :: forall ctx a b.
ConsistentTo ctx a -> ConsistentTo ctx b -> ConsistentTo ctx (a, b)
$cp1MonadZip :: forall ctx. Monad (ConsistentTo ctx)
MonadZip
           , Functor (ConsistentTo ctx)
Functor (ConsistentTo ctx)
-> (forall a. ConsistentTo ctx a -> a)
-> (forall a.
    ConsistentTo ctx a -> ConsistentTo ctx (ConsistentTo ctx a))
-> (forall a b.
    (ConsistentTo ctx a -> b)
    -> ConsistentTo ctx a -> ConsistentTo ctx b)
-> Comonad (ConsistentTo ctx)
ConsistentTo ctx a -> a
ConsistentTo ctx a -> ConsistentTo ctx (ConsistentTo ctx a)
(ConsistentTo ctx a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
forall ctx. Functor (ConsistentTo ctx)
forall a. ConsistentTo ctx a -> a
forall a.
ConsistentTo ctx a -> ConsistentTo ctx (ConsistentTo ctx a)
forall ctx a. ConsistentTo ctx a -> a
forall ctx a.
ConsistentTo ctx a -> ConsistentTo ctx (ConsistentTo ctx a)
forall a b.
(ConsistentTo ctx a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
forall ctx a b.
(ConsistentTo ctx a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
forall (w :: * -> *).
Functor w
-> (forall a. w a -> a)
-> (forall a. w a -> w (w a))
-> (forall a b. (w a -> b) -> w a -> w b)
-> Comonad w
extend :: (ConsistentTo ctx a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
$cextend :: forall ctx a b.
(ConsistentTo ctx a -> b)
-> ConsistentTo ctx a -> ConsistentTo ctx b
duplicate :: ConsistentTo ctx a -> ConsistentTo ctx (ConsistentTo ctx a)
$cduplicate :: forall ctx a.
ConsistentTo ctx a -> ConsistentTo ctx (ConsistentTo ctx a)
extract :: ConsistentTo ctx a -> a
$cextract :: forall ctx a. ConsistentTo ctx a -> a
$cp1Comonad :: forall ctx. Functor (ConsistentTo ctx)
Comonad
           )
           via Identity

-- | An accessor function for something 'ConsistentTo'.
_theConsistentTo :: ConsistentTo ctx x -> x
_theConsistentTo :: ConsistentTo ctx x -> x
_theConsistentTo (ConsistentTo !x
x) = x
x
{-# INLINE _theConsistentTo #-}

-- | A lens for something 'ConsistentTo'.
theConsistentTo :: forall ctx a b p f. (Profunctor p, Functor f) => p a (f b) -> p (ConsistentTo ctx a) (f (ConsistentTo ctx b))
theConsistentTo :: p a (f b) -> p (ConsistentTo ctx a) (f (ConsistentTo ctx b))
theConsistentTo = (ConsistentTo ctx a -> a)
-> (f b -> f (ConsistentTo ctx b))
-> p a (f b)
-> p (ConsistentTo ctx a) (f (ConsistentTo ctx b))
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap ConsistentTo ctx a -> a
forall ctx a. ConsistentTo ctx a -> a
_theConsistentTo ((b -> ConsistentTo ctx b) -> f b -> f (ConsistentTo ctx b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> ConsistentTo ctx b
forall ctx a. a -> ConsistentTo ctx a
ConsistentTo)
{-# INLINE theConsistentTo #-}