Safe Haskell | None |
---|---|
Language | Haskell2010 |
Test.Hspec.Discover
Description
Warning: This module is used by hspec-discover
. It is not part of the public API and may change at any time.
Documentation
class IsFormatter a where Source #
Methods
toFormatter :: a -> IO Formatter Source #
Instances
IsFormatter Formatter Source # | |
Defined in Test.Hspec.Discover | |
IsFormatter (IO Formatter) Source # | |
Defined in Test.Hspec.Discover |
hspecWithFormatter :: IsFormatter a => a -> Spec -> IO () Source #
Methods
fromInteger :: Integer -> a #
Instances
Num OrdA | |
Num OrdB | |
Num OrdC | |
Num CBool | |
Num CChar | |
Num CClock | |
Num CDouble | |
Num CFloat | |
Num CInt | |
Num CIntMax | |
Num CIntPtr | |
Num CLLong | |
Num CLong | |
Num CPtrdiff | |
Num CSChar | |
Num CSUSeconds | |
Defined in Foreign.C.Types | |
Num CShort | |
Num CSigAtomic | |
Defined in Foreign.C.Types | |
Num CSize | |
Num CTime | |
Num CUChar | |
Num CUInt | |
Num CUIntMax | |
Num CUIntPtr | |
Num CULLong | |
Num CULong | |
Num CUSeconds | |
Defined in Foreign.C.Types | |
Num CUShort | |
Num CWchar | |
Num IntPtr | |
Num WordPtr | |
Num Int16 | |
Num Int32 | |
Num Int64 | |
Num Int8 | |
Num Word16 | |
Num Word32 | |
Num Word64 | |
Num Word8 | |
Num CBlkCnt | |
Num CBlkSize | |
Num CCc | |
Num CClockId | |
Num CDev | |
Num CFsBlkCnt | |
Defined in System.Posix.Types | |
Num CFsFilCnt | |
Defined in System.Posix.Types | |
Num CGid | |
Num CId | |
Num CIno | |
Num CKey | |
Num CMode | |
Num CNfds | |
Num CNlink | |
Num COff | |
Num CPid | |
Num CRLim | |
Num CSocklen | |
Num CSpeed | |
Num CSsize | |
Num CTcflag | |
Num CUid | |
Num Fd | |
Num Seconds | |
Num Integer | |
Num Natural | |
Num Int | |
Num Word | |
Num a => Num (Blind a) | |
Num a => Num (Fixed a) | |
Num a => Num (Large a) | |
Num a => Num (Shrink2 a) | |
Defined in Test.QuickCheck.Modifiers | |
Num a => Num (Small a) | |
RealFloat a => Num (Complex a) | |
Num a => Num (Identity a) | |
Defined in Data.Functor.Identity | |
Num a => Num (Down a) | |
Num a => Num (Max a) | |
Num a => Num (Min a) | |
Integral a => Num (Ratio a) | |
HasResolution a => Num (Fixed a) | |
Num a => Num (Op a b) | |
Num a => Num (Const a b) | |
Defined in Data.Functor.Const | |
(Applicative f, Num a) => Num (Ap f a) | |
Num (f (g a)) => Num (Compose f g a) | |
Defined in Data.Functor.Compose Methods (+) :: Compose f g a -> Compose f g a -> Compose f g a # (-) :: Compose f g a -> Compose f g a -> Compose f g a # (*) :: Compose f g a -> Compose f g a -> Compose f g a # negate :: Compose f g a -> Compose f g a # abs :: Compose f g a -> Compose f g a # signum :: Compose f g a -> Compose f g a # fromInteger :: Integer -> Compose f g a # |
Instances
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
Monad Gen | |
Monad Rose | |
Monad Complex | |
Monad Identity | |
Monad First | |
Monad Last | |
Monad Down | |
Monad First | |
Monad Last | |
Monad Max | |
Monad Min | |
Monad NonEmpty | |
Monad STM | |
Monad NoIO | |
Monad Par1 | |
Monad P | |
Monad ReadP | |
Monad ReadPrec | |
Monad IO | |
Monad Maybe | |
Monad Solo | |
Monad [] | |
Monad m => Monad (PropertyM m) | |
Monad m => Monad (WrappedMonad m) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Either e) | |
Monad (Proxy :: Type -> Type) | |
Monad (U1 :: Type -> Type) | |
Monad (ST s) | |
Monad (SpecM a) | |
Monoid a => Monad ((,) a) | |
Monad m => Monad (Kleisli m a) | |
Monad f => Monad (Ap f) | |
Monad f => Monad (Rec1 f) | |
(Monoid a, Monoid b) => Monad ((,,) a b) | |
(Monad f, Monad g) => Monad (Product f g) | |
(Monad f, Monad g) => Monad (f :*: g) | |
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
Monad ((->) r) | |
Monad f => Monad (M1 i c f) | |
Instances
Arbitrary Char | |||||
CoArbitrary Char | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Char -> Gen b -> Gen b | |||||
Function Char | |||||
Defined in Test.QuickCheck.Function | |||||
Data Char | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char dataTypeOf :: Char -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) gmapT :: (forall b. Data b => b -> b) -> Char -> Char gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char | |||||
Storable Char | |||||
Defined in Foreign.Storable | |||||
Bounded Char | |||||
Enum Char | |||||
Ix Char | |||||
Read Char | |||||
Show Char | |||||
IsChar Char | |||||
PrintfArg Char | |||||
Defined in Text.Printf | |||||
Eq Char | |||||
Ord Char | |||||
TestCoercion SChar | |||||
Defined in GHC.TypeLits Methods testCoercion :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (Coercion a b) | |||||
TestEquality SChar | |||||
Defined in GHC.TypeLits Methods testEquality :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (a :~: b) | |||||
Generic1 (URec Char :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
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) | |||||
Defined in GHC.Generics Associated Types
| |||||
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
Arbitrary Bool | |||||
CoArbitrary Bool | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Bool -> Gen b -> Gen b | |||||
Function Bool | |||||
Defined in Test.QuickCheck.Function | |||||
Testable Bool | |||||
Defined in Test.QuickCheck.Property Methods propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Bool) -> Property | |||||
Data Bool | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool dataTypeOf :: Bool -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool | |||||
Storable Bool | |||||
Defined in Foreign.Storable | |||||
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 | |||||
Defined in GHC.Generics Associated Types
| |||||
SingKind Bool | |||||
Defined in GHC.Generics Associated Types
| |||||
Ix Bool | |||||
Read Bool | |||||
Show Bool | |||||
Eq Bool | |||||
Ord Bool | |||||
Example Bool | |||||
Defined in Test.Hspec.Core.Example Associated Types
Methods evaluateExample :: Bool -> Params -> (ActionWith (Arg Bool) -> IO ()) -> ProgressCallback -> IO Result | |||||
SingI 'False | |||||
Defined in GHC.Generics | |||||
SingI 'True | |||||
Defined in GHC.Generics | |||||
Example (a -> Bool) | |||||
Defined in Test.Hspec.Core.Example Associated Types
Methods evaluateExample :: (a -> Bool) -> Params -> (ActionWith (Arg (a -> Bool)) -> IO ()) -> ProgressCallback -> IO Result | |||||
type DemoteRep Bool | |||||
Defined in GHC.Generics | |||||
type Rep Bool | |||||
Defined in GHC.Generics | |||||
data Sing (a :: Bool) | |||||
type Arg Bool | |||||
Defined in Test.Hspec.Core.Example | |||||
type Arg (a -> Bool) | |||||
Defined in Test.Hspec.Core.Example |
Instances
Eq FailureReason | |
Eq HUnitFailure | |
Eq Result | |
Eq Shrunk | |
Eq ASCIIString | |
Eq PrintableString | |
Eq UnicodeString | |
Eq A | |
Eq B | |
Eq C | |
Eq OrdA | |
Eq OrdB | |
Eq OrdC | |
Eq ByteArray | |
Eq Constr | |
Eq ConstrRep | |
Eq DataRep | |
Eq Fixity | |
Eq Unique | |
Eq Version | |
Eq Errno | |
Eq CBool | |
Eq CChar | |
Eq CClock | |
Eq CDouble | |
Eq CFloat | |
Eq CInt | |
Eq CIntMax | |
Eq CIntPtr | |
Eq CLLong | |
Eq CLong | |
Eq CPtrdiff | |
Eq CSChar | |
Eq CSUSeconds | |
Eq CShort | |
Eq CSigAtomic | |
Eq CSize | |
Eq CTime | |
Eq CUChar | |
Eq CUInt | |
Eq CUIntMax | |
Eq CUIntPtr | |
Eq CULLong | |
Eq CULong | |
Eq CUSeconds | |
Eq CUShort | |
Eq CWchar | |
Eq IntPtr | |
Eq WordPtr | |
Eq Void | |
Eq ByteOrder | |
Eq BlockReason | |
Eq ThreadId | |
Eq ThreadStatus | |
Eq TimeoutKey | |
Eq ErrorCall | |
Eq ArithException | |
Eq SpecConstrAnnotation | |
Eq Fingerprint | |
Eq Associativity | |
Eq DecidedStrictness | |
Eq Fixity | |
Eq SourceStrictness | |
Eq SourceUnpackedness | |
Eq MaskingState | |
Eq BufferState | |
Eq IODeviceType | |
Eq SeekMode | |
Eq CodingProgress | |
Eq ArrayException | |
Eq AsyncException | |
Eq ExitCode | |
Eq IOErrorType | |
Eq IOException | |
Eq HandlePosn | |
Eq BufferMode | |
Eq Handle | |
Eq Newline | |
Eq NewlineMode | |
Eq IOMode | |
Eq InfoProv | |
Eq Int16 | |
Eq Int32 | |
Eq Int64 | |
Eq Int8 | |
Eq IoSubSystem | |
Eq StackEntry | |
Eq SrcLoc | |
Eq SomeChar | |
Eq SomeSymbol | |
Eq SomeNat | |
Eq GeneralCategory | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq Word8 | |
Eq CBlkCnt | |
Eq CBlkSize | |
Eq CCc | |
Eq CClockId | |
Eq CDev | |
Eq CFsBlkCnt | |
Eq CFsFilCnt | |
Eq CGid | |
Eq CId | |
Eq CIno | |
Eq CKey | |
Eq CMode | |
Eq CNfds | |
Eq CNlink | |
Eq COff | |
Eq CPid | |
Eq CRLim | |
Eq CSocklen | |
Eq CSpeed | |
Eq CSsize | |
Eq CTcflag | |
Eq CTimer | |
Eq CUid | |
Eq Fd | |
Eq Timeout | |
Eq Lexeme | |
Eq Number | |
Eq BigNat | |
Eq Module | |
Eq Ordering | |
Eq TrName | |
Eq TyCon | |
Eq Seconds | |
Eq ColorMode | |
Eq UnicodeMode | |
Defined in Test.Hspec.Core.Config.Definition | |
Eq Location | |
Eq Chunk | |
Eq ColorChunk | |
Eq StartsWith | |
Eq ProgressReporting | |
Eq UseColor | |
Eq ResultItem | |
Defined in Test.Hspec.Core.Runner.Result | |
Eq ResultItemStatus | |
Defined in Test.Hspec.Core.Runner.Result Methods (==) :: ResultItemStatus -> ResultItemStatus -> Bool # (/=) :: ResultItemStatus -> ResultItemStatus -> Bool # | |
Eq SpecResult | |
Defined in Test.Hspec.Core.Runner.Result | |
Eq Summary | |
Eq Config | |
Eq Forest | |
Eq Hook | |
Eq Spec | |
Eq Tree | |
Eq Chunk | |
Eq NaturalSortKey | |
Eq LocalTime | |
Eq Integer | |
Eq Natural | |
Eq () | |
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Word | |
Eq a => Eq (Blind a) | |
Eq a => Eq (Fixed a) | |
Eq a => Eq (Large a) | |
Eq a => Eq (Negative a) | |
Eq a => Eq (NonEmptyList a) | |
Eq a => Eq (NonNegative a) | |
Eq a => Eq (NonPositive a) | |
Eq a => Eq (NonZero a) | |
Eq a => Eq (OrderedList a) | |
Eq a => Eq (Positive a) | |
Eq a => Eq (Shrink2 a) | |
Eq a => Eq (Small a) | |
Eq a => Eq (SortedList a) | |
Eq a => Eq (ZipList a) | |
Eq (Chan a) | |
Eq (MutableByteArray s) | |
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 (ConstPtr a) | |
Eq a => Eq (NonEmpty a) | |
Eq (TVar a) | |
Eq (ForeignPtr a) | |
Eq p => Eq (Par1 p) | |
Eq (IOPort a) | |
Eq (IORef a) | |
Eq (MVar a) | |
Eq (FunPtr a) | |
Eq (Ptr a) | |
Eq a => Eq (Ratio a) | |
Eq (StablePtr a) | |
Eq (StableName a) | |
Eq (SChar c) | |
Eq (SSymbol s) | |
Eq (SNat n) | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (Solo 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) | |
(Ix i, Eq e) => Eq (Array i e) | |
Eq (U1 p) | |
Eq (V1 p) | |
Eq (IOArray i e) | |
Eq (STRef s a) | |
(Eq c, Eq a) => Eq (Tree c a) | |
(Eq a, Eq b) => Eq (a, b) | |
Eq a => Eq (Const a b) | |
Eq (f a) => Eq (Ap f a) | |
Eq (Coercion a b) | |
Eq (a :~: b) | |
Eq (OrderingI a b) | |
Eq (STArray s i e) | |
(Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) | |
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 a, Eq b, Eq c) => Eq (a, b, c) | |
(Eq (f a), Eq (g a)) => Eq (Product f g a) | |
(Eq (f a), Eq (g a)) => Eq (Sum f g a) | |
Eq (a :~~: b) | |
(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) | |
Eq (f (g 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) | |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Functor Gen | |
Defined in Test.QuickCheck.Gen | |
Functor Blind | |
Defined in Test.QuickCheck.Modifiers | |
Functor Fixed | |
Defined in Test.QuickCheck.Modifiers | |
Functor Large | |
Defined in Test.QuickCheck.Modifiers | |
Functor Negative | |
Defined in Test.QuickCheck.Modifiers | |
Functor NonEmptyList | |
Defined in Test.QuickCheck.Modifiers | |
Functor NonNegative | |
Defined in Test.QuickCheck.Modifiers | |
Functor NonPositive | |
Defined in Test.QuickCheck.Modifiers | |
Functor NonZero | |
Defined in Test.QuickCheck.Modifiers | |
Functor OrderedList | |
Defined in Test.QuickCheck.Modifiers | |
Functor Positive | |
Defined in Test.QuickCheck.Modifiers | |
Functor Shrink2 | |
Defined in Test.QuickCheck.Modifiers | |
Functor Small | |
Defined in Test.QuickCheck.Modifiers | |
Functor Smart | |
Defined in Test.QuickCheck.Modifiers | |
Functor SortedList | |
Defined in Test.QuickCheck.Modifiers | |
Functor Rose | |
Defined in Test.QuickCheck.Property | |
Functor ZipList | |
Defined in Control.Applicative | |
Functor Handler | |
Defined in Control.Exception | |
Functor Complex | |
Defined in Data.Complex | |
Functor Identity | |
Defined in Data.Functor.Identity | |
Functor First | |
Defined in Data.Monoid | |
Functor Last | |
Defined in Data.Monoid | |
Functor Down | |
Functor First | |
Defined in Data.Semigroup | |
Functor Last | |
Defined in Data.Semigroup | |
Functor Max | |
Defined in Data.Semigroup | |
Functor Min | |
Defined in Data.Semigroup | |
Functor NonEmpty | |
Functor STM | |
Defined in GHC.Conc.Sync | |
Functor NoIO | |
Functor Par1 | |
Defined in GHC.Generics | |
Functor ArgDescr | |
Defined in System.Console.GetOpt | |
Functor ArgOrder | |
Defined in System.Console.GetOpt | |
Functor OptDescr | |
Defined in System.Console.GetOpt | |
Functor P | |
Defined in Text.ParserCombinators.ReadP | |
Functor ReadP | |
Defined in Text.ParserCombinators.ReadP | |
Functor ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
Functor IO | |
Functor FormatF | |
Defined in Test.Hspec.Core.Formatters.V1.Monad | |
Functor Maybe | |
Functor Solo | |
Functor [] | |
Functor ((:->) a) | |
Defined in Test.QuickCheck.Function | |
Functor (Fun a) | |
Defined in Test.QuickCheck.Function | |
Functor (Shrinking s) | |
Defined in Test.QuickCheck.Modifiers | |
Functor (PropertyM m) | |
Defined in Test.QuickCheck.Monadic | |
Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative | |
Arrow a => Functor (ArrowMonad a) | |
Defined in Control.Arrow | |
Functor (Either a) | |
Functor (Proxy :: Type -> Type) | |
Defined in Data.Proxy | |
Functor (Arg a) | |
Defined in Data.Semigroup | |
Functor (Array i) | |
Functor (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (V1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (ST s) | |
Functor (SpecM a) | |
Defined in Test.Hspec.Core.Spec.Monad | |
Functor (Tree c) | |
Defined in Test.Hspec.Core.Tree | |
Functor ((,) a) | |
Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative | |
Functor m => Functor (Kleisli m a) | |
Defined in Control.Arrow | |
Functor (Const m :: Type -> Type) | |
Defined in Data.Functor.Const | |
Functor f => Functor (Ap f) | |
Defined in Data.Monoid | |
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) | |
Defined in GHC.Generics | |
Functor f => Functor (Rec1 f) | |
Defined in GHC.Generics | |
Functor (URec (Ptr ()) :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Char :: Type -> Type) | |
Functor (URec Double :: Type -> Type) | |
Functor (URec Float :: Type -> Type) | |
Functor (URec Int :: Type -> Type) | |
Functor (URec Word :: Type -> Type) | |
Functor ((,,) a b) | |
(Functor f, Functor g) => Functor (Product f g) | |
Defined in Data.Functor.Product | |
(Functor f, Functor g) => Functor (Sum f g) | |
Defined in Data.Functor.Sum | |
(Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Generics | |
Functor (K1 i c :: Type -> Type) | |
Defined in GHC.Generics | |
Functor ((,,,) a b c) | |
Functor ((->) r) | |
(Functor f, Functor g) => Functor (Compose f g) | |
Defined in Data.Functor.Compose | |
(Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Generics | |
Functor f => Functor (M1 i c f) | |
Defined in GHC.Generics | |
Functor ((,,,,) a b c d) | |
Functor ((,,,,,) a b c d e) | |
Functor ((,,,,,,) a b c d e f) | |
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 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 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 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 (Tree c) | |
Defined in Test.Hspec.Core.Tree Methods fold :: Monoid m => Tree c m -> m foldMap :: Monoid m => (a -> m) -> Tree c a -> m # foldMap' :: Monoid m => (a -> m) -> Tree c a -> m foldr :: (a -> b -> b) -> b -> Tree c a -> b # foldr' :: (a -> b -> b) -> b -> Tree c a -> b foldl :: (b -> a -> b) -> b -> Tree c a -> b # foldl' :: (b -> a -> b) -> b -> Tree c a -> b foldr1 :: (a -> a -> a) -> Tree c a -> a # foldl1 :: (a -> a -> a) -> Tree c a -> a # toList :: Tree c a -> [a] elem :: Eq a => a -> Tree c a -> Bool # maximum :: Ord a => Tree c a -> a # minimum :: Ord a => Tree c 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 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
Arbitrary Double | |||||
CoArbitrary Double | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Double -> Gen b -> Gen b | |||||
Function Double | |||||
Defined in Test.QuickCheck.Function | |||||
Data Double | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double dataTypeOf :: Double -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) gmapT :: (forall b. Data b => b -> b) -> Double -> Double gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double | |||||
Storable Double | |||||
Defined in Foreign.Storable | |||||
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 | |||||
Eq Double | |||||
Ord Double | |||||
Generic1 (URec Double :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
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) | |||||
Defined in GHC.Generics Associated Types
| |||||
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
Arbitrary Float | |||||
CoArbitrary Float | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Float -> Gen b -> Gen b | |||||
Function Float | |||||
Defined in Test.QuickCheck.Function | |||||
Data Float | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float dataTypeOf :: Float -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) gmapT :: (forall b. Data b => b -> b) -> Float -> Float gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float | |||||
Storable Float | |||||
Defined in Foreign.Storable | |||||
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 | |||||
Eq Float | |||||
Ord Float | |||||
Generic1 (URec Float :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
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) | |||||
Defined in GHC.Generics Associated Types
| |||||
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
Arbitrary Int | |||||
CoArbitrary Int | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int -> Gen b -> Gen b | |||||
Function Int | |||||
Defined in Test.QuickCheck.Function | |||||
Data Int | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int dataTypeOf :: Int -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) gmapT :: (forall b. Data b => b -> b) -> Int -> Int gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int | |||||
Storable Int | |||||
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 | |||||
Ix 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 | |||||
Eq Int | |||||
Ord Int | |||||
Generic1 (URec Int :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
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) | |||||
Defined in GHC.Generics Associated Types
| |||||
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
Arbitrary Word | |||||
CoArbitrary Word | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word -> Gen b -> Gen b | |||||
Function Word | |||||
Defined in Test.QuickCheck.Function | |||||
Data Word | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word dataTypeOf :: Word -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) gmapT :: (forall b. Data b => b -> b) -> Word -> Word gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word | |||||
Storable Word | |||||
Defined in Foreign.Storable | |||||
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 | |||||
Ix 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 | |||||
Eq Word | |||||
Ord Word | |||||
Generic1 (URec Word :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
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) | |||||
Defined in GHC.Generics Associated Types
| |||||
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
Arbitrary Ordering | |||||
CoArbitrary Ordering | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Ordering -> Gen b -> Gen b | |||||
Function Ordering | |||||
Defined in Test.QuickCheck.Function | |||||
Data Ordering | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering toConstr :: Ordering -> Constr dataTypeOf :: Ordering -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering | |||||
Monoid Ordering | |||||
Semigroup Ordering | |||||
Bounded Ordering | |||||
Enum Ordering | |||||
Generic Ordering | |||||
Defined in GHC.Generics Associated Types
| |||||
Ix Ordering | |||||
Defined in GHC.Ix | |||||
Read Ordering | |||||
Show Ordering | |||||
Eq Ordering | |||||
Ord Ordering | |||||
Defined in GHC.Classes | |||||
type Rep Ordering | |||||
Instances
Arbitrary1 Maybe | |||||
Defined in Test.QuickCheck.Arbitrary | |||||
MonadFail Maybe | |||||
Defined in Control.Monad.Fail | |||||
MonadFix Maybe | |||||
Defined in Control.Monad.Fix | |||||
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 | |||||
Generic1 Maybe | |||||
Defined in GHC.Generics Associated Types
| |||||
Arbitrary a => Arbitrary (Maybe a) | |||||
CoArbitrary a => CoArbitrary (Maybe a) | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Maybe a -> Gen b -> Gen b | |||||
Function a => Function (Maybe a) | |||||
Defined in Test.QuickCheck.Function | |||||
Testable prop => Testable (Maybe prop) | |||||
Defined in Test.QuickCheck.Property Methods property :: Maybe prop -> Property propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Maybe prop) -> Property | |||||
Data a => Data (Maybe a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) dataTypeOf :: Maybe a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) | |||||
Semigroup a => Monoid (Maybe a) | |||||
Semigroup a => Semigroup (Maybe a) | |||||
Generic (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
SingKind a => SingKind (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
Read a => Read (Maybe a) | |||||
Show a => Show (Maybe a) | |||||
Eq a => Eq (Maybe a) | |||||
Ord a => Ord (Maybe a) | |||||
SingI ('Nothing :: Maybe a) | |||||
Defined in GHC.Generics | |||||
SingI a2 => SingI ('Just a2 :: Maybe a1) | |||||
Defined in GHC.Generics | |||||
type Rep1 Maybe | |||||
type DemoteRep (Maybe a) | |||||
Defined in GHC.Generics | |||||
type Rep (Maybe a) | |||||
Defined in GHC.Generics | |||||
data Sing (b :: Maybe a) | |||||
Instances
Arbitrary Integer | |
CoArbitrary Integer | |
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Integer -> Gen b -> Gen b | |
Function Integer | |
Defined in Test.QuickCheck.Function | |
Data Integer | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer dataTypeOf :: Integer -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer | |
Bits Integer | |
Defined in GHC.Bits Methods (.&.) :: Integer -> Integer -> Integer (.|.) :: Integer -> Integer -> Integer xor :: Integer -> Integer -> Integer complement :: Integer -> Integer shift :: Integer -> Int -> Integer rotate :: Integer -> Int -> Integer setBit :: Integer -> Int -> Integer clearBit :: Integer -> Int -> Integer complementBit :: Integer -> Int -> Integer testBit :: Integer -> Int -> Bool bitSizeMaybe :: Integer -> Maybe Int shiftL :: Integer -> Int -> Integer unsafeShiftL :: Integer -> Int -> Integer shiftR :: Integer -> Int -> Integer unsafeShiftR :: Integer -> Int -> Integer rotateL :: Integer -> Int -> Integer | |
Enum Integer | |
Ix Integer | |
Num Integer | |
Read Integer | |
Integral Integer | |
Defined in GHC.Real | |
Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
Show Integer | |
PrintfArg Integer | |
Defined in Text.Printf | |
Eq Integer | |
Ord Integer | |
class Functor f => Applicative (f :: Type -> Type) where #
Instances
Applicative Gen | |
Applicative Rose | |
Applicative ZipList | |
Applicative Complex | |
Applicative Identity | |
Applicative First | |
Applicative Last | |
Applicative Down | |
Applicative First | |
Applicative Last | |
Applicative Max | |
Applicative Min | |
Applicative NonEmpty | |
Applicative STM | |
Applicative NoIO | |
Applicative Par1 | |
Applicative P | |
Applicative ReadP | |
Applicative ReadPrec | |
Applicative IO | |
Applicative Maybe | |
Applicative Solo | |
Applicative [] | |
Applicative (PropertyM m) | |
Defined in Test.QuickCheck.Monadic | |
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 (Either e) | |
Applicative (Proxy :: Type -> Type) | |
Applicative (U1 :: Type -> Type) | |
Applicative (ST s) | |
Applicative (SpecM a) | |
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) | |
(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) | |
(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) | |
(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) | |
class Semigroup a => Monoid a where #
Instances
Monoid ByteArray | |
Monoid Ordering | |
Monoid Annotations | |
Monoid Summary | |
Monoid () | |
FiniteBits a => Monoid (And a) | |
FiniteBits a => Monoid (Iff a) | |
Bits a => Monoid (Ior a) | |
Bits a => Monoid (Xor a) | |
Monoid (Comparison a) | |
Monoid (Equivalence a) | |
Monoid (Predicate a) | |
Monoid a => Monoid (Identity 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 (STM a) | |
(Generic a, Monoid (Rep a ())) => Monoid (Generically a) | |
Monoid p => Monoid (Par1 p) | |
Monoid a => Monoid (IO a) | |
Semigroup a => Monoid (Maybe a) | |
Monoid a => Monoid (Solo a) | |
Monoid [a] | |
Monoid a => Monoid (Op a b) | |
Monoid (Proxy s) | |
Monoid (U1 p) | |
Monoid a => Monoid (ST s a) | |
(Monoid a, Monoid b) => Monoid (a, b) | |
Monoid b => Monoid (a -> b) | |
Monoid a => Monoid (Const a b) | |
(Applicative f, Monoid a) => Monoid (Ap f a) | |
Monoid (f p) => Monoid (Rec1 f p) | |
(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) | |
Minimal complete definition
(<>) | sconcat
Instances
Semigroup ByteArray | |
Semigroup Void | |
Semigroup Ordering | |
Semigroup Annotations | |
Semigroup Summary | |
Semigroup () | |
Bits a => Semigroup (And a) | |
FiniteBits a => Semigroup (Iff a) | |
Bits a => Semigroup (Ior a) | |
Bits a => Semigroup (Xor a) | |
Semigroup (FromMaybe b) | |
Semigroup a => Semigroup (JoinWith a) | |
Semigroup (NonEmptyDList a) | |
Semigroup (Comparison a) | |
Semigroup (Equivalence a) | |
Semigroup (Predicate a) | |
Semigroup a => Semigroup (Identity a) | |
Semigroup (First a) | |
Semigroup (Last a) | |
Semigroup a => Semigroup (Down a) | |
Semigroup (First a) | |
Semigroup (Last a) | |
Ord a => Semigroup (Max a) | |
Ord a => Semigroup (Min a) | |
Monoid m => Semigroup (WrappedMonoid m) | |
Semigroup (NonEmpty a) | |
Semigroup a => Semigroup (STM a) | |
(Generic a, Semigroup (Rep a ())) => Semigroup (Generically a) | |
Semigroup p => Semigroup (Par1 p) | |
Semigroup a => Semigroup (IO a) | |
Semigroup a => Semigroup (Maybe a) | |
Semigroup a => Semigroup (Solo a) | |
Semigroup [a] | |
Semigroup (Either a b) | |
Semigroup a => Semigroup (Op a b) | |
Semigroup (Proxy s) | |
Semigroup (U1 p) | |
Semigroup (V1 p) | |
Semigroup a => Semigroup (ST s a) | |
(Semigroup a, Semigroup b) => Semigroup (a, b) | |
Semigroup b => Semigroup (a -> b) | |
Semigroup a => Semigroup (Const a b) | |
(Applicative f, Semigroup a) => Semigroup (Ap f a) | |
Semigroup (f p) => Semigroup (Rec1 f p) | |
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) | |
(Semigroup (f a), Semigroup (g a)) => Semigroup (Product f g a) | |
(Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) | |
Semigroup c => Semigroup (K1 i c p) | |
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) | |
Semigroup (f (g a)) => Semigroup (Compose f g a) | |
Semigroup (f (g p)) => Semigroup ((f :.: g) p) | |
Semigroup (f p) => Semigroup (M1 i c f p) | |
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) | |
(!!) :: HasCallStack => [a] -> Int -> a #
cycle :: HasCallStack => [a] -> [a] #
head :: HasCallStack => [a] -> a #
init :: HasCallStack => [a] -> [a] #
last :: HasCallStack => [a] -> a #
tail :: HasCallStack => [a] -> [a] #
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
Traversable ZipList | |
Defined in Data.Traversable | |
Traversable Complex | |
Defined in Data.Complex | |
Traversable Identity | |
Defined in Data.Traversable | |
Traversable First | |
Defined in Data.Traversable | |
Traversable Last | |
Defined in Data.Traversable | |
Traversable Down | |
Defined in Data.Traversable | |
Traversable First | |
Defined in Data.Semigroup | |
Traversable Last | |
Defined in Data.Semigroup | |
Traversable Max | |
Defined in Data.Semigroup | |
Traversable Min | |
Defined in Data.Semigroup | |
Traversable Dual | |
Defined in Data.Traversable | |
Traversable Product | |
Defined in Data.Traversable | |
Traversable Sum | |
Defined in Data.Traversable | |
Traversable NonEmpty | |
Defined in Data.Traversable | |
Traversable Par1 | |
Defined in Data.Traversable | |
Traversable Maybe | |
Traversable Solo | |
Defined in Data.Traversable | |
Traversable [] | |
Defined in Data.Traversable | |
Traversable (Either a) | |
Defined in Data.Traversable | |
Traversable (Proxy :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (Arg a) | |
Defined in Data.Semigroup | |
Ix i => Traversable (Array i) | |
Defined in Data.Traversable | |
Traversable (U1 :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (UAddr :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (UChar :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (UDouble :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (UFloat :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (UInt :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (UWord :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (V1 :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable (Tree c) | |
Defined in Test.Hspec.Core.Tree | |
Traversable ((,) a) | |
Defined in Data.Traversable | |
Traversable (Const m :: Type -> Type) | |
Defined in Data.Traversable | |
Traversable f => Traversable (Ap f) | |
Defined in Data.Traversable | |
Traversable f => Traversable (Alt f) | |
Defined in Data.Traversable | |
Traversable f => Traversable (Rec1 f) | |
Defined in Data.Traversable | |
(Traversable f, Traversable g) => Traversable (Product f g) | |
Defined in Data.Functor.Product | |
(Traversable f, Traversable g) => Traversable (Sum f g) | |
Defined in Data.Functor.Sum | |
(Traversable f, Traversable g) => Traversable (f :*: g) | |
Defined in Data.Traversable | |
(Traversable f, Traversable g) => Traversable (f :+: g) | |
Defined in Data.Traversable | |
Traversable (K1 i c :: Type -> Type) | |
Defined in Data.Traversable | |
(Traversable f, Traversable g) => Traversable (Compose f g) | |
Defined in Data.Functor.Compose | |
(Traversable f, Traversable g) => Traversable (f :.: g) | |
Defined in Data.Traversable | |
Traversable f => Traversable (M1 i c f) | |
Defined in Data.Traversable |
Minimal complete definition
readsPrec | readPrec
Instances
Read ASCIIString | |
Defined in Test.QuickCheck.Modifiers | |
Read PrintableString | |
Defined in Test.QuickCheck.Modifiers | |
Read UnicodeString | |
Defined in Test.QuickCheck.Modifiers | |
Read QCGen | |
Defined in Test.QuickCheck.Random | |
Read Args | |
Defined in Test.QuickCheck.Test | |
Read Version | |
Defined in Data.Version | |
Read CBool | |
Defined in Foreign.C.Types | |
Read CChar | |
Defined in Foreign.C.Types | |
Read CClock | |
Defined in Foreign.C.Types | |
Read CDouble | |
Defined in Foreign.C.Types | |
Read CFloat | |
Defined in Foreign.C.Types | |
Read CInt | |
Defined in Foreign.C.Types | |
Read CIntMax | |
Defined in Foreign.C.Types | |
Read CIntPtr | |
Defined in Foreign.C.Types | |
Read CLLong | |
Defined in Foreign.C.Types | |
Read CLong | |
Defined in Foreign.C.Types | |
Read CPtrdiff | |
Defined in Foreign.C.Types | |
Read CSChar | |
Defined in Foreign.C.Types | |
Read CSUSeconds | |
Defined in Foreign.C.Types | |
Read CShort | |
Defined in Foreign.C.Types | |
Read CSigAtomic | |
Defined in Foreign.C.Types | |
Read CSize | |
Defined in Foreign.C.Types | |
Read CTime | |
Defined in Foreign.C.Types | |
Read CUChar | |
Defined in Foreign.C.Types | |
Read CUInt | |
Defined in Foreign.C.Types | |
Read CUIntMax | |
Defined in Foreign.C.Types | |
Read CUIntPtr | |
Defined in Foreign.C.Types | |
Read CULLong | |
Defined in Foreign.C.Types | |
Read CULong | |
Defined in Foreign.C.Types | |
Read CUSeconds | |
Defined in Foreign.C.Types | |
Read CUShort | |
Defined in Foreign.C.Types | |
Read CWchar | |
Defined in Foreign.C.Types | |
Read IntPtr | |
Defined in Foreign.Ptr | |
Read WordPtr | |
Defined in Foreign.Ptr | |
Read Void | |
Read ByteOrder | |
Defined in GHC.ByteOrder | |
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 SeekMode | |
Defined in GHC.IO.Device | |
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 IOMode | |
Defined in GHC.IO.IOMode | |
Read Int16 | |
Read Int32 | |
Read Int64 | |
Read Int8 | |
Read GCDetails | |
Read RTSStats | |
Read SomeChar | |
Defined in GHC.TypeLits | |
Read SomeSymbol | |
Defined in GHC.TypeLits | |
Read SomeNat | |
Defined in GHC.TypeNats | |
Read GeneralCategory | |
Read Word16 | |
Read Word32 | |
Read Word64 | |
Read Word8 | |
Read CBlkCnt | |
Defined in System.Posix.Types | |
Read CBlkSize | |
Defined in System.Posix.Types | |
Read CCc | |
Defined in System.Posix.Types | |
Read CClockId | |
Defined in System.Posix.Types | |
Read CDev | |
Defined in System.Posix.Types | |
Read CFsBlkCnt | |
Defined in System.Posix.Types | |
Read CFsFilCnt | |
Defined in System.Posix.Types | |
Read CGid | |
Defined in System.Posix.Types | |
Read CId | |
Defined in System.Posix.Types | |
Read CIno | |
Defined in System.Posix.Types | |
Read CKey | |
Defined in System.Posix.Types | |
Read CMode | |
Defined in System.Posix.Types | |
Read CNfds | |
Defined in System.Posix.Types | |
Read CNlink | |
Defined in System.Posix.Types | |
Read COff | |
Defined in System.Posix.Types | |
Read CPid | |
Defined in System.Posix.Types | |
Read CRLim | |
Defined in System.Posix.Types | |
Read CSocklen | |
Defined in System.Posix.Types | |
Read CSpeed | |
Defined in System.Posix.Types | |
Read CSsize | |
Defined in System.Posix.Types | |
Read CTcflag | |
Defined in System.Posix.Types | |
Read CUid | |
Defined in System.Posix.Types | |
Read Fd | |
Defined in System.Posix.Types | |
Read Lexeme | |
Read Ordering | |
Read Location | |
Defined in Test.Hspec.Core.Example.Location | |
Read Integer | |
Read Natural | |
Read () | |
Read Bool | |
Read Char | |
Read Double | |
Read Float | |
Read Int | |
Read Word | |
Read a => Read (Fixed a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (Large a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (Negative a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (NonEmptyList a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (NonNegative a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (NonPositive a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (NonZero a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (OrderedList a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (Positive a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (Shrink2 a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (Small a) | |
Defined in Test.QuickCheck.Modifiers | |
Read a => Read (SortedList a) | |
Defined in Test.QuickCheck.Modifiers | |
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 (NonEmpty a) | |
Read p => Read (Par1 p) | |
Defined in GHC.Generics | |
(Integral a, Read a) => Read (Ratio a) | |
Read a => Read (Maybe a) | |
Read a => Read (Solo 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 | |
(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 | |
Coercible a b => Read (Coercion a b) | |
Defined in Data.Type.Coercion | |
a ~ b => Read (a :~: b) | |
Defined in Data.Type.Equality | |
Read (f p) => Read (Rec1 f p) | |
Defined in GHC.Generics | |
(Read a, Read b, Read c) => Read (a, b, c) | |
(Read (f a), Read (g a)) => Read (Product f g a) | |
Defined in Data.Functor.Product | |
(Read (f a), Read (g a)) => Read (Sum f g a) | |
Defined in Data.Functor.Sum | |
a ~~ b => Read (a :~~: b) | |
Defined in Data.Type.Equality | |
(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) | |
Read (f (g 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 |
Instances
Show FailureReason | |
Show HUnitFailure | |
Show Result | |
Show ASCIIString | |
Show PrintableString | |
Show UnicodeString | |
Show A | |
Show B | |
Show C | |
Show OrdA | |
Show OrdB | |
Show OrdC | |
Show QCGen | |
Show Confidence | |
Show Args | |
Show Result | |
Show Cell | |
Show Str | |
Show NestedAtomically | |
Show NoMatchingContinuationPrompt | |
Show NoMethodError | |
Show NonTermination | |
Show PatternMatchFail | |
Show RecConError | |
Show RecSelError | |
Show RecUpdError | |
Show TypeError | |
Show ByteArray | |
Show Constr | |
Show ConstrRep | |
Show DataRep | |
Show DataType | |
Show Fixity | |
Show Dynamic | |
Show Version | |
Show CBool | |
Show CChar | |
Show CClock | |
Show CDouble | |
Show CFloat | |
Show CInt | |
Show CIntMax | |
Show CIntPtr | |
Show CLLong | |
Show CLong | |
Show CPtrdiff | |
Show CSChar | |
Show CSUSeconds | |
Show CShort | |
Show CSigAtomic | |
Show CSize | |
Show CTime | |
Show CUChar | |
Show CUInt | |
Show CUIntMax | |
Show CUIntPtr | |
Show CULLong | |
Show CULong | |
Show CUSeconds | |
Show CUShort | |
Show CWchar | |
Show IntPtr | |
Show WordPtr | |
Show Void | |
Show ByteOrder | |
Show BlockReason | |
Show ThreadId | |
Show ThreadStatus | |
Show ErrorCall | |
Show ArithException | |
Show SomeException | |
Show Fingerprint | |
Show Associativity | |
Show DecidedStrictness | |
Show Fixity | |
Show SourceStrictness | |
Show SourceUnpackedness | |
Show MaskingState | |
Show SeekMode | |
Show CodingFailureMode | |
Show CodingProgress | |
Show TextEncoding | |
Show AllocationLimitExceeded | |
Show ArrayException | |
Show AssertionFailed | |
Show AsyncException | |
Show BlockedIndefinitelyOnMVar | |
Show BlockedIndefinitelyOnSTM | |
Show CompactionFailed | |
Show Deadlock | |
Show ExitCode | |
Show FixIOException | |
Show IOErrorType | |
Show IOException | |
Show SomeAsyncException | |
Show FD | |
Show HandlePosn | |
Show BufferMode | |
Show Handle | |
Show HandleType | |
Show Newline | |
Show NewlineMode | |
Show IOMode | |
Show IOPortException | |
Show InfoProv | |
Show Int16 | |
Show Int32 | |
Show Int64 | |
Show Int8 | |
Show CCFlags | |
Show ConcFlags | |
Show DebugFlags | |
Show DoCostCentres | |
Show DoHeapProfile | |
Show DoTrace | |
Show GCFlags | |
Show GiveGCStats | |
Show IoSubSystem | |
Show MiscFlags | |
Show ParFlags | |
Show ProfFlags | |
Show RTSFlags | |
Show TickyFlags | |
Show TraceFlags | |
Show FractionalExponentBase | |
Show StackEntry | |
Show CallStack | |
Show SrcLoc | |
Show StaticPtrInfo | |
Show GCDetails | |
Show RTSStats | |
Show SomeChar | |
Show SomeSymbol | |
Show SomeNat | |
Show GeneralCategory | |
Show Word16 | |
Show Word32 | |
Show Word64 | |
Show Word8 | |
Show CBlkCnt | |
Show CBlkSize | |
Show CCc | |
Show CClockId | |
Show CDev | |
Show CFsBlkCnt | |
Show CFsFilCnt | |
Show CGid | |
Show CId | |
Show CIno | |
Show CKey | |
Show CMode | |
Show CNfds | |
Show CNlink | |
Show COff | |
Show CPid | |
Show CRLim | |
Show CSocklen | |
Show CSpeed | |
Show CSsize | |
Show CTcflag | |
Show CTimer | |
Show CUid | |
Show Fd | |
Show Timeout | |
Show Lexeme | |
Show Number | |
Show KindRep | |
Show Module | |
Show Ordering | |
Show TrName | |
Show TyCon | |
Show TypeLitSort | |
Show Seconds | |
Show ColorMode | |
Show UnicodeMode | |
Defined in Test.Hspec.Core.Config.Definition Methods showsPrec :: Int -> UnicodeMode -> ShowS # show :: UnicodeMode -> String # showList :: [UnicodeMode] -> ShowS # | |
Show FailureReason | |
Show Params | |
Show Result | |
Show ResultStatus | |
Show Location | |
Show Event | |
Show Item | |
Show Result | |
Show FailureReason | |
Defined in Test.Hspec.Core.Formatters.V1.Monad Methods showsPrec :: Int -> FailureReason -> ShowS # show :: FailureReason -> String # showList :: [FailureReason] -> ShowS # | |
Show Chunk | |
Show ColorChunk | |
Show ProgressReporting | |
Show UseColor | |
Show ResultItem | |
Defined in Test.Hspec.Core.Runner.Result Methods showsPrec :: Int -> ResultItem -> ShowS # show :: ResultItem -> String # showList :: [ResultItem] -> ShowS # | |
Show ResultItemStatus | |
Defined in Test.Hspec.Core.Runner.Result Methods showsPrec :: Int -> ResultItemStatus -> ShowS # show :: ResultItemStatus -> String # showList :: [ResultItemStatus] -> ShowS # | |
Show SpecResult | |
Defined in Test.Hspec.Core.Runner.Result Methods showsPrec :: Int -> SpecResult -> ShowS # show :: SpecResult -> String # showList :: [SpecResult] -> ShowS # | |
Show Summary | |
Show Config | |
Show Forest | |
Show Hook | |
Show Spec | |
Show Tree | |
Show LocalTime | |
Show ZonedTime | |
Show Integer | |
Show Natural | |
Show () | |
Show Bool | |
Show Char | |
Show Int | |
Show Levity | |
Show RuntimeRep | |
Show VecCount | |
Show VecElem | |
Show Word | |
Show (Blind a) | |
Show a => Show (Fixed a) | |
Show a => Show (InfiniteList a) | |
Show a => Show (Large a) | |
Show a => Show (Negative a) | |
Show a => Show (NonEmptyList a) | |
Show a => Show (NonNegative a) | |
Show a => Show (NonPositive a) | |
Show a => Show (NonZero a) | |
Show a => Show (OrderedList a) | |
Show a => Show (Positive a) | |
Show a => Show (Shrink2 a) | |
Show a => Show (Small a) | |
Show a => Show (Smart a) | |
Show a => Show (SortedList a) | |
Show a => Show (ZipList a) | |
Show a => Show (And a) | |
Show a => Show (Iff a) | |
Show a => Show (Ior a) | |
Show a => Show (Xor a) | |
Show a => Show (Complex a) | |
Show a => Show (Identity a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Down a) | |
Show a => Show (First a) | |
Show a => Show (Last a) | |
Show a => Show (Max a) | |
Show a => Show (Min a) | |
Show m => Show (WrappedMonoid m) | |
Show (ConstPtr a) | |
Show a => Show (NonEmpty a) | |
Show (ForeignPtr a) | |
Show p => Show (Par1 p) | |
Show (FunPtr a) | |
Show (Ptr a) | |
Show a => Show (Ratio a) | |
Show (SChar c) | |
Show (SSymbol s) | |
Show (SNat n) | |
Show a => Show (Maybe a) | |
Show a => Show (Solo a) | |
Show a => Show [a] | |
(Show a, Show b) => Show (a :-> b) | |
(Show a, Show b) => Show (Fun a b) | |
Show a => Show (Shrinking s a) | |
(Show a, Show b) => Show (Either a b) | |
HasResolution a => Show (Fixed a) | |
Show (Proxy s) | |
(Show a, Show b) => Show (Arg a b) | |
(Ix a, Show a, Show b) => Show (Array a b) | |
Show (U1 p) | |
Show (V1 p) | |
Show (ST s a) | |
(Show c, Show a) => Show (Tree c a) | |
(Show a, Show b) => Show (a, b) | |
Show a => Show (Const a b) | |
Show (f a) => Show (Ap f a) | |
Show (Coercion a b) | |
Show (a :~: b) | |
Show (OrderingI a b) | |
Show (f p) => Show (Rec1 f p) | |
Show (URec Char p) | |
Show (URec Double p) | |
Show (URec Float p) | |
Show (URec Int p) | |
Show (URec Word p) | |
(Show a, Show b, Show c) => Show (a, b, c) | |
(Show (f a), Show (g a)) => Show (Product f g a) | |
(Show (f a), Show (g a)) => Show (Sum f g a) | |
Show (a :~~: b) | |
(Show (f p), Show (g p)) => Show ((f :*: g) p) | |
(Show (f p), Show (g p)) => Show ((f :+: g) p) | |
Show c => Show (K1 i c p) | |
(Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
Show (f (g a)) => Show (Compose f g a) | |
Show (f (g p)) => Show ((f :.: g) p) | |
Show (f p) => Show (M1 i c f p) | |
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
showString :: String -> ShowS #
Instances
Ord ASCIIString | |
Defined in Test.QuickCheck.Modifiers | |
Ord PrintableString | |
Defined in Test.QuickCheck.Modifiers Methods compare :: PrintableString -> PrintableString -> Ordering # (<) :: PrintableString -> PrintableString -> Bool # (<=) :: PrintableString -> PrintableString -> Bool # (>) :: PrintableString -> PrintableString -> Bool # (>=) :: PrintableString -> PrintableString -> Bool # max :: PrintableString -> PrintableString -> PrintableString # min :: PrintableString -> PrintableString -> PrintableString # | |
Ord UnicodeString | |
Defined in Test.QuickCheck.Modifiers Methods compare :: UnicodeString -> UnicodeString -> Ordering # (<) :: UnicodeString -> UnicodeString -> Bool # (<=) :: UnicodeString -> UnicodeString -> Bool # (>) :: UnicodeString -> UnicodeString -> Bool # (>=) :: UnicodeString -> UnicodeString -> Bool # | |
Ord OrdA | |
Ord OrdB | |
Ord OrdC | |
Ord ByteArray | |
Ord Unique | |
Ord Version | |
Ord CBool | |
Ord CChar | |
Ord CClock | |
Ord CDouble | |
Ord CFloat | |
Ord CInt | |
Ord CIntMax | |
Ord CIntPtr | |
Ord CLLong | |
Ord CLong | |
Ord CPtrdiff | |
Defined in Foreign.C.Types | |
Ord CSChar | |
Ord CSUSeconds | |
Ord CShort | |
Ord CSigAtomic | |
Ord CSize | |
Ord CTime | |
Ord CUChar | |
Ord CUInt | |
Ord CUIntMax | |
Defined in Foreign.C.Types | |
Ord CUIntPtr | |
Defined in Foreign.C.Types | |
Ord CULLong | |
Ord CULong | |
Ord CUSeconds | |
Ord CUShort | |
Ord CWchar | |
Ord IntPtr | |
Ord WordPtr | |
Ord Void | |
Ord ByteOrder | |
Ord BlockReason | |
Defined in GHC.Conc.Sync | |
Ord ThreadId | |
Defined in GHC.Conc.Sync | |
Ord ThreadStatus | |
Defined in GHC.Conc.Sync | |
Ord TimeoutKey | |
Ord ErrorCall | |
Ord ArithException | |
Defined in GHC.Exception.Type Methods compare :: ArithException -> ArithException -> Ordering # (<) :: ArithException -> ArithException -> Bool # (<=) :: ArithException -> ArithException -> Bool # (>) :: ArithException -> ArithException -> Bool # (>=) :: ArithException -> ArithException -> Bool # | |
Ord Fingerprint | |
Defined in GHC.Fingerprint.Type | |
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 SeekMode | |
Defined in GHC.IO.Device | |
Ord ArrayException | |
Defined in GHC.IO.Exception Methods compare :: ArrayException -> ArrayException -> Ordering # (<) :: ArrayException -> ArrayException -> Bool # (<=) :: ArrayException -> ArrayException -> Bool # (>) :: ArrayException -> ArrayException -> Bool # (>=) :: ArrayException -> ArrayException -> Bool # | |
Ord AsyncException | |
Defined in GHC.IO.Exception Methods compare :: AsyncException -> AsyncException -> Ordering # (<) :: AsyncException -> AsyncException -> Bool # (<=) :: AsyncException -> AsyncException -> Bool # (>) :: AsyncException -> AsyncException -> Bool # (>=) :: AsyncException -> AsyncException -> Bool # | |
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 IOMode | |
Ord Int16 | |
Ord Int32 | |
Ord Int64 | |
Ord Int8 | |
Ord SomeChar | |
Defined in GHC.TypeLits | |
Ord SomeSymbol | |
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 CBlkCnt | |
Ord CBlkSize | |
Defined in System.Posix.Types | |
Ord CCc | |
Ord CClockId | |
Defined in System.Posix.Types | |
Ord CDev | |
Ord CFsBlkCnt | |
Ord CFsFilCnt | |
Ord CGid | |
Ord CId | |
Ord CIno | |
Ord CKey | |
Ord CMode | |
Ord CNfds | |
Ord CNlink | |
Ord COff | |
Ord CPid | |
Ord CRLim | |
Ord CSocklen | |
Defined in System.Posix.Types | |
Ord CSpeed | |
Ord CSsize | |
Ord CTcflag | |
Ord CTimer | |
Ord CUid | |
Ord Fd | |
Ord BigNat | |
Ord Ordering | |
Defined in GHC.Classes | |
Ord TyCon | |
Ord Seconds | |
Defined in Test.Hspec.Core.Clock | |
Ord Chunk | |
Ord NaturalSortKey | |
Defined in Test.Hspec.Discover.Sort Methods compare :: NaturalSortKey -> NaturalSortKey -> Ordering # (<) :: NaturalSortKey -> NaturalSortKey -> Bool # (<=) :: NaturalSortKey -> NaturalSortKey -> Bool # (>) :: NaturalSortKey -> NaturalSortKey -> Bool # (>=) :: NaturalSortKey -> NaturalSortKey -> Bool # | |
Ord LocalTime | |
Defined in Data.Time.LocalTime.Internal.LocalTime | |
Ord Integer | |
Ord Natural | |
Ord () | |
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Word | |
Ord a => Ord (Blind a) | |
Defined in Test.QuickCheck.Modifiers | |
Ord a => Ord (Fixed a) | |
Defined in Test.QuickCheck.Modifiers | |
Ord a => Ord (Large a) | |
Defined in Test.QuickCheck.Modifiers | |
Ord a => Ord (Negative a) | |
Defined in Test.QuickCheck.Modifiers | |
Ord a => Ord (NonEmptyList a) | |
Defined in Test.QuickCheck.Modifiers Methods compare :: NonEmptyList a -> NonEmptyList a -> Ordering # (<) :: NonEmptyList a -> NonEmptyList a -> Bool # (<=) :: NonEmptyList a -> NonEmptyList a -> Bool # (>) :: NonEmptyList a -> NonEmptyList a -> Bool # (>=) :: NonEmptyList a -> NonEmptyList a -> Bool # | |
Ord a => Ord (NonNegative a) | |
Defined in Test.QuickCheck.Modifiers Methods compare :: NonNegative a -> NonNegative a -> Ordering # (<) :: NonNegative a -> NonNegative a -> Bool # (<=) :: NonNegative a -> NonNegative a -> Bool # (>) :: NonNegative a -> NonNegative a -> Bool # (>=) :: NonNegative a -> NonNegative a -> Bool # | |
Ord a => Ord (NonPositive a) | |
Defined in Test.QuickCheck.Modifiers Methods compare :: NonPositive a -> NonPositive a -> Ordering # (<) :: NonPositive a -> NonPositive a -> Bool # (<=) :: NonPositive a -> NonPositive a -> Bool # (>) :: NonPositive a -> NonPositive a -> Bool # (>=) :: NonPositive a -> NonPositive a -> Bool # | |
Ord a => Ord (NonZero a) | |
Ord a => Ord (OrderedList a) | |
Defined in Test.QuickCheck.Modifiers Methods compare :: OrderedList a -> OrderedList a -> Ordering # (<) :: OrderedList a -> OrderedList a -> Bool # (<=) :: OrderedList a -> OrderedList a -> Bool # (>) :: OrderedList a -> OrderedList a -> Bool # (>=) :: OrderedList a -> OrderedList a -> Bool # | |
Ord a => Ord (Positive a) | |
Defined in Test.QuickCheck.Modifiers | |
Ord a => Ord (Shrink2 a) | |
Ord a => Ord (Small a) | |
Defined in Test.QuickCheck.Modifiers | |
Ord a => Ord (SortedList a) | |
Defined in Test.QuickCheck.Modifiers | |
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 (ConstPtr a) | |
Ord a => Ord (NonEmpty a) | |
Ord (ForeignPtr a) | |
Defined in GHC.ForeignPtr | |
Ord p => Ord (Par1 p) | |
Ord (FunPtr a) | |
Defined in GHC.Ptr | |
Ord (Ptr a) | |
Integral a => Ord (Ratio a) | |
Ord (SChar c) | |
Ord (SSymbol s) | |
Ord (SNat n) | |
Ord a => Ord (Maybe a) | |
Ord a => Ord (Solo 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) | |
(Ix i, Ord e) => Ord (Array i e) | |
Ord (U1 p) | |
Ord (V1 p) | |
(Ord a, Ord b) => Ord (a, b) | |
Ord a => Ord (Const a b) | |
Ord (f a) => Ord (Ap f a) | |
Ord (Coercion a b) | |
Defined in Data.Type.Coercion | |
Ord (a :~: b) | |
Defined in Data.Type.Equality | |
(Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) | |
Defined in GHC.Generics Methods compare :: Generically1 f a -> Generically1 f a -> Ordering # (<) :: Generically1 f a -> Generically1 f a -> Bool # (<=) :: Generically1 f a -> Generically1 f a -> Bool # (>) :: Generically1 f a -> Generically1 f a -> Bool # (>=) :: Generically1 f a -> Generically1 f a -> Bool # max :: Generically1 f a -> Generically1 f a -> Generically1 f a # min :: Generically1 f a -> Generically1 f a -> Generically1 f a # | |
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 a, Ord b, Ord c) => Ord (a, b, c) | |
(Ord (f a), Ord (g 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 # | |
(Ord (f a), Ord (g a)) => Ord (Sum f g a) | |
Ord (a :~~: b) | |
(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 | |
Ord (f (g 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) # |
fromIntegral :: (Integral a, Num b) => a -> b #
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
MonadFail P | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP | |
MonadFail ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
MonadFail IO | |
Defined in Control.Monad.Fail | |
MonadFail Maybe | |
Defined in Control.Monad.Fail | |
MonadFail [] | |
Defined in Control.Monad.Fail | |
Monad m => MonadFail (PropertyM m) | |
Defined in Test.QuickCheck.Monadic | |
MonadFail f => MonadFail (Ap f) | |
Defined in Data.Monoid |
Instances
Arbitrary2 Either | |||||
Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Either a b) liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Either a b -> [Either a b] | |||||
Bifoldable Either | |||||
Bifoldable1 Either | |||||
Defined in Data.Bifoldable1 | |||||
Bifunctor Either | |||||
Bitraversable Either | |||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) | |||||
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 | |||||
Generic1 (Either a :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
Arbitrary a => Arbitrary1 (Either a) | |||||
Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (Either a a0) liftShrink :: (a0 -> [a0]) -> Either a a0 -> [Either a a0] | |||||
MonadFix (Either e) | |||||
Defined in Control.Monad.Fix | |||||
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) | |||||
(Arbitrary a, Arbitrary b) => Arbitrary (Either a b) | |||||
(CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b) | |||||
Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Either a b -> Gen b0 -> Gen b0 | |||||
(Function a, Function b) => Function (Either a b) | |||||
Defined in Test.QuickCheck.Function | |||||
(Data a, Data b) => Data (Either a b) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) toConstr :: Either a b -> Constr dataTypeOf :: Either a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) | |||||
Semigroup (Either a b) | |||||
Generic (Either a b) | |||||
Defined in GHC.Generics Associated Types
| |||||
(Read a, Read b) => Read (Either a b) | |||||
(Show a, Show b) => Show (Either a b) | |||||
(Eq a, Eq b) => Eq (Either a b) | |||||
(Ord a, Ord b) => Ord (Either a b) | |||||
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 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))) |
Instances
Bounded CBool | |
Defined in Foreign.C.Types | |
Bounded CChar | |
Defined in Foreign.C.Types | |
Bounded CInt | |
Defined in Foreign.C.Types | |
Bounded CIntMax | |
Defined in Foreign.C.Types | |
Bounded CIntPtr | |
Defined in Foreign.C.Types | |
Bounded CLLong | |
Defined in Foreign.C.Types | |
Bounded CLong | |
Defined in Foreign.C.Types | |
Bounded CPtrdiff | |
Defined in Foreign.C.Types | |
Bounded CSChar | |
Defined in Foreign.C.Types | |
Bounded CShort | |
Defined in Foreign.C.Types | |
Bounded CSigAtomic | |
Defined in Foreign.C.Types | |
Bounded CSize | |
Defined in Foreign.C.Types | |
Bounded CUChar | |
Defined in Foreign.C.Types | |
Bounded CUInt | |
Defined in Foreign.C.Types | |
Bounded CUIntMax | |
Defined in Foreign.C.Types | |
Bounded CUIntPtr | |
Defined in Foreign.C.Types | |
Bounded CULLong | |
Defined in Foreign.C.Types | |
Bounded CULong | |
Defined in Foreign.C.Types | |
Bounded CUShort | |
Defined in Foreign.C.Types | |
Bounded CWchar | |
Defined in Foreign.C.Types | |
Bounded IntPtr | |
Defined in Foreign.Ptr | |
Bounded WordPtr | |
Defined in Foreign.Ptr | |
Bounded ByteOrder | |
Defined in GHC.ByteOrder | |
Bounded Associativity | |
Defined in GHC.Generics | |
Bounded DecidedStrictness | |
Defined in GHC.Generics | |
Bounded SourceStrictness | |
Defined in GHC.Generics | |
Bounded SourceUnpackedness | |
Defined in GHC.Generics | |
Bounded Int16 | |
Bounded Int32 | |
Bounded Int64 | |
Bounded Int8 | |
Bounded GeneralCategory | |
Defined in GHC.Unicode | |
Bounded Word16 | |
Bounded Word32 | |
Bounded Word64 | |
Bounded Word8 | |
Bounded CBlkCnt | |
Defined in System.Posix.Types | |
Bounded CBlkSize | |
Defined in System.Posix.Types | |
Bounded CClockId | |
Defined in System.Posix.Types | |
Bounded CDev | |
Defined in System.Posix.Types | |
Bounded CFsBlkCnt | |
Defined in System.Posix.Types | |
Bounded CFsFilCnt | |
Defined in System.Posix.Types | |
Bounded CGid | |
Defined in System.Posix.Types | |
Bounded CId | |
Defined in System.Posix.Types | |
Bounded CIno | |
Defined in System.Posix.Types | |
Bounded CKey | |
Defined in System.Posix.Types | |
Bounded CMode | |
Defined in System.Posix.Types | |
Bounded CNfds | |
Defined in System.Posix.Types | |
Bounded CNlink | |
Defined in System.Posix.Types | |
Bounded COff | |
Defined in System.Posix.Types | |
Bounded CPid | |
Defined in System.Posix.Types | |
Bounded CRLim | |
Defined in System.Posix.Types | |
Bounded CSocklen | |
Defined in System.Posix.Types | |
Bounded CSsize | |
Defined in System.Posix.Types | |
Bounded CTcflag | |
Defined in System.Posix.Types | |
Bounded CUid | |
Defined in System.Posix.Types | |
Bounded Fd | |
Defined in System.Posix.Types | |
Bounded Ordering | |
Bounded FailOn | |
Defined in Test.Hspec.Core.Config.Definition | |
Bounded () | |
Bounded Bool | |
Bounded Char | |
Bounded Int | |
Bounded Levity | |
Bounded VecCount | |
Bounded VecElem | |
Bounded Word | |
Bounded a => Bounded (And a) | |
Bounded a => Bounded (Iff a) | |
Bounded a => Bounded (Ior a) | |
Bounded a => Bounded (Xor a) | |
Bounded a => Bounded (Identity a) | |
Defined in Data.Functor.Identity | |
Bounded a => Bounded (Down a) | |
Bounded a => Bounded (First a) | |
Defined in Data.Semigroup | |
Bounded a => Bounded (Last a) | |
Defined in Data.Semigroup | |
Bounded a => Bounded (Max a) | |
Defined in Data.Semigroup | |
Bounded a => Bounded (Min a) | |
Defined in Data.Semigroup | |
Bounded m => Bounded (WrappedMonoid m) | |
Defined in Data.Semigroup | |
Bounded a => Bounded (Solo a) | |
Bounded (Proxy t) | |
Defined in Data.Proxy | |
(Bounded a, Bounded b) => Bounded (a, b) | |
Bounded a => Bounded (Const a b) | |
Defined in Data.Functor.Const | |
(Applicative f, Bounded a) => Bounded (Ap f a) | |
Defined in Data.Monoid | |
Coercible a b => Bounded (Coercion a b) | |
Defined in Data.Type.Coercion | |
a ~ b => Bounded (a :~: b) | |
Defined in Data.Type.Equality | |
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) | |
a ~~ b => Bounded (a :~~: b) | |
Defined in Data.Type.Equality | |
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) | |
Bounded (f (g a)) => Bounded (Compose f g a) | |
Defined in Data.Functor.Compose | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
Enum CBool | |
Defined in Foreign.C.Types | |
Enum CChar | |
Defined in Foreign.C.Types | |
Enum CClock | |
Defined in Foreign.C.Types | |
Enum CDouble | |
Defined in Foreign.C.Types Methods enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] # | |
Enum CFloat | |
Defined in Foreign.C.Types | |
Enum CInt | |
Defined in Foreign.C.Types | |
Enum CIntMax | |
Defined in Foreign.C.Types Methods enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] # | |
Enum CIntPtr | |
Defined in Foreign.C.Types Methods enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] # | |
Enum CLLong | |
Defined in Foreign.C.Types | |
Enum CLong | |
Defined in Foreign.C.Types | |
Enum CPtrdiff | |
Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] # | |
Enum CSChar | |
Defined in Foreign.C.Types | |
Enum CSUSeconds | |
Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
Enum CShort | |
Defined in Foreign.C.Types | |
Enum CSigAtomic | |
Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
Enum CSize | |
Defined in Foreign.C.Types | |
Enum CTime | |
Defined in Foreign.C.Types | |
Enum CUChar | |
Defined in Foreign.C.Types | |
Enum CUInt | |
Defined in Foreign.C.Types | |
Enum CUIntMax | |
Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] # | |
Enum CUIntPtr | |
Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] # | |
Enum CULLong | |
Defined in Foreign.C.Types Methods enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] # | |
Enum CULong | |
Defined in Foreign.C.Types | |
Enum CUSeconds | |
Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
Enum CUShort | |
Defined in Foreign.C.Types Methods enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] # | |
Enum CWchar | |
Defined in Foreign.C.Types | |
Enum IntPtr | |
Defined in Foreign.Ptr | |
Enum WordPtr | |
Defined in Foreign.Ptr Methods enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] # | |
Enum ByteOrder | |
Defined in GHC.ByteOrder Methods succ :: ByteOrder -> ByteOrder # pred :: ByteOrder -> ByteOrder # fromEnum :: ByteOrder -> Int # enumFrom :: ByteOrder -> [ByteOrder] # enumFromThen :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromTo :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromThenTo :: ByteOrder -> ByteOrder -> ByteOrder -> [ByteOrder] # | |
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 SeekMode | |
Defined in GHC.IO.Device Methods succ :: SeekMode -> SeekMode # pred :: SeekMode -> SeekMode # enumFrom :: SeekMode -> [SeekMode] # enumFromThen :: SeekMode -> SeekMode -> [SeekMode] # enumFromTo :: SeekMode -> SeekMode -> [SeekMode] # enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode] # | |
Enum IOMode | |
Defined in GHC.IO.IOMode | |
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 CBlkCnt | |
Defined in System.Posix.Types Methods enumFrom :: CBlkCnt -> [CBlkCnt] # enumFromThen :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromTo :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromThenTo :: CBlkCnt -> CBlkCnt -> CBlkCnt -> [CBlkCnt] # | |
Enum CBlkSize | |
Defined in System.Posix.Types Methods succ :: CBlkSize -> CBlkSize # pred :: CBlkSize -> CBlkSize # enumFrom :: CBlkSize -> [CBlkSize] # enumFromThen :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromTo :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromThenTo :: CBlkSize -> CBlkSize -> CBlkSize -> [CBlkSize] # | |
Enum CCc | |
Defined in System.Posix.Types | |
Enum CClockId | |
Defined in System.Posix.Types Methods succ :: CClockId -> CClockId # pred :: CClockId -> CClockId # enumFrom :: CClockId -> [CClockId] # enumFromThen :: CClockId -> CClockId -> [CClockId] # enumFromTo :: CClockId -> CClockId -> [CClockId] # enumFromThenTo :: CClockId -> CClockId -> CClockId -> [CClockId] # | |
Enum CDev | |
Defined in System.Posix.Types | |
Enum CFsBlkCnt | |
Defined in System.Posix.Types Methods succ :: CFsBlkCnt -> CFsBlkCnt # pred :: CFsBlkCnt -> CFsBlkCnt # fromEnum :: CFsBlkCnt -> Int # enumFrom :: CFsBlkCnt -> [CFsBlkCnt] # enumFromThen :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromTo :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromThenTo :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # | |
Enum CFsFilCnt | |
Defined in System.Posix.Types Methods succ :: CFsFilCnt -> CFsFilCnt # pred :: CFsFilCnt -> CFsFilCnt # fromEnum :: CFsFilCnt -> Int # enumFrom :: CFsFilCnt -> [CFsFilCnt] # enumFromThen :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromTo :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromThenTo :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # | |
Enum CGid | |
Defined in System.Posix.Types | |
Enum CId | |
Defined in System.Posix.Types | |
Enum CIno | |
Defined in System.Posix.Types | |
Enum CKey | |
Defined in System.Posix.Types | |
Enum CMode | |
Defined in System.Posix.Types | |
Enum CNfds | |
Defined in System.Posix.Types | |
Enum CNlink | |
Defined in System.Posix.Types | |
Enum COff | |
Defined in System.Posix.Types | |
Enum CPid | |
Defined in System.Posix.Types | |
Enum CRLim | |
Defined in System.Posix.Types | |
Enum CSocklen | |
Defined in System.Posix.Types Methods succ :: CSocklen -> CSocklen # pred :: CSocklen -> CSocklen # enumFrom :: CSocklen -> [CSocklen] # enumFromThen :: CSocklen -> CSocklen -> [CSocklen] # enumFromTo :: CSocklen -> CSocklen -> [CSocklen] # enumFromThenTo :: CSocklen -> CSocklen -> CSocklen -> [CSocklen] # | |
Enum CSpeed | |
Defined in System.Posix.Types | |
Enum CSsize | |
Defined in System.Posix.Types | |
Enum CTcflag | |
Defined in System.Posix.Types Methods enumFrom :: CTcflag -> [CTcflag] # enumFromThen :: CTcflag -> CTcflag -> [CTcflag] # enumFromTo :: CTcflag -> CTcflag -> [CTcflag] # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag] # | |
Enum CUid | |
Defined in System.Posix.Types | |
Enum Fd | |
Defined in System.Posix.Types | |
Enum Ordering | |
Enum FailOn | |
Defined in Test.Hspec.Core.Config.Definition | |
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 (Blind a) | |
Defined in Test.QuickCheck.Modifiers Methods enumFrom :: Blind a -> [Blind a] # enumFromThen :: Blind a -> Blind a -> [Blind a] # enumFromTo :: Blind a -> Blind a -> [Blind a] # enumFromThenTo :: Blind a -> Blind a -> Blind a -> [Blind a] # | |
Enum a => Enum (Fixed a) | |
Defined in Test.QuickCheck.Modifiers 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 a => Enum (Large a) | |
Defined in Test.QuickCheck.Modifiers Methods enumFrom :: Large a -> [Large a] # enumFromThen :: Large a -> Large a -> [Large a] # enumFromTo :: Large a -> Large a -> [Large a] # enumFromThenTo :: Large a -> Large a -> Large a -> [Large a] # | |
Enum a => Enum (Negative a) | |
Defined in Test.QuickCheck.Modifiers Methods succ :: Negative a -> Negative a # pred :: Negative a -> Negative a # fromEnum :: Negative a -> Int # enumFrom :: Negative a -> [Negative a] # enumFromThen :: Negative a -> Negative a -> [Negative a] # enumFromTo :: Negative a -> Negative a -> [Negative a] # enumFromThenTo :: Negative a -> Negative a -> Negative a -> [Negative a] # | |
Enum a => Enum (NonNegative a) | |
Defined in Test.QuickCheck.Modifiers Methods succ :: NonNegative a -> NonNegative a # pred :: NonNegative a -> NonNegative a # toEnum :: Int -> NonNegative a # fromEnum :: NonNegative a -> Int # enumFrom :: NonNegative a -> [NonNegative a] # enumFromThen :: NonNegative a -> NonNegative a -> [NonNegative a] # enumFromTo :: NonNegative a -> NonNegative a -> [NonNegative a] # enumFromThenTo :: NonNegative a -> NonNegative a -> NonNegative a -> [NonNegative a] # | |
Enum a => Enum (NonPositive a) | |
Defined in Test.QuickCheck.Modifiers Methods succ :: NonPositive a -> NonPositive a # pred :: NonPositive a -> NonPositive a # toEnum :: Int -> NonPositive a # fromEnum :: NonPositive a -> Int # enumFrom :: NonPositive a -> [NonPositive a] # enumFromThen :: NonPositive a -> NonPositive a -> [NonPositive a] # enumFromTo :: NonPositive a -> NonPositive a -> [NonPositive a] # enumFromThenTo :: NonPositive a -> NonPositive a -> NonPositive a -> [NonPositive a] # | |
Enum a => Enum (NonZero a) | |
Defined in Test.QuickCheck.Modifiers Methods succ :: NonZero a -> NonZero a # pred :: NonZero a -> NonZero a # fromEnum :: NonZero a -> Int # enumFrom :: NonZero a -> [NonZero a] # enumFromThen :: NonZero a -> NonZero a -> [NonZero a] # enumFromTo :: NonZero a -> NonZero a -> [NonZero a] # enumFromThenTo :: NonZero a -> NonZero a -> NonZero a -> [NonZero a] # | |
Enum a => Enum (Positive a) | |
Defined in Test.QuickCheck.Modifiers Methods succ :: Positive a -> Positive a # pred :: Positive a -> Positive a # fromEnum :: Positive a -> Int # enumFrom :: Positive a -> [Positive a] # enumFromThen :: Positive a -> Positive a -> [Positive a] # enumFromTo :: Positive a -> Positive a -> [Positive a] # enumFromThenTo :: Positive a -> Positive a -> Positive a -> [Positive a] # | |
Enum a => Enum (Shrink2 a) | |
Defined in Test.QuickCheck.Modifiers Methods succ :: Shrink2 a -> Shrink2 a # pred :: Shrink2 a -> Shrink2 a # fromEnum :: Shrink2 a -> Int # enumFrom :: Shrink2 a -> [Shrink2 a] # enumFromThen :: Shrink2 a -> Shrink2 a -> [Shrink2 a] # enumFromTo :: Shrink2 a -> Shrink2 a -> [Shrink2 a] # enumFromThenTo :: Shrink2 a -> Shrink2 a -> Shrink2 a -> [Shrink2 a] # | |
Enum a => Enum (Small a) | |
Defined in Test.QuickCheck.Modifiers Methods enumFrom :: Small a -> [Small a] # enumFromThen :: Small a -> Small a -> [Small a] # enumFromTo :: Small a -> Small a -> [Small a] # enumFromThenTo :: Small a -> Small a -> Small a -> [Small a] # | |
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, Bounded a, Eq a) => Enum (Down a) | |
Defined in Data.Ord | |
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 (Solo a) | |
Defined in GHC.Enum | |
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 | |
Coercible a b => Enum (Coercion a b) | |
Defined in Data.Type.Coercion Methods succ :: Coercion a b -> Coercion a b # pred :: Coercion a b -> Coercion a b # toEnum :: Int -> Coercion a b # fromEnum :: Coercion a b -> Int # enumFrom :: Coercion a b -> [Coercion a b] # enumFromThen :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromTo :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [Coercion a b] # | |
a ~ b => Enum (a :~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] # | |
a ~~ b => Enum (a :~~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] # | |
Enum (f (g a)) => Enum (Compose f g a) | |
Defined in Data.Functor.Compose Methods succ :: Compose f g a -> Compose f g a # pred :: Compose f g a -> Compose f g a # toEnum :: Int -> Compose f g a # fromEnum :: Compose f g a -> Int # enumFrom :: Compose f g a -> [Compose f g a] # enumFromThen :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromTo :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromThenTo :: Compose f g a -> Compose f g a -> Compose f g a -> [Compose f g a] # |
error :: HasCallStack => [Char] -> a #
errorWithoutStackTrace :: [Char] -> a #
undefined :: HasCallStack => a #
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 CDouble | |
Floating CFloat | |
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 (Op a b) | |
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 |
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
RealFloat CDouble | |
Defined in Foreign.C.Types Methods floatRadix :: CDouble -> Integer # floatDigits :: CDouble -> Int # floatRange :: CDouble -> (Int, Int) # decodeFloat :: CDouble -> (Integer, Int) # encodeFloat :: Integer -> Int -> CDouble # significand :: CDouble -> CDouble # scaleFloat :: Int -> CDouble -> CDouble # isInfinite :: CDouble -> Bool # isDenormalized :: CDouble -> Bool # isNegativeZero :: CDouble -> Bool # | |
RealFloat CFloat | |
Defined in Foreign.C.Types Methods floatRadix :: CFloat -> Integer # floatDigits :: CFloat -> Int # floatRange :: CFloat -> (Int, Int) # decodeFloat :: CFloat -> (Integer, Int) # encodeFloat :: Integer -> Int -> CFloat # significand :: CFloat -> CFloat # scaleFloat :: Int -> CFloat -> CFloat # isInfinite :: CFloat -> Bool # isDenormalized :: CFloat -> Bool # isNegativeZero :: CFloat -> Bool # | |
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 # | |
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 # | |
RealFloat a => RealFloat (Identity a) | |
Defined in Data.Functor.Identity Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # | |
RealFloat a => RealFloat (Down a) | |
Defined in Data.Ord Methods floatRadix :: Down a -> Integer # floatDigits :: Down a -> Int # floatRange :: Down a -> (Int, Int) # decodeFloat :: Down a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Down a # significand :: Down a -> Down a # scaleFloat :: Int -> Down a -> Down a # isInfinite :: Down a -> Bool # isDenormalized :: Down a -> Bool # isNegativeZero :: Down a -> Bool # | |
RealFloat a => RealFloat (Const a b) | |
Defined in Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # |
class Num a => Fractional a where #
Minimal complete definition
fromRational, (recip | (/))
Instances
Fractional CDouble | |
Defined in Foreign.C.Types | |
Fractional CFloat | |
Defined in Foreign.C.Types | |
Fractional Seconds | |
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 (Op a b) | |
Defined in Data.Functor.Contravariant | |
Fractional a => Fractional (Const a b) | |
Defined in Data.Functor.Const |
class (Real a, Enum a) => Integral a where #
Methods
Instances
Integral CBool | |
Integral CChar | |
Integral CInt | |
Integral CIntMax | |
Defined in Foreign.C.Types | |
Integral CIntPtr | |
Defined in Foreign.C.Types | |
Integral CLLong | |
Defined in Foreign.C.Types | |
Integral CLong | |
Integral CPtrdiff | |
Defined in Foreign.C.Types | |
Integral CSChar | |
Defined in Foreign.C.Types | |
Integral CShort | |
Defined in Foreign.C.Types | |
Integral CSigAtomic | |
Defined in Foreign.C.Types Methods quot :: CSigAtomic -> CSigAtomic -> CSigAtomic # rem :: CSigAtomic -> CSigAtomic -> CSigAtomic # div :: CSigAtomic -> CSigAtomic -> CSigAtomic # mod :: CSigAtomic -> CSigAtomic -> CSigAtomic # quotRem :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) # divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) # | |
Integral CSize | |
Integral CUChar | |
Defined in Foreign.C.Types | |
Integral CUInt | |
Integral CUIntMax | |
Defined in Foreign.C.Types | |
Integral CUIntPtr | |
Defined in Foreign.C.Types | |
Integral CULLong | |
Defined in Foreign.C.Types | |
Integral CULong | |
Defined in Foreign.C.Types | |
Integral CUShort | |
Defined in Foreign.C.Types | |
Integral CWchar | |
Defined in Foreign.C.Types | |
Integral IntPtr | |
Defined in Foreign.Ptr | |
Integral WordPtr | |
Defined in Foreign.Ptr | |
Integral Int16 | |
Integral Int32 | |
Integral Int64 | |
Integral Int8 | |
Integral Word16 | |
Integral Word32 | |
Integral Word64 | |
Integral Word8 | |
Integral CBlkCnt | |
Defined in System.Posix.Types | |
Integral CBlkSize | |
Defined in System.Posix.Types | |
Integral CClockId | |
Defined in System.Posix.Types | |
Integral CDev | |
Integral CFsBlkCnt | |
Defined in System.Posix.Types Methods quot :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # rem :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # div :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # mod :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # quotRem :: CFsBlkCnt -> CFsBlkCnt -> (CFsBlkCnt, CFsBlkCnt) # divMod :: CFsBlkCnt -> CFsBlkCnt -> (CFsBlkCnt, CFsBlkCnt) # | |
Integral CFsFilCnt | |
Defined in System.Posix.Types Methods quot :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # rem :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # div :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # mod :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # quotRem :: CFsFilCnt -> CFsFilCnt -> (CFsFilCnt, CFsFilCnt) # divMod :: CFsFilCnt -> CFsFilCnt -> (CFsFilCnt, CFsFilCnt) # | |
Integral CGid | |
Integral CId | |
Integral CIno | |
Integral CKey | |
Integral CMode | |
Integral CNfds | |
Integral CNlink | |
Defined in System.Posix.Types | |
Integral COff | |
Integral CPid | |
Integral CRLim | |
Integral CSocklen | |
Defined in System.Posix.Types | |
Integral CSsize | |
Defined in System.Posix.Types | |
Integral CTcflag | |
Defined in System.Posix.Types | |
Integral CUid | |
Integral Fd | |
Integral Integer | |
Defined in GHC.Real | |
Integral Natural | |
Defined in GHC.Real | |
Integral Int | |
Integral Word | |
Integral a => Integral (Blind a) | |
Defined in Test.QuickCheck.Modifiers | |
Integral a => Integral (Fixed a) | |
Defined in Test.QuickCheck.Modifiers | |
Integral a => Integral (Large a) | |
Defined in Test.QuickCheck.Modifiers | |
Integral a => Integral (Shrink2 a) | |
Defined in Test.QuickCheck.Modifiers Methods quot :: Shrink2 a -> Shrink2 a -> Shrink2 a # rem :: Shrink2 a -> Shrink2 a -> Shrink2 a # div :: Shrink2 a -> Shrink2 a -> Shrink2 a # mod :: Shrink2 a -> Shrink2 a -> Shrink2 a # quotRem :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a) # divMod :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a) # | |
Integral a => Integral (Small a) | |
Defined in Test.QuickCheck.Modifiers | |
Integral a => Integral (Identity a) | |
Defined in Data.Functor.Identity Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # | |
Integral a => Integral (Const a b) | |
Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # | |
Integral (f (g a)) => Integral (Compose f g a) | |
Defined in Data.Functor.Compose Methods quot :: Compose f g a -> Compose f g a -> Compose f g a # rem :: Compose f g a -> Compose f g a -> Compose f g a # div :: Compose f g a -> Compose f g a -> Compose f g a # mod :: Compose f g a -> Compose f g a -> Compose f g a # quotRem :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a) # divMod :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a) # |
class (Num a, Ord a) => Real a where #
Methods
toRational :: a -> Rational #
Instances
Real CBool | |
Defined in Foreign.C.Types Methods toRational :: CBool -> Rational # | |
Real CChar | |
Defined in Foreign.C.Types Methods toRational :: CChar -> Rational # | |
Real CClock | |
Defined in Foreign.C.Types Methods toRational :: CClock -> Rational # | |
Real CDouble | |
Defined in Foreign.C.Types Methods toRational :: CDouble -> Rational # | |
Real CFloat | |
Defined in Foreign.C.Types Methods toRational :: CFloat -> Rational # | |
Real CInt | |
Defined in Foreign.C.Types Methods toRational :: CInt -> Rational # | |
Real CIntMax | |
Defined in Foreign.C.Types Methods toRational :: CIntMax -> Rational # | |
Real CIntPtr | |
Defined in Foreign.C.Types Methods toRational :: CIntPtr -> Rational # | |
Real CLLong | |
Defined in Foreign.C.Types Methods toRational :: CLLong -> Rational # | |
Real CLong | |
Defined in Foreign.C.Types Methods toRational :: CLong -> Rational # | |
Real CPtrdiff | |
Defined in Foreign.C.Types Methods toRational :: CPtrdiff -> Rational # | |
Real CSChar | |
Defined in Foreign.C.Types Methods toRational :: CSChar -> Rational # | |
Real CSUSeconds | |
Defined in Foreign.C.Types Methods toRational :: CSUSeconds -> Rational # | |
Real CShort | |
Defined in Foreign.C.Types Methods toRational :: CShort -> Rational # | |
Real CSigAtomic | |
Defined in Foreign.C.Types Methods toRational :: CSigAtomic -> Rational # | |
Real CSize | |
Defined in Foreign.C.Types Methods toRational :: CSize -> Rational # | |
Real CTime | |
Defined in Foreign.C.Types Methods toRational :: CTime -> Rational # | |
Real CUChar | |
Defined in Foreign.C.Types Methods toRational :: CUChar -> Rational # | |
Real CUInt | |
Defined in Foreign.C.Types Methods toRational :: CUInt -> Rational # | |
Real CUIntMax | |
Defined in Foreign.C.Types Methods toRational :: CUIntMax -> Rational # | |
Real CUIntPtr | |
Defined in Foreign.C.Types Methods toRational :: CUIntPtr -> Rational # | |
Real CULLong | |
Defined in Foreign.C.Types Methods toRational :: CULLong -> Rational # | |
Real CULong | |
Defined in Foreign.C.Types Methods toRational :: CULong -> Rational # | |
Real CUSeconds | |
Defined in Foreign.C.Types Methods toRational :: CUSeconds -> Rational # | |
Real CUShort | |
Defined in Foreign.C.Types Methods toRational :: CUShort -> Rational # | |
Real CWchar | |
Defined in Foreign.C.Types Methods toRational :: CWchar -> Rational # | |
Real IntPtr | |
Defined in Foreign.Ptr Methods toRational :: IntPtr -> Rational # | |
Real WordPtr | |
Defined in Foreign.Ptr Methods toRational :: WordPtr -> Rational # | |
Real Int16 | |
Defined in GHC.Int Methods toRational :: Int16 -> Rational # | |
Real Int32 | |
Defined in GHC.Int Methods toRational :: Int32 -> Rational # | |
Real Int64 | |
Defined in GHC.Int Methods toRational :: Int64 -> Rational # | |
Real Int8 | |
Defined in GHC.Int Methods toRational :: Int8 -> Rational # | |
Real Word16 | |
Defined in GHC.Word Methods toRational :: Word16 -> Rational # | |
Real Word32 | |
Defined in GHC.Word Methods toRational :: Word32 -> Rational # | |
Real Word64 | |
Defined in GHC.Word Methods toRational :: Word64 -> Rational # | |
Real Word8 | |
Defined in GHC.Word Methods toRational :: Word8 -> Rational # | |
Real CBlkCnt | |
Defined in System.Posix.Types Methods toRational :: CBlkCnt -> Rational # | |
Real CBlkSize | |
Defined in System.Posix.Types Methods toRational :: CBlkSize -> Rational # | |
Real CCc | |
Defined in System.Posix.Types Methods toRational :: CCc -> Rational # | |
Real CClockId | |
Defined in System.Posix.Types Methods toRational :: CClockId -> Rational # | |
Real CDev | |
Defined in System.Posix.Types Methods toRational :: CDev -> Rational # | |
Real CFsBlkCnt | |
Defined in System.Posix.Types Methods toRational :: CFsBlkCnt -> Rational # | |
Real CFsFilCnt | |
Defined in System.Posix.Types Methods toRational :: CFsFilCnt -> Rational # | |
Real CGid | |
Defined in System.Posix.Types Methods toRational :: CGid -> Rational # | |
Real CId | |
Defined in System.Posix.Types Methods toRational :: CId -> Rational # | |
Real CIno | |
Defined in System.Posix.Types Methods toRational :: CIno -> Rational # | |
Real CKey | |
Defined in System.Posix.Types Methods toRational :: CKey -> Rational # | |
Real CMode | |
Defined in System.Posix.Types Methods toRational :: CMode -> Rational # | |
Real CNfds | |
Defined in System.Posix.Types Methods toRational :: CNfds -> Rational # | |
Real CNlink | |
Defined in System.Posix.Types Methods toRational :: CNlink -> Rational # | |
Real COff | |
Defined in System.Posix.Types Methods toRational :: COff -> Rational # | |
Real CPid | |
Defined in System.Posix.Types Methods toRational :: CPid -> Rational # | |
Real CRLim | |
Defined in System.Posix.Types Methods toRational :: CRLim -> Rational # | |
Real CSocklen | |
Defined in System.Posix.Types Methods toRational :: CSocklen -> Rational # | |
Real CSpeed | |
Defined in System.Posix.Types Methods toRational :: CSpeed -> Rational # | |
Real CSsize | |
Defined in System.Posix.Types Methods toRational :: CSsize -> Rational # | |
Real CTcflag | |
Defined in System.Posix.Types Methods toRational :: CTcflag -> Rational # | |
Real CUid | |
Defined in System.Posix.Types Methods toRational :: CUid -> Rational # | |
Real Fd | |
Defined in System.Posix.Types Methods toRational :: Fd -> Rational # | |
Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
Real Natural | |
Defined in GHC.Real Methods toRational :: Natural -> Rational # | |
Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
Real a => Real (Blind a) | |
Defined in Test.QuickCheck.Modifiers Methods toRational :: Blind a -> Rational # | |
Real a => Real (Fixed a) | |
Defined in Test.QuickCheck.Modifiers Methods toRational :: Fixed a -> Rational # | |
Real a => Real (Large a) | |
Defined in Test.QuickCheck.Modifiers Methods toRational :: Large a -> Rational # | |
Real a => Real (Shrink2 a) | |
Defined in Test.QuickCheck.Modifiers Methods toRational :: Shrink2 a -> Rational # | |
Real a => Real (Small a) | |
Defined in Test.QuickCheck.Modifiers Methods toRational :: Small a -> Rational # | |
Real a => Real (Identity a) | |
Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational # | |
Real a => Real (Down a) | |
Defined in Data.Ord Methods toRational :: Down a -> Rational # | |
Integral a => Real (Ratio a) | |
Defined in GHC.Real Methods toRational :: Ratio a -> Rational # | |
HasResolution a => Real (Fixed a) | |
Defined in Data.Fixed Methods toRational :: Fixed a -> Rational # | |
Real a => Real (Const a b) | |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational # | |
Real (f (g a)) => Real (Compose f g a) | |
Defined in Data.Functor.Compose Methods toRational :: Compose f g a -> Rational # |
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 #
(^^) :: (Fractional a, Integral b) => a -> b -> a #
realToFrac :: (Real a, Fractional b) => a -> b #
appendFile :: FilePath -> String -> IO () #
getContents :: IO String #