Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Hedgehog.Internal.Prelude
Description
Mostly for compatibility across different base Prelude changes.
Documentation
Minimal complete definition
Instances
class Monad m => MonadFail (m :: Type -> Type) #
Minimal complete definition
Instances
Instances
Bits Int | |
Defined in GHC.Bits Methods complement :: Int -> Int complementBit :: Int -> Int -> Int bitSizeMaybe :: Int -> Maybe Int unsafeShiftL :: Int -> Int -> Int unsafeShiftR :: Int -> Int -> Int | |
FiniteBits Int | |
Defined in GHC.Bits | |
Bounded Int | |
Enum Int | |
Num Int | |
Read Int | |
Integral Int | |
Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
Show Int | |
PrintfArg Int | |
Defined in Text.Printf | |
NFData Int | |
Defined in Control.DeepSeq | |
Eq Int | |
Ord Int | |
Hashable Int | |
Defined in Data.Hashable.Class | |
Random Int | |
Uniform Int | |
Defined in System.Random.Internal | |
UniformRange Int | |
Defined in System.Random.Internal | |
Pretty Int | |
Defined in Text.PrettyPrint.Annotated.WL | |
Lift Int | |
Generic1 (URec Int :: k -> Type) | |
Foldable (UInt :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
Traversable (UInt :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Int :: Type -> Type) | |
Generic (URec Int p) | |
Show (URec Int p) | |
Eq (URec Int p) | |
Ord (URec Int p) | |
data URec Int (p :: k) | |
Defined in GHC.Generics | |
type Rep1 (URec Int :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Int p) | |
Defined in GHC.Generics |
Instances
Bits Bool | |
Defined in GHC.Bits | |
FiniteBits Bool | |
Defined in GHC.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |
Bounded Bool | |
Enum Bool | |
Generic Bool | |
SingKind Bool | |
Defined in GHC.Generics Associated Types type DemoteRep Bool | |
Read Bool | |
Show Bool | |
NFData Bool | |
Defined in Control.DeepSeq | |
Eq Bool | |
Ord Bool | |
Hashable Bool | |
Defined in Data.Hashable.Class | |
Random Bool | |
Uniform Bool | |
Defined in System.Random.Internal | |
UniformRange Bool | |
Defined in System.Random.Internal | |
Pretty Bool | |
Defined in Text.PrettyPrint.Annotated.WL | |
SingI 'False | |
Defined in GHC.Generics | |
SingI 'True | |
Defined in GHC.Generics | |
Lift Bool | |
type DemoteRep Bool | |
Defined in GHC.Generics | |
type Rep Bool | |
Defined in GHC.Generics | |
data Sing (a :: Bool) | |
Instances
Bounded Char | |
Enum Char | |
Read Char | |
Show Char | |
IsChar Char | |
PrintfArg Char | |
Defined in Text.Printf | |
Outputable String | |
Defined in System.Console.Concurrent.Internal | |
ToRegionContent String | |
Defined in System.Console.Regions Methods | |
NFData Char | |
Defined in Control.DeepSeq | |
Eq Char | |
Ord Char | |
Hashable Char | |
Defined in Data.Hashable.Class | |
Random Char | |
Uniform Char | |
Defined in System.Random.Internal | |
UniformRange Char | |
Defined in System.Random.Internal | |
ErrorList Char | |
Defined in Control.Monad.Trans.Error | |
Pretty Char | |
Defined in Text.PrettyPrint.Annotated.WL | |
Lift Char | |
Generic1 (URec Char :: k -> Type) | |
Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
Traversable (UChar :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Char :: Type -> Type) | |
Generic (URec Char p) | |
Show (URec Char p) | |
Eq (URec Char p) | |
Ord (URec Char p) | |
Defined in GHC.Generics | |
data URec Char (p :: k) | |
Defined in GHC.Generics | |
type Compare (a :: Char) (b :: Char) | |
Defined in Data.Type.Ord | |
type Rep1 (URec Char :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Char p) | |
Defined in GHC.Generics |
Instances
Floating Double | |
RealFloat Double | |
Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # | |
Read Double | |
PrintfArg Double | |
Defined in Text.Printf | |
NFData Double | |
Defined in Control.DeepSeq | |
Erf Double | |
InvErf Double | |
Eq Double | |
Ord Double | |
Hashable Double | |
Defined in Data.Hashable.Class | |
Random Double | |
UniformRange Double | |
Defined in System.Random.Internal | |
Pretty Double | |
Defined in Text.PrettyPrint.Annotated.WL | |
Lift Double | |
Generic1 (URec Double :: k -> Type) | |
Foldable (UDouble :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
Traversable (UDouble :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Double :: Type -> Type) | |
Generic (URec Double p) | |
Show (URec Double p) | |
Eq (URec Double p) | |
Ord (URec Double p) | |
Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
data URec Double (p :: k) | |
Defined in GHC.Generics | |
type Rep1 (URec Double :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Double p) | |
Defined in GHC.Generics |
Instances
Floating Float | |
RealFloat Float | |
Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # | |
Read Float | |
PrintfArg Float | |
Defined in Text.Printf | |
NFData Float | |
Defined in Control.DeepSeq | |
Erf Float | |
InvErf Float | |
Eq Float | |
Ord Float | |
Hashable Float | |
Defined in Data.Hashable.Class | |
Random Float | |
UniformRange Float | |
Defined in System.Random.Internal | |
Pretty Float | |
Defined in Text.PrettyPrint.Annotated.WL | |
Lift Float | |
Generic1 (URec Float :: k -> Type) | |
Foldable (UFloat :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
Traversable (UFloat :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Float :: Type -> Type) | |
Generic (URec Float p) | |
Show (URec Float p) | |
Eq (URec Float p) | |
Ord (URec Float p) | |
Defined in GHC.Generics | |
data URec Float (p :: k) | |
Defined in GHC.Generics | |
type Rep1 (URec Float :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Float p) | |
Defined in GHC.Generics |
Instances
Bits Word | |
Defined in GHC.Bits | |
FiniteBits Word | |
Defined in GHC.Bits Methods finiteBitSize :: Word -> Int countLeadingZeros :: Word -> Int countTrailingZeros :: Word -> Int | |
Bounded Word | |
Enum Word | |
Num Word | |
Read Word | |
Integral Word | |
Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
Show Word | |
PrintfArg Word | |
Defined in Text.Printf | |
NFData Word | |
Defined in Control.DeepSeq | |
Eq Word | |
Ord Word | |
Hashable Word | |
Defined in Data.Hashable.Class | |
Random Word | |
Uniform Word | |
Defined in System.Random.Internal | |
UniformRange Word | |
Defined in System.Random.Internal | |
Pretty Word | |
Defined in Text.PrettyPrint.Annotated.WL | |
Lift Word | |
Generic1 (URec Word :: k -> Type) | |
Foldable (UWord :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |
Traversable (UWord :: Type -> Type) | |
Defined in Data.Traversable | |
Functor (URec Word :: Type -> Type) | |
Generic (URec Word p) | |
Show (URec Word p) | |
Eq (URec Word p) | |
Ord (URec Word p) | |
Defined in GHC.Generics | |
data URec Word (p :: k) | |
Defined in GHC.Generics | |
type Rep1 (URec Word :: k -> Type) | |
Defined in GHC.Generics | |
type Rep (URec Word p) | |
Defined in GHC.Generics |
Instances
Monoid Ordering | |
Semigroup Ordering | |
Bounded Ordering | |
Enum Ordering | |
Generic Ordering | |
Read Ordering | |
Show Ordering | |
NFData Ordering | |
Defined in Control.DeepSeq | |
Eq Ordering | |
Ord Ordering | |
Defined in GHC.Classes | |
Hashable Ordering | |
Defined in Data.Hashable.Class | |
type Rep Ordering | |
Instances
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
MonadZip Maybe | |
Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Eq1 Maybe | |
Ord1 Maybe | |
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |
Read1 Maybe | |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] | |
Show1 Maybe | |
Defined in Data.Functor.Classes | |
Traversable Maybe | |
Alternative Maybe | |
Applicative Maybe | |
Functor Maybe | |
Monad Maybe | |
MonadPlus Maybe | |
NFData1 Maybe | |
Defined in Control.DeepSeq | |
MonadThrow Maybe | |
Defined in Control.Monad.Catch | |
Hashable1 Maybe | |
Defined in Data.Hashable.Class | |
Generic1 Maybe | |
MonadBaseControl Maybe Maybe | |
Defined in Control.Monad.Trans.Control Associated Types type StM Maybe a | |
MonadError () Maybe | |
Defined in Control.Monad.Error.Class | |
MonadBase Maybe Maybe | |
Defined in Control.Monad.Base | |
Lift a => Lift (Maybe a :: Type) | |
Semigroup a => Monoid (Maybe a) | |
Semigroup a => Semigroup (Maybe a) | |
Generic (Maybe a) | |
SingKind a => SingKind (Maybe a) | |
Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) | |
Read a => Read (Maybe a) | |
Show a => Show (Maybe a) | |
NFData a => NFData (Maybe a) | |
Defined in Control.DeepSeq | |
Eq a => Eq (Maybe a) | |
Ord a => Ord (Maybe a) | |
Hashable a => Hashable (Maybe a) | |
Defined in Data.Hashable.Class | |
Pretty a => Pretty (Maybe a) | |
Defined in Text.PrettyPrint.Annotated.WL | |
SingI ('Nothing :: Maybe a) | |
Defined in GHC.Generics | |
SingI a2 => SingI ('Just a2 :: Maybe a1) | |
Defined in GHC.Generics | |
type Rep1 Maybe | |
type StM Maybe a | |
Defined in Control.Monad.Trans.Control type StM Maybe a = a | |
type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
type Rep (Maybe a) | |
Defined in GHC.Generics | |
data Sing (b :: Maybe a) | |
Instances
Instances
class Semigroup a => Monoid a where #
Minimal complete definition
Instances
Monoid ByteArray | |
Monoid All | |
Monoid Any | |
Monoid Builder | |
Monoid ByteString | |
Monoid ByteString | |
Monoid ShortByteString | |
Monoid IntSet | |
Monoid Ordering | |
Monoid Cover Source # | |
Monoid CoverCount Source # | |
Defined in Hedgehog.Internal.Property Methods mempty :: CoverCount # mappend :: CoverCount -> CoverCount -> CoverCount # mconcat :: [CoverCount] -> CoverCount # | |
Monoid Journal Source # | |
Monoid LabelName Source # | |
Monoid Summary Source # | |
Monoid Doc | |
Monoid () | |
(Semigroup a, Monoid a) => Monoid (Concurrently a) | |
FiniteBits a => Monoid (And a) | |
FiniteBits a => Monoid (Iff a) | |
Bits a => Monoid (Ior a) | |
Bits a => Monoid (Xor a) | |
Monoid a => Monoid (Identity a) | |
Ord a => Monoid (Max a) | |
Ord a => Monoid (Min a) | |
Monoid (First a) | |
Monoid (Last a) | |
Monoid a => Monoid (Down a) | |
(Ord a, Bounded a) => Monoid (Max a) | |
(Ord a, Bounded a) => Monoid (Min a) | |
Monoid m => Monoid (WrappedMonoid m) | |
Monoid a => Monoid (Dual a) | |
Monoid (Endo a) | |
Num a => Monoid (Product a) | |
Num a => Monoid (Sum a) | |
Monoid a => Monoid (STM a) | |
(Generic a, Monoid (Rep a ())) => Monoid (Generically a) | |
Monoid p => Monoid (Par1 p) | |
Num a => Monoid (AlphaColour a) | |
Defined in Data.Colour.Internal Methods mempty :: AlphaColour a # mappend :: AlphaColour a -> AlphaColour a -> AlphaColour a # mconcat :: [AlphaColour a] -> AlphaColour a # | |
Num a => Monoid (Colour a) | |
Monoid (IntMap a) | |
Monoid (Seq a) | |
Monoid (MergeSet a) | |
Ord a => Monoid (Set a) | |
Monoid a => Monoid (IO a) | |
(Semigroup a, Monoid a) => Monoid (Coverage a) Source # | |
Monoid (Doc a) | |
Monoid a => Monoid (Q a) | |
Monoid (Doc a) | |
Semigroup a => Monoid (Maybe a) | |
Monoid a => Monoid (a) | |
Monoid [a] | |
Monoid (Proxy s) | |
Monoid (U1 p) | |
Monoid a => Monoid (ST s a) | |
Ord k => Monoid (Map k v) | |
(Monad m, Monoid a) => Monoid (GenT m a) Source # | |
(MonadBaseControl IO m, Semigroup a, Monoid a) => Monoid (Concurrently m a) | |
Monoid b => Monoid (a -> b) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid a => Monoid (Const a b) | |
(Applicative f, Monoid a) => Monoid (Ap f a) | |
Alternative f => Monoid (Alt f a) | |
Monoid (f p) => Monoid (Rec1 f p) | |
(Semigroup a, Monoid a) => Monoid (Tagged s a) | |
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
(Monoid (f a), Monoid (g a)) => Monoid (Product f g a) | |
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
Monoid c => Monoid (K1 i c p) | |
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
Monoid (f (g a)) => Monoid (Compose f g a) | |
Monoid (f (g p)) => Monoid ((f :.: g) p) | |
Monoid (f p) => Monoid (M1 i c f p) | |
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
Instances
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative Concurrently | |
Defined in Control.Concurrent.Async | |
Applicative ZipList | |
Applicative Complex | |
Applicative Identity | |
Applicative First | |
Applicative Last | |
Applicative Down | |
Applicative First | |
Applicative Last | |
Applicative Max | |
Applicative Min | |
Applicative Dual | |
Applicative Product | |
Applicative Sum | |
Applicative STM | |
Applicative Par1 | |
Applicative P | |
Applicative ReadP | |
Applicative ReadPrec | |
Applicative Put | |
Applicative Seq | |
Applicative Tree | |
Applicative IO | |
Applicative Q | |
Applicative NonEmpty | |
Applicative Maybe | |
Applicative Solo | |
Applicative [] | |
Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
Arrow a => Applicative (ArrowMonad a) | |
Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 # | |
Applicative (ST s) | |
Applicative (Either e) | |
Applicative (StateL s) | |
Applicative (StateR s) | |
Applicative (Proxy :: Type -> Type) | |
Applicative (U1 :: Type -> Type) | |
Applicative (ST s) | |
Monad m => Applicative (GenT m) Source # | |
Monad m => Applicative (PropertyT m) Source # | |
Defined in Hedgehog.Internal.Property | |
Monad m => Applicative (TestT m) Source # | |
Applicative m => Applicative (NodeT m) Source # | |
Applicative m => Applicative (TreeT m) Source # | |
MonadBaseControl IO m => Applicative (Concurrently m) | |
Defined in Control.Concurrent.Async.Lifted Methods pure :: a -> Concurrently m a # (<*>) :: Concurrently m (a -> b) -> Concurrently m a -> Concurrently m b # liftA2 :: (a -> b -> c) -> Concurrently m a -> Concurrently m b -> Concurrently m c (*>) :: Concurrently m a -> Concurrently m b -> Concurrently m b # (<*) :: Concurrently m a -> Concurrently m b -> Concurrently m a # | |
Applicative m => Applicative (ResourceT m) | |
Defined in Control.Monad.Trans.Resource.Internal | |
Applicative m => Applicative (ListT m) | |
(Functor m, Monad m) => Applicative (MaybeT m) | |
Monoid a => Applicative ((,) a) | |
Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
Applicative m => Applicative (Kleisli m a) | |
Defined in Control.Arrow | |
Monoid m => Applicative (Const m :: Type -> Type) | |
Applicative f => Applicative (Ap f) | |
Applicative f => Applicative (Alt f) | |
(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | |
Defined in GHC.Generics Methods pure :: a -> Generically1 f a # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a # | |
Applicative f => Applicative (Rec1 f) | |
(Applicative f, Monad f) => Applicative (WhenMissing f x) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a # | |
Applicative (Tagged s) | |
(Monoid w, Functor m, Monad m) => Applicative (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
(Functor m, Monad m) => Applicative (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
(Functor m, Monad m) => Applicative (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
(Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
(Functor m, Monad m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(Monoid a, Monoid b) => Applicative ((,,) a b) | |
(Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
(Applicative f, Applicative g) => Applicative (f :*: g) | |
Monoid c => Applicative (K1 i c :: Type -> Type) | |
(Monad f, Applicative f) => Applicative (WhenMatched f x y) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a # | |
(Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a # | |
Applicative (ContT r m) | |
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Base | |
Applicative ((->) r) | |
(Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
(Applicative f, Applicative g) => Applicative (f :.: g) | |
Applicative f => Applicative (M1 i c f) | |
(Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a # | |
(Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad Complex | |
Monad Identity | |
Monad First | |
Monad Last | |
Monad Down | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad Dual | |
Monad Product | |
Monad Sum | |
Monad STM | |
Monad Par1 | |
Monad P | |
Monad ReadP | |
Monad ReadPrec | |
Monad Put | |
Monad Seq | |
Monad Tree | |
Monad IO | |
Monad Q | |
Monad NonEmpty | |
Monad Maybe | |
Monad Solo | |
Monad [] | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (ST s) | |
Monad (Either e) | |
Monad (Proxy :: Type -> Type) | |
Monad (U1 :: Type -> Type) | |
Monad (ST s) | |
Monad m => Monad (GenT m) Source # | |
Monad m => Monad (PropertyT m) Source # | |
Monad m => Monad (TestT m) Source # | |
Monad m => Monad (NodeT m) Source # | |
Monad m => Monad (TreeT m) Source # | |
Monad m => Monad (ResourceT m) | |
Monad m => Monad (ListT m) | |
Monad m => Monad (MaybeT m) | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (Kleisli m a) | |
Monad f => Monad (Ap f) | |
Monad f => Monad (Alt f) | |
Monad f => Monad (Rec1 f) | |
(Applicative f, Monad f) => Monad (WhenMissing f x) | |
Monad (Tagged s) | |
(Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
(Monad m, Error e) => Monad (ErrorT e m) | |
Monad m => Monad (ExceptT e m) | |
Monad m => Monad (IdentityT m) | |
Monad m => Monad (ReaderT r m) | |
Monad m => Monad (SelectT r m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
(Monad f, Monad g) => Monad (Product f g) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monad f, Applicative f) => Monad (WhenMatched f x y) | |
(Applicative f, Monad f) => Monad (WhenMissing f k x) | |
Monad (ContT r m) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
Monad ((->) r) | |
Monad f => Monad (M1 i c f) | |
(Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
Monad m => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #
Methods
traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #
sequenceA :: Applicative f => t (f a) -> f (t a) #
Instances
class Foldable (t :: Type -> Type) where #
Methods
foldMap :: Monoid m => (a -> m) -> t a -> m #
foldr :: (a -> b -> b) -> b -> t a -> b #
foldl :: (b -> a -> b) -> b -> t a -> b #
foldr1 :: (a -> a -> a) -> t a -> a #
foldl1 :: (a -> a -> a) -> t a -> a #
elem :: Eq a => a -> t a -> Bool #
maximum :: Ord a => t a -> a #
Instances
Foldable ZipList | |
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
Foldable Complex | |
Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m foldMap :: Monoid m => (a -> m) -> Complex a -> m # foldMap' :: Monoid m => (a -> m) -> Complex a -> m foldr :: (a -> b -> b) -> b -> Complex a -> b # foldr' :: (a -> b -> b) -> b -> Complex a -> b foldl :: (b -> a -> b) -> b -> Complex a -> b # foldl' :: (b -> a -> b) -> b -> Complex a -> b foldr1 :: (a -> a -> a) -> Complex a -> a # foldl1 :: (a -> a -> a) -> Complex a -> a # toList :: Complex a -> [a] elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
Foldable Identity | |
Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
Foldable First | |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Down | |
Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # | |
Foldable First | |
Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
Foldable Last | |
Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
Foldable Max | |
Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # toList :: Max a -> [a] elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
Foldable Min | |
Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # toList :: Min a -> [a] elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
Foldable Dual | |
Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
Foldable Product | |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
Foldable Sum | |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
Foldable Par1 | |
Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # toList :: Par1 a -> [a] elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
Foldable IntMap | |
Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # toList :: IntMap a -> [a] elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # | |
Foldable Digit | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldMap' :: Monoid m => (a -> m) -> Digit a -> m foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # toList :: Digit a -> [a] elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # | |
Foldable Elem | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldMap' :: Monoid m => (a -> m) -> Elem a -> m foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # toList :: Elem a -> [a] elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # | |
Foldable FingerTree | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # | |
Foldable Node | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # toList :: Node a -> [a] elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
Foldable Seq | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # | |
Foldable ViewL | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # toList :: ViewL a -> [a] elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # | |
Foldable ViewR | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # toList :: ViewR a -> [a] elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # | |
Foldable Set | |
Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
Foldable Tree | |
Defined in Data.Tree Methods fold :: Monoid m => Tree m -> m foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldMap' :: Monoid m => (a -> m) -> Tree a -> m foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # toList :: Tree a -> [a] elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
Foldable Hashed | |
Defined in Data.Hashable.Class Methods fold :: Monoid m => Hashed m -> m foldMap :: Monoid m => (a -> m) -> Hashed a -> m # foldMap' :: Monoid m => (a -> m) -> Hashed a -> m foldr :: (a -> b -> b) -> b -> Hashed a -> b # foldr' :: (a -> b -> b) -> b -> Hashed a -> b foldl :: (b -> a -> b) -> b -> Hashed a -> b # foldl' :: (b -> a -> b) -> b -> Hashed a -> b foldr1 :: (a -> a -> a) -> Hashed a -> a # foldl1 :: (a -> a -> a) -> Hashed a -> a # toList :: Hashed a -> [a] elem :: Eq a => a -> Hashed a -> Bool # maximum :: Ord a => Hashed a -> a # minimum :: Ord a => Hashed a -> a # | |
Foldable Coverage Source # | |
Defined in Hedgehog.Internal.Property Methods fold :: Monoid m => Coverage m -> m foldMap :: Monoid m => (a -> m) -> Coverage a -> m # foldMap' :: Monoid m => (a -> m) -> Coverage a -> m foldr :: (a -> b -> b) -> b -> Coverage a -> b # foldr' :: (a -> b -> b) -> b -> Coverage a -> b foldl :: (b -> a -> b) -> b -> Coverage a -> b # foldl' :: (b -> a -> b) -> b -> Coverage a -> b foldr1 :: (a -> a -> a) -> Coverage a -> a # foldl1 :: (a -> a -> a) -> Coverage a -> a # elem :: Eq a => a -> Coverage a -> Bool # maximum :: Ord a => Coverage a -> a # minimum :: Ord a => Coverage a -> a # | |
Foldable Label Source # | |
Defined in Hedgehog.Internal.Property Methods fold :: Monoid m => Label m -> m foldMap :: Monoid m => (a -> m) -> Label a -> m # foldMap' :: Monoid m => (a -> m) -> Label a -> m foldr :: (a -> b -> b) -> b -> Label a -> b # foldr' :: (a -> b -> b) -> b -> Label a -> b foldl :: (b -> a -> b) -> b -> Label a -> b # foldl' :: (b -> a -> b) -> b -> Label a -> b foldr1 :: (a -> a -> a) -> Label a -> a # foldl1 :: (a -> a -> a) -> Label a -> a # elem :: Eq a => a -> Label a -> Bool # maximum :: Ord a => Label a -> a # minimum :: Ord a => Label a -> a # | |
Foldable Report Source # | |
Defined in Hedgehog.Internal.Report Methods fold :: Monoid m => Report m -> m foldMap :: Monoid m => (a -> m) -> Report a -> m # foldMap' :: Monoid m => (a -> m) -> Report a -> m foldr :: (a -> b -> b) -> b -> Report a -> b # foldr' :: (a -> b -> b) -> b -> Report a -> b foldl :: (b -> a -> b) -> b -> Report a -> b # foldl' :: (b -> a -> b) -> b -> Report a -> b foldr1 :: (a -> a -> a) -> Report a -> a # foldl1 :: (a -> a -> a) -> Report a -> a # elem :: Eq a => a -> Report a -> Bool # maximum :: Ord a => Report a -> a # minimum :: Ord a => Report a -> a # | |
Foldable Concrete Source # | |
Defined in Hedgehog.Internal.State Methods fold :: Monoid m => Concrete m -> m foldMap :: Monoid m => (a -> m) -> Concrete a -> m # foldMap' :: Monoid m => (a -> m) -> Concrete a -> m foldr :: (a -> b -> b) -> b -> Concrete a -> b # foldr' :: (a -> b -> b) -> b -> Concrete a -> b foldl :: (b -> a -> b) -> b -> Concrete a -> b # foldl' :: (b -> a -> b) -> b -> Concrete a -> b foldr1 :: (a -> a -> a) -> Concrete a -> a # foldl1 :: (a -> a -> a) -> Concrete a -> a # elem :: Eq a => a -> Concrete a -> Bool # maximum :: Ord a => Concrete a -> a # minimum :: Ord a => Concrete a -> a # | |
Foldable Node Source # | |
Defined in Hedgehog.Internal.Tree Methods fold :: Monoid m => Node m -> m foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
Foldable Tree Source # | |
Defined in Hedgehog.Internal.Tree Methods fold :: Monoid m => Tree m -> m foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldMap' :: Monoid m => (a -> m) -> Tree a -> m foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
Foldable Window | |
Defined in System.Console.Terminal.Common Methods fold :: Monoid m => Window m -> m foldMap :: Monoid m => (a -> m) -> Window a -> m # foldMap' :: Monoid m => (a -> m) -> Window a -> m foldr :: (a -> b -> b) -> b -> Window a -> b # foldr' :: (a -> b -> b) -> b -> Window a -> b foldl :: (b -> a -> b) -> b -> Window a -> b # foldl' :: (b -> a -> b) -> b -> Window a -> b foldr1 :: (a -> a -> a) -> Window a -> a # foldl1 :: (a -> a -> a) -> Window a -> a # elem :: Eq a => a -> Window a -> Bool # maximum :: Ord a => Window a -> a # minimum :: Ord a => Window a -> a # | |
Foldable SimpleDoc | |
Defined in Text.PrettyPrint.Annotated.WL Methods fold :: Monoid m => SimpleDoc m -> m foldMap :: Monoid m => (a -> m) -> SimpleDoc a -> m # foldMap' :: Monoid m => (a -> m) -> SimpleDoc a -> m foldr :: (a -> b -> b) -> b -> SimpleDoc a -> b # foldr' :: (a -> b -> b) -> b -> SimpleDoc a -> b foldl :: (b -> a -> b) -> b -> SimpleDoc a -> b # foldl' :: (b -> a -> b) -> b -> SimpleDoc a -> b foldr1 :: (a -> a -> a) -> SimpleDoc a -> a # foldl1 :: (a -> a -> a) -> SimpleDoc a -> a # toList :: SimpleDoc a -> [a] length :: SimpleDoc a -> Int # elem :: Eq a => a -> SimpleDoc a -> Bool # maximum :: Ord a => SimpleDoc a -> a # minimum :: Ord a => SimpleDoc a -> a # | |
Foldable NonEmpty | |
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # | |
Foldable Solo | |
Defined in Data.Foldable Methods fold :: Monoid m => Solo m -> m foldMap :: Monoid m => (a -> m) -> Solo a -> m # foldMap' :: Monoid m => (a -> m) -> Solo a -> m foldr :: (a -> b -> b) -> b -> Solo a -> b # foldr' :: (a -> b -> b) -> b -> Solo a -> b foldl :: (b -> a -> b) -> b -> Solo a -> b # foldl' :: (b -> a -> b) -> b -> Solo a -> b foldr1 :: (a -> a -> a) -> Solo a -> a # foldl1 :: (a -> a -> a) -> Solo a -> a # toList :: Solo a -> [a] elem :: Eq a => a -> Solo a -> Bool # maximum :: Ord a => Solo a -> a # | |
Foldable [] | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> [a] -> m # foldMap' :: Monoid m => (a -> m) -> [a] -> m foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Foldable (Proxy :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # toList :: Proxy a -> [a] elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # minimum :: Ord a => Proxy a -> a # | |
Foldable (Arg a) | |
Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # toList :: Arg a a0 -> [a0] elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
Foldable (Array i) | |
Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
Foldable (U1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # toList :: U1 a -> [a] elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
Foldable (UAddr :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # toList :: UAddr a -> [a] elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # minimum :: Ord a => UAddr a -> a # | |
Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
Foldable (UDouble :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
Foldable (UFloat :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
Foldable (UInt :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
Foldable (UWord :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |
Foldable (V1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
Foldable (Map k) | |
Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # toList :: Map k a -> [a] elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
Foldable (Vec n) Source # | |
Defined in Hedgehog.Internal.Gen Methods fold :: Monoid m => Vec n m -> m foldMap :: Monoid m => (a -> m) -> Vec n a -> m # foldMap' :: Monoid m => (a -> m) -> Vec n a -> m foldr :: (a -> b -> b) -> b -> Vec n a -> b # foldr' :: (a -> b -> b) -> b -> Vec n a -> b foldl :: (b -> a -> b) -> b -> Vec n a -> b # foldl' :: (b -> a -> b) -> b -> Vec n a -> b foldr1 :: (a -> a -> a) -> Vec n a -> a # foldl1 :: (a -> a -> a) -> Vec n a -> a # elem :: Eq a => a -> Vec n a -> Bool # maximum :: Ord a => Vec n a -> a # minimum :: Ord a => Vec n a -> a # | |
Foldable f => Foldable (ListT f) | |
Defined in Control.Monad.Trans.List Methods fold :: Monoid m => ListT f m -> m foldMap :: Monoid m => (a -> m) -> ListT f a -> m # foldMap' :: Monoid m => (a -> m) -> ListT f a -> m foldr :: (a -> b -> b) -> b -> ListT f a -> b # foldr' :: (a -> b -> b) -> b -> ListT f a -> b foldl :: (b -> a -> b) -> b -> ListT f a -> b # foldl' :: (b -> a -> b) -> b -> ListT f a -> b foldr1 :: (a -> a -> a) -> ListT f a -> a # foldl1 :: (a -> a -> a) -> ListT f a -> a # toList :: ListT f a -> [a] elem :: Eq a => a -> ListT f a -> Bool # maximum :: Ord a => ListT f a -> a # minimum :: Ord a => ListT f a -> a # | |
Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
Foldable ((,) a) | |
Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # toList :: (a, a0) -> [a0] elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
Foldable f => Foldable (Ap f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # toList :: Ap f a -> [a] elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |
Foldable f => Foldable (Alt f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # toList :: Alt f a -> [a] elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # minimum :: Ord a => Alt f a -> a # | |
Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # toList :: Rec1 f a -> [a] elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # minimum :: Ord a => Rec1 f a -> a # | |
Foldable (Tagged s) | |
Defined in Data.Tagged Methods fold :: Monoid m => Tagged s m -> m foldMap :: Monoid m => (a -> m) -> Tagged s a -> m # foldMap' :: Monoid m => (a -> m) -> Tagged s a -> m foldr :: (a -> b -> b) -> b -> Tagged s a -> b # foldr' :: (a -> b -> b) -> b -> Tagged s a -> b foldl :: (b -> a -> b) -> b -> Tagged s a -> b # foldl' :: (b -> a -> b) -> b -> Tagged s a -> b foldr1 :: (a -> a -> a) -> Tagged s a -> a # foldl1 :: (a -> a -> a) -> Tagged s a -> a # elem :: Eq a => a -> Tagged s a -> Bool # maximum :: Ord a => Tagged s a -> a # minimum :: Ord a => Tagged s a -> a # | |
Foldable f => Foldable (ErrorT e f) | |
Defined in Control.Monad.Trans.Error Methods fold :: Monoid m => ErrorT e f m -> m foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ErrorT e f a -> m foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b foldr1 :: (a -> a -> a) -> ErrorT e f a -> a # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a # toList :: ErrorT e f a -> [a] null :: ErrorT e f a -> Bool # length :: ErrorT e f a -> Int # elem :: Eq a => a -> ErrorT e f a -> Bool # maximum :: Ord a => ErrorT e f a -> a # minimum :: Ord a => ErrorT e f a -> a # | |
Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
Foldable f => Foldable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # | |
Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Strict Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
(Foldable f, Foldable g) => Foldable (Product f g) | |
Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # | |
(Foldable f, Foldable g) => Foldable (Sum f g) | |
Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # toList :: Sum f g a -> [a] elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # | |
(Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :*: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :*: g) a -> m foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b foldr1 :: (a -> a -> a) -> (f :*: g) a -> a # foldl1 :: (a -> a -> a) -> (f :*: g) a -> a # toList :: (f :*: g) a -> [a] length :: (f :*: g) a -> Int # elem :: Eq a => a -> (f :*: g) a -> Bool # maximum :: Ord a => (f :*: g) a -> a # minimum :: Ord a => (f :*: g) a -> a # | |
(Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # | |
Foldable (K1 i c :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # toList :: K1 i c a -> [a] elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # minimum :: Ord a => K1 i c a -> a # | |
(Foldable f, Foldable g) => Foldable (Compose f g) | |
Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # | |
(Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # | |
Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # toList :: M1 i c f a -> [a] elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # |
Instances
Instances
Ord BlinkSpeed | |
Defined in System.Console.ANSI.Types Methods compare :: BlinkSpeed -> BlinkSpeed -> Ordering # (<) :: BlinkSpeed -> BlinkSpeed -> Bool # (<=) :: BlinkSpeed -> BlinkSpeed -> Bool # (>) :: BlinkSpeed -> BlinkSpeed -> Bool # (>=) :: BlinkSpeed -> BlinkSpeed -> Bool # max :: BlinkSpeed -> BlinkSpeed -> BlinkSpeed # min :: BlinkSpeed -> BlinkSpeed -> BlinkSpeed # | |
Ord Color | |
Ord ColorIntensity | |
Defined in System.Console.ANSI.Types Methods compare :: ColorIntensity -> ColorIntensity -> Ordering # (<) :: ColorIntensity -> ColorIntensity -> Bool # (<=) :: ColorIntensity -> ColorIntensity -> Bool # (>) :: ColorIntensity -> ColorIntensity -> Bool # (>=) :: ColorIntensity -> ColorIntensity -> Bool # max :: ColorIntensity -> ColorIntensity -> ColorIntensity # min :: ColorIntensity -> ColorIntensity -> ColorIntensity # | |
Ord ConsoleIntensity | |
Defined in System.Console.ANSI.Types Methods compare :: ConsoleIntensity -> ConsoleIntensity -> Ordering # (<) :: ConsoleIntensity -> ConsoleIntensity -> Bool # (<=) :: ConsoleIntensity -> ConsoleIntensity -> Bool # (>) :: ConsoleIntensity -> ConsoleIntensity -> Bool # (>=) :: ConsoleIntensity -> ConsoleIntensity -> Bool # max :: ConsoleIntensity -> ConsoleIntensity -> ConsoleIntensity # min :: ConsoleIntensity -> ConsoleIntensity -> ConsoleIntensity # | |
Ord ConsoleLayer | |
Defined in System.Console.ANSI.Types Methods compare :: ConsoleLayer -> ConsoleLayer -> Ordering # (<) :: ConsoleLayer -> ConsoleLayer -> Bool # (<=) :: ConsoleLayer -> ConsoleLayer -> Bool # (>) :: ConsoleLayer -> ConsoleLayer -> Bool # (>=) :: ConsoleLayer -> ConsoleLayer -> Bool # max :: ConsoleLayer -> ConsoleLayer -> ConsoleLayer # min :: ConsoleLayer -> ConsoleLayer -> ConsoleLayer # | |
Ord Underlining | |
Defined in System.Console.ANSI.Types Methods compare :: Underlining -> Underlining -> Ordering # (<) :: Underlining -> Underlining -> Bool # (<=) :: Underlining -> Underlining -> Bool # (>) :: Underlining -> Underlining -> Bool # (>=) :: Underlining -> Underlining -> Bool # max :: Underlining -> Underlining -> Underlining # min :: Underlining -> Underlining -> Underlining # | |
Ord ByteArray | |
Ord All | |
Ord Any | |
Ord SomeTypeRep | |
Defined in Data.Typeable.Internal | |
Ord Version | |
Ord Void | |
Ord BlockReason | |
Defined in GHC.Conc.Sync | |
Ord ThreadId | |
Defined in GHC.Conc.Sync | |
Ord ThreadStatus | |
Defined in GHC.Conc.Sync | |
Ord ArithException | |
Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # max :: ArithException -> ArithException -> ArithException # min :: ArithException -> ArithException -> ArithException # | |
Ord Associativity | |
Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering # (<) :: Associativity -> Associativity -> Bool # (<=) :: Associativity -> Associativity -> Bool # (>) :: Associativity -> Associativity -> Bool # (>=) :: Associativity -> Associativity -> Bool # | |
Ord DecidedStrictness | |
Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
Ord Fixity | |
Ord SourceStrictness | |
Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
Ord SourceUnpackedness | |
Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
Ord ArrayException | |
Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # max :: ArrayException -> ArrayException -> ArrayException # min :: ArrayException -> ArrayException -> ArrayException # | |
Ord AsyncException | |
Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # max :: AsyncException -> AsyncException -> AsyncException # min :: AsyncException -> AsyncException -> AsyncException # | |
Ord ExitCode | |
Defined in GHC.IO.Exception | |
Ord BufferMode | |
Defined in GHC.IO.Handle.Types | |
Ord Newline | |
Ord NewlineMode | |
Defined in GHC.IO.Handle.Types | |
Ord Int16 | |
Ord Int32 | |
Ord Int64 | |
Ord Int8 | |
Ord SomeNat | |
Ord GeneralCategory | |
Defined in GHC.Unicode Methods compare :: GeneralCategory -> GeneralCategory -> Ordering # (<) :: GeneralCategory -> GeneralCategory -> Bool # (<=) :: GeneralCategory -> GeneralCategory -> Bool # (>) :: GeneralCategory -> GeneralCategory -> Bool # (>=) :: GeneralCategory -> GeneralCategory -> Bool # max :: GeneralCategory -> GeneralCategory -> GeneralCategory # min :: GeneralCategory -> GeneralCategory -> GeneralCategory # | |
Ord Word16 | |
Ord Word32 | |
Ord Word64 | |
Ord Word8 | |
Ord ByteString | |
Defined in Data.ByteString.Internal.Type | |
Ord ByteString | |
Defined in Data.ByteString.Lazy.Internal | |
Ord ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods compare :: ShortByteString -> ShortByteString -> Ordering # (<) :: ShortByteString -> ShortByteString -> Bool # (<=) :: ShortByteString -> ShortByteString -> Bool # (>) :: ShortByteString -> ShortByteString -> Bool # (>=) :: ShortByteString -> ShortByteString -> Bool # max :: ShortByteString -> ShortByteString -> ShortByteString # min :: ShortByteString -> ShortByteString -> ShortByteString # | |
Ord IntSet | |
Ord BigNat | |
Ord Extension | |
Ord Ordering | |
Defined in GHC.Classes | |
Ord TyCon | |
Ord UseColor Source # | |
Defined in Hedgehog.Internal.Config | |
Ord Verbosity Source # | |
Ord WorkerCount Source # | |
Defined in Hedgehog.Internal.Config Methods compare :: WorkerCount -> WorkerCount -> Ordering # (<) :: WorkerCount -> WorkerCount -> Bool # (<=) :: WorkerCount -> WorkerCount -> Bool # (>) :: WorkerCount -> WorkerCount -> Bool # (>=) :: WorkerCount -> WorkerCount -> Bool # max :: WorkerCount -> WorkerCount -> WorkerCount # min :: WorkerCount -> WorkerCount -> WorkerCount # | |
Ord Position Source # | |
Defined in Hedgehog.Internal.Discovery | |
Ord PropertySource Source # | |
Defined in Hedgehog.Internal.Discovery Methods compare :: PropertySource -> PropertySource -> Ordering # (<) :: PropertySource -> PropertySource -> Bool # (<=) :: PropertySource -> PropertySource -> Bool # (>) :: PropertySource -> PropertySource -> Bool # (>=) :: PropertySource -> PropertySource -> Bool # max :: PropertySource -> PropertySource -> PropertySource # min :: PropertySource -> PropertySource -> PropertySource # | |
Ord Confidence Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: Confidence -> Confidence -> Ordering # (<) :: Confidence -> Confidence -> Bool # (<=) :: Confidence -> Confidence -> Bool # (>) :: Confidence -> Confidence -> Bool # (>=) :: Confidence -> Confidence -> Bool # max :: Confidence -> Confidence -> Confidence # min :: Confidence -> Confidence -> Confidence # | |
Ord Cover Source # | |
Ord CoverCount Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: CoverCount -> CoverCount -> Ordering # (<) :: CoverCount -> CoverCount -> Bool # (<=) :: CoverCount -> CoverCount -> Bool # (>) :: CoverCount -> CoverCount -> Bool # (>=) :: CoverCount -> CoverCount -> Bool # max :: CoverCount -> CoverCount -> CoverCount # min :: CoverCount -> CoverCount -> CoverCount # | |
Ord CoverPercentage Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: CoverPercentage -> CoverPercentage -> Ordering # (<) :: CoverPercentage -> CoverPercentage -> Bool # (<=) :: CoverPercentage -> CoverPercentage -> Bool # (>) :: CoverPercentage -> CoverPercentage -> Bool # (>=) :: CoverPercentage -> CoverPercentage -> Bool # max :: CoverPercentage -> CoverPercentage -> CoverPercentage # min :: CoverPercentage -> CoverPercentage -> CoverPercentage # | |
Ord DiscardCount Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: DiscardCount -> DiscardCount -> Ordering # (<) :: DiscardCount -> DiscardCount -> Bool # (<=) :: DiscardCount -> DiscardCount -> Bool # (>) :: DiscardCount -> DiscardCount -> Bool # (>=) :: DiscardCount -> DiscardCount -> Bool # max :: DiscardCount -> DiscardCount -> DiscardCount # min :: DiscardCount -> DiscardCount -> DiscardCount # | |
Ord DiscardLimit Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: DiscardLimit -> DiscardLimit -> Ordering # (<) :: DiscardLimit -> DiscardLimit -> Bool # (<=) :: DiscardLimit -> DiscardLimit -> Bool # (>) :: DiscardLimit -> DiscardLimit -> Bool # (>=) :: DiscardLimit -> DiscardLimit -> Bool # max :: DiscardLimit -> DiscardLimit -> DiscardLimit # min :: DiscardLimit -> DiscardLimit -> DiscardLimit # | |
Ord GroupName Source # | |
Ord LabelName Source # | |
Ord PropertyConfig Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: PropertyConfig -> PropertyConfig -> Ordering # (<) :: PropertyConfig -> PropertyConfig -> Bool # (<=) :: PropertyConfig -> PropertyConfig -> Bool # (>) :: PropertyConfig -> PropertyConfig -> Bool # (>=) :: PropertyConfig -> PropertyConfig -> Bool # max :: PropertyConfig -> PropertyConfig -> PropertyConfig # min :: PropertyConfig -> PropertyConfig -> PropertyConfig # | |
Ord PropertyCount Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: PropertyCount -> PropertyCount -> Ordering # (<) :: PropertyCount -> PropertyCount -> Bool # (<=) :: PropertyCount -> PropertyCount -> Bool # (>) :: PropertyCount -> PropertyCount -> Bool # (>=) :: PropertyCount -> PropertyCount -> Bool # max :: PropertyCount -> PropertyCount -> PropertyCount # min :: PropertyCount -> PropertyCount -> PropertyCount # | |
Ord PropertyName Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: PropertyName -> PropertyName -> Ordering # (<) :: PropertyName -> PropertyName -> Bool # (<=) :: PropertyName -> PropertyName -> Bool # (>) :: PropertyName -> PropertyName -> Bool # (>=) :: PropertyName -> PropertyName -> Bool # max :: PropertyName -> PropertyName -> PropertyName # min :: PropertyName -> PropertyName -> PropertyName # | |
Ord ShrinkCount Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: ShrinkCount -> ShrinkCount -> Ordering # (<) :: ShrinkCount -> ShrinkCount -> Bool # (<=) :: ShrinkCount -> ShrinkCount -> Bool # (>) :: ShrinkCount -> ShrinkCount -> Bool # (>=) :: ShrinkCount -> ShrinkCount -> Bool # max :: ShrinkCount -> ShrinkCount -> ShrinkCount # min :: ShrinkCount -> ShrinkCount -> ShrinkCount # | |
Ord ShrinkLimit Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: ShrinkLimit -> ShrinkLimit -> Ordering # (<) :: ShrinkLimit -> ShrinkLimit -> Bool # (<=) :: ShrinkLimit -> ShrinkLimit -> Bool # (>) :: ShrinkLimit -> ShrinkLimit -> Bool # (>=) :: ShrinkLimit -> ShrinkLimit -> Bool # max :: ShrinkLimit -> ShrinkLimit -> ShrinkLimit # min :: ShrinkLimit -> ShrinkLimit -> ShrinkLimit # | |
Ord ShrinkPath Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: ShrinkPath -> ShrinkPath -> Ordering # (<) :: ShrinkPath -> ShrinkPath -> Bool # (<=) :: ShrinkPath -> ShrinkPath -> Bool # (>) :: ShrinkPath -> ShrinkPath -> Bool # (>=) :: ShrinkPath -> ShrinkPath -> Bool # max :: ShrinkPath -> ShrinkPath -> ShrinkPath # min :: ShrinkPath -> ShrinkPath -> ShrinkPath # | |
Ord ShrinkRetries Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: ShrinkRetries -> ShrinkRetries -> Ordering # (<) :: ShrinkRetries -> ShrinkRetries -> Bool # (<=) :: ShrinkRetries -> ShrinkRetries -> Bool # (>) :: ShrinkRetries -> ShrinkRetries -> Bool # (>=) :: ShrinkRetries -> ShrinkRetries -> Bool # max :: ShrinkRetries -> ShrinkRetries -> ShrinkRetries # min :: ShrinkRetries -> ShrinkRetries -> ShrinkRetries # | |
Ord Skip Source # | |
Ord TerminationCriteria Source # | |
Defined in Hedgehog.Internal.Property Methods compare :: TerminationCriteria -> TerminationCriteria -> Ordering # (<) :: TerminationCriteria -> TerminationCriteria -> Bool # (<=) :: TerminationCriteria -> TerminationCriteria -> Bool # (>) :: TerminationCriteria -> TerminationCriteria -> Bool # (>=) :: TerminationCriteria -> TerminationCriteria -> Bool # max :: TerminationCriteria -> TerminationCriteria -> TerminationCriteria # min :: TerminationCriteria -> TerminationCriteria -> TerminationCriteria # | |
Ord TestCount Source # | |
Ord TestLimit Source # | |
Ord TaskIndex Source # | |
Ord Size Source # | |
Ord Markup Source # | |
Ord Style Source # | |
Ord RunnerConfig Source # | |
Defined in Hedgehog.Internal.Runner Methods compare :: RunnerConfig -> RunnerConfig -> Ordering # (<) :: RunnerConfig -> RunnerConfig -> Bool # (<=) :: RunnerConfig -> RunnerConfig -> Bool # (>) :: RunnerConfig -> RunnerConfig -> Bool # (>=) :: RunnerConfig -> RunnerConfig -> Bool # max :: RunnerConfig -> RunnerConfig -> RunnerConfig # min :: RunnerConfig -> RunnerConfig -> RunnerConfig # | |
Ord Seed Source # | |
Ord ColumnNo Source # | |
Defined in Hedgehog.Internal.Source | |
Ord LineNo Source # | |
Ord Span Source # | |
Ord EnvironmentError Source # | |
Defined in Hedgehog.Internal.State Methods compare :: EnvironmentError -> EnvironmentError -> Ordering # (<) :: EnvironmentError -> EnvironmentError -> Bool # (<=) :: EnvironmentError -> EnvironmentError -> Bool # (>) :: EnvironmentError -> EnvironmentError -> Bool # (>=) :: EnvironmentError -> EnvironmentError -> Bool # max :: EnvironmentError -> EnvironmentError -> EnvironmentError # min :: EnvironmentError -> EnvironmentError -> EnvironmentError # | |
Ord Name Source # | |
Ord AnnLookup | |
Ord AnnTarget | |
Ord Bang | |
Ord Body | |
Ord Bytes | |
Ord Callconv | |
Defined in Language.Haskell.TH.Syntax | |
Ord Clause | |
Ord Con | |
Ord Dec | |
Ord DecidedStrictness | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
Ord DerivClause | |
Defined in Language.Haskell.TH.Syntax | |
Ord DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering # (<) :: DerivStrategy -> DerivStrategy -> Bool # (<=) :: DerivStrategy -> DerivStrategy -> Bool # (>) :: DerivStrategy -> DerivStrategy -> Bool # (>=) :: DerivStrategy -> DerivStrategy -> Bool # | |
Ord DocLoc | |
Ord Exp | |
Ord FamilyResultSig | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering # (<) :: FamilyResultSig -> FamilyResultSig -> Bool # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool # (>) :: FamilyResultSig -> FamilyResultSig -> Bool # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # | |
Ord Fixity | |
Ord FixityDirection | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection # | |
Ord Foreign | |
Defined in Language.Haskell.TH.Syntax | |
Ord FunDep | |
Ord Guard | |
Ord Info | |
Ord InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering # (<) :: InjectivityAnn -> InjectivityAnn -> Bool # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool # (>) :: InjectivityAnn -> InjectivityAnn -> Bool # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool # | |
Ord Inline | |
Ord Lit | |
Ord Loc | |
Ord Match | |
Ord ModName | |
Defined in Language.Haskell.TH.Syntax | |
Ord Module | |
Ord ModuleInfo | |
Defined in Language.Haskell.TH.Syntax | |
Ord Name | |
Ord NameFlavour | |
Defined in Language.Haskell.TH.Syntax | |
Ord NameSpace | |
Ord OccName | |
Defined in Language.Haskell.TH.Syntax | |
Ord Overlap | |
Defined in Language.Haskell.TH.Syntax | |
Ord Pat | |
Ord PatSynArgs | |
Defined in Language.Haskell.TH.Syntax | |
Ord PatSynDir | |
Ord Phases | |
Ord PkgName | |
Defined in Language.Haskell.TH.Syntax | |
Ord Pragma | |
Ord Range | |
Ord Role | |
Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
Ord RuleMatch | |
Ord Safety | |
Ord SourceStrictness | |
Defined in Language.Haskell.TH.Syntax Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
Ord SourceUnpackedness | |
Defined in Language.Haskell.TH.Syntax Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
Ord Specificity | |
Defined in Language.Haskell.TH.Syntax | |
Ord Stmt | |
Ord TyLit | |
Ord TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
Ord Type | |
Ord TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # | |
Ord NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime Methods compare :: NominalDiffTime -> NominalDiffTime -> Ordering # (<) :: NominalDiffTime -> NominalDiffTime -> Bool # (<=) :: NominalDiffTime -> NominalDiffTime -> Bool # (>) :: NominalDiffTime -> NominalDiffTime -> Bool # (>=) :: NominalDiffTime -> NominalDiffTime -> Bool # max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime # | |
Ord LocalTime | |
Defined in Data.Time.LocalTime.Internal.LocalTime | |
Ord Integer | |
Ord () | |
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Word | |
Ord (Async a) | |
Defined in Control.Concurrent.Async | |
Ord a => Ord (ZipList a) | |
Ord a => Ord (Identity a) | |
Defined in Data.Functor.Identity | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Down a) | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Max a) | |
Ord a => Ord (Min a) | |
Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # | |
Ord a => Ord (Dual a) | |
Ord a => Ord (Product a) | |
Ord a => Ord (Sum a) | |
Ord p => Ord (Par1 p) | |
Integral a => Ord (Ratio a) | |
Ord a => Ord (IntMap a) | |
Defined in Data.IntMap.Internal | |
Ord a => Ord (Seq a) | |
Ord a => Ord (ViewL a) | |
Defined in Data.Sequence.Internal | |
Ord a => Ord (ViewR a) | |
Defined in Data.Sequence.Internal | |
Ord a => Ord (Intersection a) | |
Defined in Data.Set.Internal Methods compare :: Intersection a -> Intersection a -> Ordering # (<) :: Intersection a -> Intersection a -> Bool # (<=) :: Intersection a -> Intersection a -> Bool # (>) :: Intersection a -> Intersection a -> Bool # (>=) :: Intersection a -> Intersection a -> Bool # | |
Ord a => Ord (Set a) | |
Ord a => Ord (Tree a) | |
Ord a => Ord (Hashed a) | |
Defined in Data.Hashable.Class | |
Ord a => Ord (Pos a) Source # | |
Ord a => Ord (Opaque a) Source # | |
Defined in Hedgehog.Internal.Opaque | |
Ord a => Ord (Concrete a) Source # | |
Defined in Hedgehog.Internal.State | |
Ord (Symbolic a) Source # | |
Defined in Hedgehog.Internal.State | |
Ord g => Ord (StateGen g) | |
Defined in System.Random.Internal | |
Ord flag => Ord (TyVarBndr flag) | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering # (<) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>) :: TyVarBndr flag -> TyVarBndr flag -> Bool # (>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool # | |
Ord a => Ord (NonEmpty a) | |
Ord a => Ord (Maybe a) | |
Ord a => Ord (a) | |
Ord a => Ord [a] | |
(Ord a, Ord b) => Ord (Either a b) | |
Ord (Fixed a) | |
Ord (Proxy s) | |
Ord a => Ord (Arg a b) | |
Ord (TypeRep a) | |
Ord (U1 p) | |
Ord (V1 p) | |
(Ord k, Ord v) => Ord (Map k v) | |
(Ord a, Ord1 v) => Ord (Var a v) Source # | |
Defined in Hedgehog.Internal.State | |
(Ord1 m, Ord a) => Ord (ListT m a) | |
(Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
(Ord a, Ord b) => Ord (a, b) | |
Ord a => Ord (Const a b) | |
Ord (f a) => Ord (Ap f a) | |
Ord (f a) => Ord (Alt f a) | |
Defined in Data.Semigroup.Internal | |
Ord (f p) => Ord (Rec1 f p) | |
Defined in GHC.Generics | |
Ord (URec (Ptr ()) p) | |
Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # | |
Ord (URec Char p) | |
Defined in GHC.Generics | |
Ord (URec Double p) | |
Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # | |
Ord (URec Float p) | |
Defined in GHC.Generics | |
Ord (URec Int p) | |
Ord (URec Word p) | |
Defined in GHC.Generics | |
Ord b => Ord (Tagged s b) | |
(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # | |
(Ord1 f, Ord a) => Ord (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # | |
(Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
(Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
(Ord a, Ord b, Ord c) => Ord (a, b, c) | |
(Ord1 f, Ord1 g, Ord a) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # | |
(Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a) | |
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p) | |
Defined in GHC.Generics | |
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p) | |
Defined in GHC.Generics | |
Ord c => Ord (K1 i c p) | |
Defined in GHC.Generics | |
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # | |
Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Generics | |
Ord (f p) => Ord (M1 i c f p) | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering # (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering # (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering # (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering # (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Classes Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering # (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool # max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # |
Instances
Eq BlinkSpeed | |
Defined in System.Console.ANSI.Types | |
Eq Color | |
Eq ColorIntensity | |
Defined in System.Console.ANSI.Types Methods (==) :: ColorIntensity -> ColorIntensity -> Bool # (/=) :: ColorIntensity -> ColorIntensity -> Bool # | |
Eq ConsoleIntensity | |
Defined in System.Console.ANSI.Types Methods (==) :: ConsoleIntensity -> ConsoleIntensity -> Bool # (/=) :: ConsoleIntensity -> ConsoleIntensity -> Bool # | |
Eq ConsoleLayer | |
Defined in System.Console.ANSI.Types | |
Eq SGR | |
Eq Underlining | |
Defined in System.Console.ANSI.Types | |
Eq AsyncCancelled | |
Eq ByteArray | |
Eq All | |
Eq Any | |
Eq SomeTypeRep | |
Eq Version | |
Eq Void | |
Eq BlockReason | |
Eq ThreadId | |
Eq ThreadStatus | |
Eq ArithException | |
Defined in GHC.Exception.Type Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool # | |
Eq SpecConstrAnnotation | |
Eq Associativity | |
Eq DecidedStrictness | |
Eq Fixity | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq MaskingState | |
Defined in GHC.IO | |
Eq ArrayException | |
Defined in GHC.IO.Exception Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool # | |
Eq AsyncException | |
Defined in GHC.IO.Exception Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool # | |
Eq ExitCode | |
Eq IOErrorType | |
Eq IOException | |
Defined in GHC.IO.Exception | |
Eq HandlePosn | |
Eq BufferMode | |
Eq Handle | |
Eq Newline | |
Eq NewlineMode | |
Eq Int16 | |
Eq Int32 | |
Eq Int64 | |
Eq Int8 | |
Eq IoSubSystem | |
Eq SrcLoc | |
Eq SomeNat | |
Eq GeneralCategory | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq Word8 | |
Eq ByteString | |
Eq ByteString | |
Eq ShortByteString | |
Eq AtEnd | |
Eq OutputBuffer | |
Defined in System.Console.Concurrent.Internal | |
Eq OutputBufferedActivity | |
Defined in System.Console.Concurrent.Internal Methods (==) :: OutputBufferedActivity -> OutputBufferedActivity -> Bool # (/=) :: OutputBufferedActivity -> OutputBufferedActivity -> Bool # | |
Eq ConsoleRegion | |
Defined in System.Console.Regions Methods (==) :: ConsoleRegion -> ConsoleRegion -> Bool # (/=) :: ConsoleRegion -> ConsoleRegion -> Bool # | |
Eq LineUpdate | |
Eq RegionLayout | |
Defined in System.Console.Regions | |
Eq IntSet | |
Eq BigNat | |
Eq ForeignSrcLang | |
Eq Extension | |
Eq Module | |
Eq Ordering | |
Eq TrName | |
Eq TyCon | |
Eq UseColor Source # | |
Eq Verbosity Source # | |
Eq WorkerCount Source # | |
Defined in Hedgehog.Internal.Config | |
Eq Position Source # | |
Eq PropertySource Source # | |
Defined in Hedgehog.Internal.Discovery Methods (==) :: PropertySource -> PropertySource -> Bool # (/=) :: PropertySource -> PropertySource -> Bool # | |
Eq Confidence Source # | |
Defined in Hedgehog.Internal.Property | |
Eq Cover Source # | |
Eq CoverCount Source # | |
Defined in Hedgehog.Internal.Property | |
Eq CoverPercentage Source # | |
Defined in Hedgehog.Internal.Property Methods (==) :: CoverPercentage -> CoverPercentage -> Bool # (/=) :: CoverPercentage -> CoverPercentage -> Bool # | |
Eq Diff Source # | |
Eq DiscardCount Source # | |
Defined in Hedgehog.Internal.Property | |
Eq DiscardLimit Source # | |
Defined in Hedgehog.Internal.Property | |
Eq Failure Source # | |
Eq GroupName Source # | |
Eq Journal Source # | |
Eq LabelName Source # | |
Eq Log Source # | |
Eq PropertyConfig Source # | |
Defined in Hedgehog.Internal.Property Methods (==) :: PropertyConfig -> PropertyConfig -> Bool # (/=) :: PropertyConfig -> PropertyConfig -> Bool # | |
Eq PropertyCount Source # | |
Defined in Hedgehog.Internal.Property Methods (==) :: PropertyCount -> PropertyCount -> Bool # (/=) :: PropertyCount -> PropertyCount -> Bool # | |
Eq PropertyName Source # | |
Defined in Hedgehog.Internal.Property | |
Eq ShrinkCount Source # | |
Defined in Hedgehog.Internal.Property | |
Eq ShrinkLimit Source # | |
Defined in Hedgehog.Internal.Property | |
Eq ShrinkPath Source # | |
Defined in Hedgehog.Internal.Property | |
Eq ShrinkRetries Source # | |
Defined in Hedgehog.Internal.Property Methods (==) :: ShrinkRetries -> ShrinkRetries -> Bool # (/=) :: ShrinkRetries -> ShrinkRetries -> Bool # | |
Eq Skip Source # | |
Eq TerminationCriteria Source # | |
Defined in Hedgehog.Internal.Property Methods (==) :: TerminationCriteria -> TerminationCriteria -> Bool # (/=) :: TerminationCriteria -> TerminationCriteria -> Bool # | |
Eq TestCount Source # | |
Eq TestLimit Source # | |
Eq TaskIndex Source # | |
Eq Size Source # | |
Eq FailedAnnotation Source # | |
Defined in Hedgehog.Internal.Report Methods (==) :: FailedAnnotation -> FailedAnnotation -> Bool # (/=) :: FailedAnnotation -> FailedAnnotation -> Bool # | |
Eq FailureReport Source # | |
Defined in Hedgehog.Internal.Report Methods (==) :: FailureReport -> FailureReport -> Bool # (/=) :: FailureReport -> FailureReport -> Bool # | |
Eq Markup Source # | |
Eq Progress Source # | |
Eq Result Source # | |
Eq Style Source # | |
Eq RunnerConfig Source # | |
Defined in Hedgehog.Internal.Runner | |
Eq Seed Source # | |
Eq LineDiff Source # | |
Eq ValueDiff Source # | |
Eq ColumnNo Source # | |
Eq LineNo Source # | |
Eq Span Source # | |
Eq EnvironmentError Source # | |
Defined in Hedgehog.Internal.State Methods (==) :: EnvironmentError -> EnvironmentError -> Bool # (/=) :: EnvironmentError -> EnvironmentError -> Bool # | |
Eq Name Source # | |
Eq Mode | |
Eq Style | |
Eq TextDetails | |
Eq Doc | |
Eq Value | |
Eq StdGen | |
Eq AnnLookup | |
Eq AnnTarget | |
Eq Bang | |
Eq Body | |
Eq Bytes | |
Eq Callconv | |
Eq Clause | |
Eq Con | |
Eq Dec | |
Eq DecidedStrictness | |
Eq DerivClause | |
Eq DerivStrategy | |
Eq DocLoc | |
Eq Exp | |
Eq FamilyResultSig | |
Eq Fixity | |
Eq FixityDirection | |
Eq Foreign | |
Eq FunDep | |
Eq Guard | |
Eq Info | |
Eq InjectivityAnn | |
Eq Inline | |
Eq Lit | |
Eq Loc | |
Eq Match | |
Eq ModName | |
Eq Module | |
Eq ModuleInfo | |
Eq Name | |
Eq NameFlavour | |
Eq NameSpace | |
Eq OccName | |
Eq Overlap | |
Eq Pat | |
Eq PatSynArgs | |
Eq PatSynDir | |
Eq Phases | |
Eq PkgName | |
Eq Pragma | |
Eq Range | |
Eq Role | |
Eq RuleBndr | |
Eq RuleMatch | |
Eq Safety | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq Specificity | |
Eq Stmt | |
Eq TyLit | |
Eq TySynEqn | |
Eq Type | |
Eq TypeFamilyHead | |
Eq NominalDiffTime | |
Eq LocalTime | |
Eq Integer | |
Eq () | |
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Word | |
Eq (Async a) | |
Eq a => Eq (ZipList a) | |
Eq (MutableByteArray s) | |
Defined in Data.Array.Byte Methods (==) :: MutableByteArray s -> MutableByteArray s -> Bool # (/=) :: MutableByteArray s -> MutableByteArray s -> Bool # | |
Eq a => Eq (And a) | |
Eq a => Eq (Iff a) | |
Eq a => Eq (Ior a) | |
Eq a => Eq (Xor a) | |
Eq a => Eq (Complex a) | |
Eq a => Eq (Identity a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Down a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Max a) | |
Eq a => Eq (Min a) | |
Eq m => Eq (WrappedMonoid m) | |
Eq a => Eq (Dual a) | |
Eq a => Eq (Product a) | |
Eq a => Eq (Sum a) | |
Eq (TVar a) | |
Eq p => Eq (Par1 p) | |
Eq (IORef a) | |
Eq (MVar a) | |
Eq a => Eq (Ratio a) | |
Eq a => Eq (AlphaColour a) | |
Defined in Data.Colour.Internal Methods (==) :: AlphaColour a -> AlphaColour a -> Bool # (/=) :: AlphaColour a -> AlphaColour a -> Bool # | |
Eq a => Eq (Colour a) | |
Eq a => Eq (IntMap a) | |
Eq a => Eq (Seq a) | |
Eq a => Eq (ViewL a) | |
Eq a => Eq (ViewR a) | |
Eq a => Eq (Intersection a) | |
Eq a => Eq (Set a) | |
Eq a => Eq (Tree a) | |
Eq a => Eq (Hashed a) | |
Eq a => Eq (Pos a) Source # | |
Eq a => Eq (Opaque a) Source # | |
Eq a => Eq (Coverage a) Source # | |
Eq a => Eq (Label a) Source # | |
Eq a => Eq (Concrete a) Source # | |
Eq (Symbolic a) Source # | |
Eq a => Eq (AnnotDetails a) | |
Eq (Doc a) | |
Eq a => Eq (Span a) | |
Eq g => Eq (StateGen g) | |
Eq (TMVar a) | |
Eq flag => Eq (TyVarBndr flag) | |
Eq a => Eq (Window a) | |
Eq a => Eq (NonEmpty a) | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (a) | |
Eq a => Eq [a] | |
(Eq a, Eq b) => Eq (Either a b) | |
Eq (Fixed a) | |
Eq (Proxy s) | |
Eq a => Eq (Arg a b) | |
Eq (TypeRep a) | |
Eq (U1 p) | |
Eq (V1 p) | |
Eq (STRef s a) | |
(Eq k, Eq a) => Eq (Map k a) | |
(Eq a, Eq1 v) => Eq (Var a v) Source # | |
(Eq a, Eq1 m) => Eq (NodeT m a) Source # | |
(Eq1 m, Eq a) => Eq (TreeT m a) Source # | |
(Eq1 m, Eq a) => Eq (ListT m a) | |
(Eq1 m, Eq a) => Eq (MaybeT m a) | |
(Eq a, Eq b) => Eq (a, b) | |
Eq a => Eq (Const a b) | |
Eq (f a) => Eq (Ap f a) | |
Eq (f a) => Eq (Alt f a) | |
Eq (OrderingI a b) | |
Eq (f p) => Eq (Rec1 f p) | |
Eq (URec (Ptr ()) p) | |
Eq (URec Char p) | |
Eq (URec Double p) | |
Eq (URec Float p) | |
Eq (URec Int p) | |
Eq (URec Word p) | |
Eq b => Eq (Tagged s b) | |
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) | |
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
(Eq1 f, Eq a) => Eq (IdentityT f a) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
(Eq a, Eq b, Eq c) => Eq (a, b, c) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Product f g a) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) | |
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
Eq c => Eq (K1 i c p) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
(Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) | |
Eq (f (g p)) => Eq ((f :.: g) p) | |
Eq (f p) => Eq (M1 i c f p) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Instances
Bifunctor Either | |
Eq2 Either | |
Ord2 Either | |
Defined in Data.Functor.Classes | |
Read2 Either | |
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] | |
Show2 Either | |
NFData2 Either | |
Defined in Control.DeepSeq | |
Hashable2 Either | |
Defined in Data.Hashable.Class | |
Generic1 (Either a :: Type -> Type) | |
MonadError e (Either e) | |
Defined in Control.Monad.Error.Class | |
(Lift a, Lift b) => Lift (Either a b :: Type) | |
Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
Eq a => Eq1 (Either a) | |
Ord a => Ord1 (Either a) | |
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |
Read a => Read1 (Either a) | |
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] | |
Show a => Show1 (Either a) | |
Defined in Data.Functor.Classes | |
Traversable (Either a) | |
Defined in Data.Traversable | |
Applicative (Either e) | |
Functor (Either a) | |
Monad (Either e) | |
NFData a => NFData1 (Either a) | |
Defined in Control.DeepSeq | |
e ~ SomeException => MonadCatch (Either e) | |
e ~ SomeException => MonadMask (Either e) | |
Defined in Control.Monad.Catch | |
e ~ SomeException => MonadThrow (Either e) | |
Defined in Control.Monad.Catch | |
Hashable a => Hashable1 (Either a) | |
Defined in Data.Hashable.Class | |
MonadBaseControl (Either e) (Either e) | |
Defined in Control.Monad.Trans.Control Associated Types type StM (Either e) a | |
MonadBase (Either e) (Either e) | |
Defined in Control.Monad.Base | |
Semigroup (Either a b) | |
Generic (Either a b) | |
(Read a, Read b) => Read (Either a b) | |
(Show a, Show b) => Show (Either a b) | |
(NFData a, NFData b) => NFData (Either a b) | |
Defined in Control.DeepSeq | |
(Eq a, Eq b) => Eq (Either a b) | |
(Ord a, Ord b) => Ord (Either a b) | |
(Hashable a, Hashable b) => Hashable (Either a b) | |
Defined in Data.Hashable.Class | |
type Rep1 (Either a :: Type -> Type) | |
Defined in GHC.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)) | |
type StM (Either e) a | |
Defined in Control.Monad.Trans.Control type StM (Either e) a = a | |
type Rep (Either a b) | |
Defined in GHC.Generics type Rep (Either a b) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) |
Minimal complete definition
readsPrec | readPrec
Instances
Read BlinkSpeed | |
Defined in System.Console.ANSI.Types Methods readsPrec :: Int -> ReadS BlinkSpeed # readList :: ReadS [BlinkSpeed] # readPrec :: ReadPrec BlinkSpeed readListPrec :: ReadPrec [BlinkSpeed] | |
Read Color | |
Read ColorIntensity | |
Defined in System.Console.ANSI.Types Methods readsPrec :: Int -> ReadS ColorIntensity # readList :: ReadS [ColorIntensity] # readPrec :: ReadPrec ColorIntensity readListPrec :: ReadPrec [ColorIntensity] | |
Read ConsoleIntensity | |
Defined in System.Console.ANSI.Types Methods readsPrec :: Int -> ReadS ConsoleIntensity # readList :: ReadS [ConsoleIntensity] # readPrec :: ReadPrec ConsoleIntensity readListPrec :: ReadPrec [ConsoleIntensity] | |
Read ConsoleLayer | |
Defined in System.Console.ANSI.Types Methods readsPrec :: Int -> ReadS ConsoleLayer # readList :: ReadS [ConsoleLayer] # readPrec :: ReadPrec ConsoleLayer readListPrec :: ReadPrec [ConsoleLayer] | |
Read SGR | |
Read Underlining | |
Defined in System.Console.ANSI.Types Methods readsPrec :: Int -> ReadS Underlining # readList :: ReadS [Underlining] # readPrec :: ReadPrec Underlining readListPrec :: ReadPrec [Underlining] | |
Read All | |
Defined in Data.Semigroup.Internal | |
Read Any | |
Defined in Data.Semigroup.Internal | |
Read Version | |
Defined in Data.Version | |
Read Void | |
Read Associativity | |
Defined in GHC.Generics | |
Read DecidedStrictness | |
Defined in GHC.Generics | |
Read Fixity | |
Defined in GHC.Generics | |
Read SourceStrictness | |
Defined in GHC.Generics | |
Read SourceUnpackedness | |
Defined in GHC.Generics | |
Read ExitCode | |
Defined in GHC.IO.Exception | |
Read BufferMode | |
Defined in GHC.IO.Handle.Types | |
Read Newline | |
Defined in GHC.IO.Handle.Types | |
Read NewlineMode | |
Defined in GHC.IO.Handle.Types | |
Read Int16 | |
Read Int32 | |
Read Int64 | |
Read Int8 | |
Read GCDetails | |
Read RTSStats | |
Read SomeNat | |
Defined in GHC.TypeNats | |
Read GeneralCategory | |
Read Word16 | |
Read Word32 | |
Read Word64 | |
Read Word8 | |
Read Lexeme | |
Read ByteString | |
Defined in Data.ByteString.Internal.Type | |
Read ByteString | |
Defined in Data.ByteString.Lazy.Internal | |
Read ShortByteString | |
Defined in Data.ByteString.Short.Internal | |
Read IntSet | |
Defined in Data.IntSet.Internal | |
Read Ordering | |
Read Size Source # | |
Read Seed Source # | |
Read NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime | |
Read Integer | |
Read Natural | |
Read () | |
Read Bool | |
Read Char | |
Read Double | |
Read Float | |
Read Int | |
Read Word | |
Read a => Read (ZipList a) | |
Defined in Control.Applicative | |
Read a => Read (And a) | |
Read a => Read (Iff a) | |
Read a => Read (Ior a) | |
Read a => Read (Xor a) | |
Read a => Read (Complex a) | |
Defined in Data.Complex | |
Read a => Read (Identity a) | |
Defined in Data.Functor.Identity | |
Read a => Read (First a) | |
Defined in Data.Monoid | |
Read a => Read (Last a) | |
Defined in Data.Monoid | |
Read a => Read (Down a) | |
Read a => Read (First a) | |
Defined in Data.Semigroup | |
Read a => Read (Last a) | |
Defined in Data.Semigroup | |
Read a => Read (Max a) | |
Defined in Data.Semigroup | |
Read a => Read (Min a) | |
Defined in Data.Semigroup | |
Read m => Read (WrappedMonoid m) | |
Defined in Data.Semigroup | |
Read a => Read (Dual a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (Product a) | |
Defined in Data.Semigroup.Internal | |
Read a => Read (Sum a) | |
Defined in Data.Semigroup.Internal | |
Read p => Read (Par1 p) | |
Defined in GHC.Generics | |
(Integral a, Read a) => Read (Ratio a) | |
Read e => Read (IntMap e) | |
Defined in Data.IntMap.Internal | |
Read a => Read (Seq a) | |
Defined in Data.Sequence.Internal | |
Read a => Read (ViewL a) | |
Defined in Data.Sequence.Internal | |
Read a => Read (ViewR a) | |
Defined in Data.Sequence.Internal | |
(Read a, Ord a) => Read (Set a) | |
Defined in Data.Set.Internal | |
Read a => Read (Tree a) | |
Read a => Read (Window a) | |
Read a => Read (NonEmpty a) | |
Read a => Read (Maybe a) | |
Read a => Read (a) | |
Read a => Read [a] | |
(Read a, Read b) => Read (Either a b) | |
HasResolution a => Read (Fixed a) | |
Defined in Data.Fixed | |
Read (Proxy t) | |
Defined in Data.Proxy | |
(Read a, Read b) => Read (Arg a b) | |
Defined in Data.Semigroup | |
(Ix a, Read a, Read b) => Read (Array a b) | |
Read (U1 p) | |
Defined in GHC.Generics | |
Read (V1 p) | |
Defined in GHC.Generics | |
(Ord k, Read k, Read e) => Read (Map k e) | |
Defined in Data.Map.Internal | |
(Read1 m, Read a) => Read (ListT m a) | |
Defined in Control.Monad.Trans.List | |
(Read1 m, Read a) => Read (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
(Read a, Read b) => Read (a, b) | |
Read a => Read (Const a b) | |
Defined in Data.Functor.Const | |
Read (f a) => Read (Ap f a) | |
Defined in Data.Monoid | |
Read (f a) => Read (Alt f a) | |
Defined in Data.Semigroup.Internal | |
Read (f p) => Read (Rec1 f p) | |
Defined in GHC.Generics | |
Read b => Read (Tagged s b) | |
(Read e, Read1 m, Read a) => Read (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
(Read e, Read1 m, Read a) => Read (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except | |
(Read1 f, Read a) => Read (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity | |
(Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(Read a, Read b, Read c) => Read (a, b, c) | |
(Read1 f, Read1 g, Read a) => Read (Product f g a) | |
Defined in Data.Functor.Product | |
(Read1 f, Read1 g, Read a) => Read (Sum f g a) | |
Defined in Data.Functor.Sum | |
(Read (f p), Read (g p)) => Read ((f :*: g) p) | |
Defined in GHC.Generics | |
(Read (f p), Read (g p)) => Read ((f :+: g) p) | |
Defined in GHC.Generics | |
Read c => Read (K1 i c p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c, Read d) => Read (a, b, c, d) | |
(Read1 f, Read1 g, Read a) => Read (Compose f g a) | |
Defined in Data.Functor.Compose | |
Read (f (g p)) => Read ((f :.: g) p) | |
Defined in GHC.Generics | |
Read (f p) => Read (M1 i c f p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) | |
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Read |
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
class (Real a, Fractional a) => RealFrac a where #
Minimal complete definition
Methods
properFraction :: Integral b => a -> (b, a) #
truncate :: Integral b => a -> b #
round :: Integral b => a -> b #
class Num a => Fractional a where #
Minimal complete definition
fromRational, (recip | (/))
Instances
Fractional CoverPercentage Source # | |
Defined in Hedgehog.Internal.Property Methods (/) :: CoverPercentage -> CoverPercentage -> CoverPercentage # recip :: CoverPercentage -> CoverPercentage # fromRational :: Rational -> CoverPercentage # | |
Fractional NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime | |
RealFloat a => Fractional (Complex a) | |
Defined in Data.Complex | |
Fractional a => Fractional (Identity a) | |
Defined in Data.Functor.Identity | |
Fractional a => Fractional (Down a) | |
Integral a => Fractional (Ratio a) | |
HasResolution a => Fractional (Fixed a) | |
Defined in Data.Fixed | |
Fractional a => Fractional (Const a b) | |
Defined in Data.Functor.Const | |
Fractional a => Fractional (Tagged s a) | |
class (Real a, Enum a) => Integral a where #
Methods
Instances
class (Num a, Ord a) => Real a where #
Methods
toRational :: a -> Rational #
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
Enum BlinkSpeed | |
Defined in System.Console.ANSI.Types Methods succ :: BlinkSpeed -> BlinkSpeed # pred :: BlinkSpeed -> BlinkSpeed # toEnum :: Int -> BlinkSpeed # fromEnum :: BlinkSpeed -> Int # enumFrom :: BlinkSpeed -> [BlinkSpeed] # enumFromThen :: BlinkSpeed -> BlinkSpeed -> [BlinkSpeed] # enumFromTo :: BlinkSpeed -> BlinkSpeed -> [BlinkSpeed] # enumFromThenTo :: BlinkSpeed -> BlinkSpeed -> BlinkSpeed -> [BlinkSpeed] # | |
Enum Color | |
Defined in System.Console.ANSI.Types | |
Enum ColorIntensity | |
Defined in System.Console.ANSI.Types Methods succ :: ColorIntensity -> ColorIntensity # pred :: ColorIntensity -> ColorIntensity # toEnum :: Int -> ColorIntensity # fromEnum :: ColorIntensity -> Int # enumFrom :: ColorIntensity -> [ColorIntensity] # enumFromThen :: ColorIntensity -> ColorIntensity -> [ColorIntensity] # enumFromTo :: ColorIntensity -> ColorIntensity -> [ColorIntensity] # enumFromThenTo :: ColorIntensity -> ColorIntensity -> ColorIntensity -> [ColorIntensity] # | |
Enum ConsoleIntensity | |
Defined in System.Console.ANSI.Types Methods succ :: ConsoleIntensity -> ConsoleIntensity # pred :: ConsoleIntensity -> ConsoleIntensity # toEnum :: Int -> ConsoleIntensity # fromEnum :: ConsoleIntensity -> Int # enumFrom :: ConsoleIntensity -> [ConsoleIntensity] # enumFromThen :: ConsoleIntensity -> ConsoleIntensity -> [ConsoleIntensity] # enumFromTo :: ConsoleIntensity -> ConsoleIntensity -> [ConsoleIntensity] # enumFromThenTo :: ConsoleIntensity -> ConsoleIntensity -> ConsoleIntensity -> [ConsoleIntensity] # | |
Enum ConsoleLayer | |
Defined in System.Console.ANSI.Types Methods succ :: ConsoleLayer -> ConsoleLayer # pred :: ConsoleLayer -> ConsoleLayer # toEnum :: Int -> ConsoleLayer # fromEnum :: ConsoleLayer -> Int # enumFrom :: ConsoleLayer -> [ConsoleLayer] # enumFromThen :: ConsoleLayer -> ConsoleLayer -> [ConsoleLayer] # enumFromTo :: ConsoleLayer -> ConsoleLayer -> [ConsoleLayer] # enumFromThenTo :: ConsoleLayer -> ConsoleLayer -> ConsoleLayer -> [ConsoleLayer] # | |
Enum Underlining | |
Defined in System.Console.ANSI.Types Methods succ :: Underlining -> Underlining # pred :: Underlining -> Underlining # toEnum :: Int -> Underlining # fromEnum :: Underlining -> Int # enumFrom :: Underlining -> [Underlining] # enumFromThen :: Underlining -> Underlining -> [Underlining] # enumFromTo :: Underlining -> Underlining -> [Underlining] # enumFromThenTo :: Underlining -> Underlining -> Underlining -> [Underlining] # | |
Enum Associativity | |
Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] # | |
Enum DecidedStrictness | |
Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # | |
Enum SourceStrictness | |
Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] # | |
Enum SourceUnpackedness | |
Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # | |
Enum Int16 | |
Enum Int32 | |
Enum Int64 | |
Enum Int8 | |
Enum DoCostCentres | |
Defined in GHC.RTS.Flags Methods succ :: DoCostCentres -> DoCostCentres # pred :: DoCostCentres -> DoCostCentres # toEnum :: Int -> DoCostCentres # fromEnum :: DoCostCentres -> Int # enumFrom :: DoCostCentres -> [DoCostCentres] # enumFromThen :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromTo :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromThenTo :: DoCostCentres -> DoCostCentres -> DoCostCentres -> [DoCostCentres] # | |
Enum DoHeapProfile | |
Defined in GHC.RTS.Flags Methods succ :: DoHeapProfile -> DoHeapProfile # pred :: DoHeapProfile -> DoHeapProfile # toEnum :: Int -> DoHeapProfile # fromEnum :: DoHeapProfile -> Int # enumFrom :: DoHeapProfile -> [DoHeapProfile] # enumFromThen :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromTo :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromThenTo :: DoHeapProfile -> DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # | |
Enum DoTrace | |
Defined in GHC.RTS.Flags Methods enumFrom :: DoTrace -> [DoTrace] # enumFromThen :: DoTrace -> DoTrace -> [DoTrace] # enumFromTo :: DoTrace -> DoTrace -> [DoTrace] # enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace] # | |
Enum GiveGCStats | |
Defined in GHC.RTS.Flags Methods succ :: GiveGCStats -> GiveGCStats # pred :: GiveGCStats -> GiveGCStats # toEnum :: Int -> GiveGCStats # fromEnum :: GiveGCStats -> Int # enumFrom :: GiveGCStats -> [GiveGCStats] # enumFromThen :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromTo :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromThenTo :: GiveGCStats -> GiveGCStats -> GiveGCStats -> [GiveGCStats] # | |
Enum IoSubSystem | |
Defined in GHC.RTS.Flags Methods succ :: IoSubSystem -> IoSubSystem # pred :: IoSubSystem -> IoSubSystem # toEnum :: Int -> IoSubSystem # fromEnum :: IoSubSystem -> Int # enumFrom :: IoSubSystem -> [IoSubSystem] # enumFromThen :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromTo :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromThenTo :: IoSubSystem -> IoSubSystem -> IoSubSystem -> [IoSubSystem] # | |
Enum GeneralCategory | |
Defined in GHC.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] # | |
Enum Word16 | |
Defined in GHC.Word | |
Enum Word32 | |
Defined in GHC.Word | |
Enum Word64 | |
Defined in GHC.Word | |
Enum Word8 | |
Enum Extension | |
Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] # | |
Enum Ordering | |
Enum WorkerCount Source # | |
Defined in Hedgehog.Internal.Config Methods succ :: WorkerCount -> WorkerCount # pred :: WorkerCount -> WorkerCount # toEnum :: Int -> WorkerCount # fromEnum :: WorkerCount -> Int # enumFrom :: WorkerCount -> [WorkerCount] # enumFromThen :: WorkerCount -> WorkerCount -> [WorkerCount] # enumFromTo :: WorkerCount -> WorkerCount -> [WorkerCount] # enumFromThenTo :: WorkerCount -> WorkerCount -> WorkerCount -> [WorkerCount] # | |
Enum DiscardCount Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: DiscardCount -> DiscardCount # pred :: DiscardCount -> DiscardCount # toEnum :: Int -> DiscardCount # fromEnum :: DiscardCount -> Int # enumFrom :: DiscardCount -> [DiscardCount] # enumFromThen :: DiscardCount -> DiscardCount -> [DiscardCount] # enumFromTo :: DiscardCount -> DiscardCount -> [DiscardCount] # enumFromThenTo :: DiscardCount -> DiscardCount -> DiscardCount -> [DiscardCount] # | |
Enum DiscardLimit Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: DiscardLimit -> DiscardLimit # pred :: DiscardLimit -> DiscardLimit # toEnum :: Int -> DiscardLimit # fromEnum :: DiscardLimit -> Int # enumFrom :: DiscardLimit -> [DiscardLimit] # enumFromThen :: DiscardLimit -> DiscardLimit -> [DiscardLimit] # enumFromTo :: DiscardLimit -> DiscardLimit -> [DiscardLimit] # enumFromThenTo :: DiscardLimit -> DiscardLimit -> DiscardLimit -> [DiscardLimit] # | |
Enum PropertyCount Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: PropertyCount -> PropertyCount # pred :: PropertyCount -> PropertyCount # toEnum :: Int -> PropertyCount # fromEnum :: PropertyCount -> Int # enumFrom :: PropertyCount -> [PropertyCount] # enumFromThen :: PropertyCount -> PropertyCount -> [PropertyCount] # enumFromTo :: PropertyCount -> PropertyCount -> [PropertyCount] # enumFromThenTo :: PropertyCount -> PropertyCount -> PropertyCount -> [PropertyCount] # | |
Enum ShrinkCount Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: ShrinkCount -> ShrinkCount # pred :: ShrinkCount -> ShrinkCount # toEnum :: Int -> ShrinkCount # fromEnum :: ShrinkCount -> Int # enumFrom :: ShrinkCount -> [ShrinkCount] # enumFromThen :: ShrinkCount -> ShrinkCount -> [ShrinkCount] # enumFromTo :: ShrinkCount -> ShrinkCount -> [ShrinkCount] # enumFromThenTo :: ShrinkCount -> ShrinkCount -> ShrinkCount -> [ShrinkCount] # | |
Enum ShrinkLimit Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: ShrinkLimit -> ShrinkLimit # pred :: ShrinkLimit -> ShrinkLimit # toEnum :: Int -> ShrinkLimit # fromEnum :: ShrinkLimit -> Int # enumFrom :: ShrinkLimit -> [ShrinkLimit] # enumFromThen :: ShrinkLimit -> ShrinkLimit -> [ShrinkLimit] # enumFromTo :: ShrinkLimit -> ShrinkLimit -> [ShrinkLimit] # enumFromThenTo :: ShrinkLimit -> ShrinkLimit -> ShrinkLimit -> [ShrinkLimit] # | |
Enum ShrinkRetries Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: ShrinkRetries -> ShrinkRetries # pred :: ShrinkRetries -> ShrinkRetries # toEnum :: Int -> ShrinkRetries # fromEnum :: ShrinkRetries -> Int # enumFrom :: ShrinkRetries -> [ShrinkRetries] # enumFromThen :: ShrinkRetries -> ShrinkRetries -> [ShrinkRetries] # enumFromTo :: ShrinkRetries -> ShrinkRetries -> [ShrinkRetries] # enumFromThenTo :: ShrinkRetries -> ShrinkRetries -> ShrinkRetries -> [ShrinkRetries] # | |
Enum TestCount Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: TestCount -> TestCount # pred :: TestCount -> TestCount # fromEnum :: TestCount -> Int # enumFrom :: TestCount -> [TestCount] # enumFromThen :: TestCount -> TestCount -> [TestCount] # enumFromTo :: TestCount -> TestCount -> [TestCount] # enumFromThenTo :: TestCount -> TestCount -> TestCount -> [TestCount] # | |
Enum TestLimit Source # | |
Defined in Hedgehog.Internal.Property Methods succ :: TestLimit -> TestLimit # pred :: TestLimit -> TestLimit # fromEnum :: TestLimit -> Int # enumFrom :: TestLimit -> [TestLimit] # enumFromThen :: TestLimit -> TestLimit -> [TestLimit] # enumFromTo :: TestLimit -> TestLimit -> [TestLimit] # enumFromThenTo :: TestLimit -> TestLimit -> TestLimit -> [TestLimit] # | |
Enum TaskIndex Source # | |
Defined in Hedgehog.Internal.Queue Methods succ :: TaskIndex -> TaskIndex # pred :: TaskIndex -> TaskIndex # fromEnum :: TaskIndex -> Int # enumFrom :: TaskIndex -> [TaskIndex] # enumFromThen :: TaskIndex -> TaskIndex -> [TaskIndex] # enumFromTo :: TaskIndex -> TaskIndex -> [TaskIndex] # enumFromThenTo :: TaskIndex -> TaskIndex -> TaskIndex -> [TaskIndex] # | |
Enum Size Source # | |
Enum ColumnNo Source # | |
Defined in Hedgehog.Internal.Source | |
Enum LineNo Source # | |
Defined in Hedgehog.Internal.Source | |
Enum NominalDiffTime | |
Defined in Data.Time.Clock.Internal.NominalDiffTime Methods succ :: NominalDiffTime -> NominalDiffTime # pred :: NominalDiffTime -> NominalDiffTime # toEnum :: Int -> NominalDiffTime # fromEnum :: NominalDiffTime -> Int # enumFrom :: NominalDiffTime -> [NominalDiffTime] # enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # | |
Enum Integer | |
Enum Natural | |
Defined in GHC.Enum Methods enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
Enum () | |
Enum Bool | |
Enum Char | |
Enum Int | |
Enum Levity | |
Defined in GHC.Enum | |
Enum VecCount | |
Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
Enum VecElem | |
Defined in GHC.Enum Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
Enum Word | |
Enum a => Enum (And a) | |
Enum a => Enum (Iff a) | |
Enum a => Enum (Ior a) | |
Enum a => Enum (Xor a) | |
Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
Enum a => Enum (First a) | |
Defined in Data.Semigroup Methods enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] # | |
Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
Integral a => Enum (Ratio a) | |
Defined in GHC.Real Methods enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # | |
Enum a => Enum (a) | |
Enum (Fixed a) | |
Defined in Data.Fixed Methods enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] # | |
Enum (Proxy s) | |
Defined in Data.Proxy Methods enumFrom :: Proxy s -> [Proxy s] # enumFromThen :: Proxy s -> Proxy s -> [Proxy s] # enumFromTo :: Proxy s -> Proxy s -> [Proxy s] # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] # | |
Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
Enum (f a) => Enum (Ap f a) | |
Defined in Data.Monoid | |
Enum (f a) => Enum (Alt f a) | |
Defined in Data.Semigroup.Internal Methods enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # | |
Enum a => Enum (Tagged s a) | |
Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a # pred :: Tagged s a -> Tagged s a # fromEnum :: Tagged s a -> Int # enumFrom :: Tagged s a -> [Tagged s a] # enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a] # |
Instances
class Fractional a => Floating a where #
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Methods
Instances
Floating Double | |
Floating Float | |
RealFloat a => Floating (Complex a) | |
Defined in Data.Complex Methods exp :: Complex a -> Complex a # log :: Complex a -> Complex a # sqrt :: Complex a -> Complex a # (**) :: Complex a -> Complex a -> Complex a # logBase :: Complex a -> Complex a -> Complex a # sin :: Complex a -> Complex a # cos :: Complex a -> Complex a # tan :: Complex a -> Complex a # asin :: Complex a -> Complex a # acos :: Complex a -> Complex a # atan :: Complex a -> Complex a # sinh :: Complex a -> Complex a # cosh :: Complex a -> Complex a # tanh :: Complex a -> Complex a # asinh :: Complex a -> Complex a # acosh :: Complex a -> Complex a # atanh :: Complex a -> Complex a # log1p :: Complex a -> Complex a expm1 :: Complex a -> Complex a log1pexp :: Complex a -> Complex a log1mexp :: Complex a -> Complex a | |
Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity Methods exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a expm1 :: Identity a -> Identity a log1pexp :: Identity a -> Identity a log1mexp :: Identity a -> Identity a | |
Floating a => Floating (Down a) | |
Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const Methods exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b log1pexp :: Const a b -> Const a b log1mexp :: Const a b -> Const a b | |
Floating a => Floating (Tagged s a) | |
Defined in Data.Tagged Methods exp :: Tagged s a -> Tagged s a # log :: Tagged s a -> Tagged s a # sqrt :: Tagged s a -> Tagged s a # (**) :: Tagged s a -> Tagged s a -> Tagged s a # logBase :: Tagged s a -> Tagged s a -> Tagged s a # sin :: Tagged s a -> Tagged s a # cos :: Tagged s a -> Tagged s a # tan :: Tagged s a -> Tagged s a # asin :: Tagged s a -> Tagged s a # acos :: Tagged s a -> Tagged s a # atan :: Tagged s a -> Tagged s a # sinh :: Tagged s a -> Tagged s a # cosh :: Tagged s a -> Tagged s a # tanh :: Tagged s a -> Tagged s a # asinh :: Tagged s a -> Tagged s a # acosh :: Tagged s a -> Tagged s a # atanh :: Tagged s a -> Tagged s a # log1p :: Tagged s a -> Tagged s a expm1 :: Tagged s a -> Tagged s a |
class (RealFrac a, Floating a) => RealFloat a where #
Minimal complete definition
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
Methods
floatRadix :: a -> Integer #
floatDigits :: a -> Int #
floatRange :: a -> (Int, Int) #
decodeFloat :: a -> (Integer, Int) #
encodeFloat :: Integer -> Int -> a #
significand :: a -> a #
scaleFloat :: Int -> a -> a #
isInfinite :: a -> Bool #
isDenormalized :: a -> Bool #
isNegativeZero :: a -> Bool #
Instances
Methods
fromInteger :: Integer -> a #
Instances
type IOError = IOException #
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a #
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a #
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a #
getContents :: IO String #
appendFile :: FilePath -> String -> IO () #
realToFrac :: (Real a, Fractional b) => a -> b #
fromIntegral :: (Integral a, Num b) => a -> b #
(^^) :: (Fractional a, Integral b) => a -> b -> a #
showString :: String -> ShowS #
(!!) :: HasCallStack => [a] -> Int -> a #
cycle :: HasCallStack => [a] -> [a] #
head :: HasCallStack => [a] -> a #
init :: HasCallStack => [a] -> [a] #
last :: HasCallStack => [a] -> a #
tail :: HasCallStack => [a] -> [a] #