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

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

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

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

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

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