| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Darcs.Prelude
Documentation
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
| Enum Bool | |
| Enum Char | |
| Enum Int | |
| Enum Int8 | |
| Enum Int16 | |
| Enum Int32 | |
| Enum Int64 | |
| Enum Integer | |
| Enum Natural | |
Defined in GHC.Enum Methods pred :: Natural -> Natural enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
| Enum Ordering | |
| Enum Word | |
| Enum Word8 | |
| Enum Word16 | |
Defined in GHC.Word | |
| Enum Word32 | |
Defined in GHC.Word | |
| Enum Word64 | |
Defined in GHC.Word | |
| 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 pred :: VecElem -> VecElem enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
| Enum () | |
| 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 CInt | |
Defined in Foreign.C.Types | |
| Enum CMode | |
Defined in System.Posix.Types | |
| 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 CSize | |
Defined in Foreign.C.Types | |
| Enum CChar | |
Defined in Foreign.C.Types | |
| Enum CULong | |
Defined in Foreign.C.Types | |
| Enum CDev | |
Defined in System.Posix.Types | |
| Enum CIno | |
Defined in System.Posix.Types | |
| Enum WordPtr | |
Defined in Foreign.Ptr Methods pred :: WordPtr -> WordPtr enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] # | |
| Enum Message | |
Defined in Text.Parsec.Error Methods pred :: Message -> Message enumFrom :: Message -> [Message] # enumFromThen :: Message -> Message -> [Message] # enumFromTo :: Message -> Message -> [Message] # enumFromThenTo :: Message -> Message -> Message -> [Message] # | |
| Enum Day | |
Defined in Data.Time.Calendar.Days | |
| Enum DayOfWeek | |
Defined in Data.Time.Calendar.Week Methods succ :: DayOfWeek -> DayOfWeek # pred :: DayOfWeek -> DayOfWeek fromEnum :: DayOfWeek -> Int # enumFrom :: DayOfWeek -> [DayOfWeek] # enumFromThen :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromTo :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromThenTo :: DayOfWeek -> DayOfWeek -> DayOfWeek -> [DayOfWeek] # | |
| Enum DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods succ :: DiffTime -> DiffTime # pred :: DiffTime -> DiffTime enumFrom :: DiffTime -> [DiffTime] # enumFromThen :: DiffTime -> DiffTime -> [DiffTime] # enumFromTo :: DiffTime -> DiffTime -> [DiffTime] # enumFromThenTo :: DiffTime -> DiffTime -> DiffTime -> [DiffTime] # | |
| Enum Day | |
Defined in System.Time | |
| Enum Month | |
Defined in System.Time | |
| Enum CTime | |
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 CBool | |
Defined in Foreign.C.Types | |
| Enum CClock | |
Defined in Foreign.C.Types | |
| Enum CDouble | |
Defined in Foreign.C.Types Methods pred :: CDouble -> CDouble enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] # | |
| Enum CFloat | |
Defined in Foreign.C.Types | |
| Enum CIntMax | |
Defined in Foreign.C.Types Methods pred :: CIntMax -> CIntMax enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] # | |
| Enum CIntPtr | |
Defined in Foreign.C.Types Methods pred :: CIntPtr -> CIntPtr 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 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 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 pred :: CULLong -> CULLong enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] # | |
| 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 pred :: CUShort -> CUShort enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] # | |
| Enum CWchar | |
Defined in Foreign.C.Types | |
| Enum CompressionStrategy | |
Defined in Codec.Compression.Zlib.Stream Methods succ :: CompressionStrategy -> CompressionStrategy # pred :: CompressionStrategy -> CompressionStrategy toEnum :: Int -> CompressionStrategy # fromEnum :: CompressionStrategy -> Int # enumFrom :: CompressionStrategy -> [CompressionStrategy] # enumFromThen :: CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # enumFromTo :: CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # enumFromThenTo :: CompressionStrategy -> CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # | |
| Enum Method | |
Defined in Codec.Compression.Zlib.Stream | |
| Enum Format | |
Defined in Codec.Compression.Zlib.Stream | |
| Enum Mode | |
Defined in System.IO.MMap | |
| Enum Fd | |
Defined in System.Posix.Types | |
| Enum CBlkCnt | |
Defined in System.Posix.Types Methods pred :: CBlkCnt -> CBlkCnt 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 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 CKey | |
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 pred :: CTcflag -> CTcflag enumFrom :: CTcflag -> [CTcflag] # enumFromThen :: CTcflag -> CTcflag -> [CTcflag] # enumFromTo :: CTcflag -> CTcflag -> [CTcflag] # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag] # | |
| Enum CUid | |
Defined in System.Posix.Types | |
| 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 Extension | |
Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] # | |
| Enum IntPtr | |
Defined in Foreign.Ptr | |
| Enum XdgDirectory | |
Defined in System.Directory.Internal.Common Methods succ :: XdgDirectory -> XdgDirectory # pred :: XdgDirectory -> XdgDirectory toEnum :: Int -> XdgDirectory # fromEnum :: XdgDirectory -> Int # enumFrom :: XdgDirectory -> [XdgDirectory] # enumFromThen :: XdgDirectory -> XdgDirectory -> [XdgDirectory] # enumFromTo :: XdgDirectory -> XdgDirectory -> [XdgDirectory] # enumFromThenTo :: XdgDirectory -> XdgDirectory -> XdgDirectory -> [XdgDirectory] # | |
| Enum XdgDirectoryList | |
Defined in System.Directory.Internal.Common Methods succ :: XdgDirectoryList -> XdgDirectoryList # pred :: XdgDirectoryList -> XdgDirectoryList toEnum :: Int -> XdgDirectoryList # fromEnum :: XdgDirectoryList -> Int # enumFrom :: XdgDirectoryList -> [XdgDirectoryList] # enumFromThen :: XdgDirectoryList -> XdgDirectoryList -> [XdgDirectoryList] # enumFromTo :: XdgDirectoryList -> XdgDirectoryList -> [XdgDirectoryList] # enumFromThenTo :: XdgDirectoryList -> XdgDirectoryList -> XdgDirectoryList -> [XdgDirectoryList] # | |
| Enum Encoding | |
Defined in Basement.String Methods succ :: Encoding -> Encoding # pred :: Encoding -> Encoding enumFrom :: Encoding -> [Encoding] # enumFromThen :: Encoding -> Encoding -> [Encoding] # enumFromTo :: Encoding -> Encoding -> [Encoding] # enumFromThenTo :: Encoding -> Encoding -> Encoding -> [Encoding] # | |
| Enum UTF32_Invalid | |
Defined in Basement.String.Encoding.UTF32 Methods succ :: UTF32_Invalid -> UTF32_Invalid # pred :: UTF32_Invalid -> UTF32_Invalid toEnum :: Int -> UTF32_Invalid # fromEnum :: UTF32_Invalid -> Int # enumFrom :: UTF32_Invalid -> [UTF32_Invalid] # enumFromThen :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromTo :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromThenTo :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # | |
| Enum CryptoError | |
Defined in Crypto.Error.Types Methods succ :: CryptoError -> CryptoError # pred :: CryptoError -> CryptoError toEnum :: Int -> CryptoError # fromEnum :: CryptoError -> Int # enumFrom :: CryptoError -> [CryptoError] # enumFromThen :: CryptoError -> CryptoError -> [CryptoError] # enumFromTo :: CryptoError -> CryptoError -> [CryptoError] # enumFromThenTo :: CryptoError -> CryptoError -> CryptoError -> [CryptoError] # | |
| Enum DoPa | |
Defined in Text.Regex.TDFA.Common | |
| Enum WhichTest | |
Defined in Text.Regex.TDFA.Common Methods succ :: WhichTest -> WhichTest # pred :: WhichTest -> WhichTest fromEnum :: WhichTest -> Int # enumFrom :: WhichTest -> [WhichTest] # enumFromThen :: WhichTest -> WhichTest -> [WhichTest] # enumFromTo :: WhichTest -> WhichTest -> [WhichTest] # enumFromThenTo :: WhichTest -> WhichTest -> WhichTest -> [WhichTest] # | |
| Enum FileType | |
Defined in System.Directory.Internal.Common Methods succ :: FileType -> FileType # pred :: FileType -> FileType enumFrom :: FileType -> [FileType] # enumFromThen :: FileType -> FileType -> [FileType] # enumFromTo :: FileType -> FileType -> [FileType] # enumFromThenTo :: FileType -> FileType -> FileType -> [FileType] # | |
| Enum PortNumber | |
Defined in Network.Socket.Types Methods succ :: PortNumber -> PortNumber # pred :: PortNumber -> PortNumber fromEnum :: PortNumber -> Int # enumFrom :: PortNumber -> [PortNumber] # enumFromThen :: PortNumber -> PortNumber -> [PortNumber] # enumFromTo :: PortNumber -> PortNumber -> [PortNumber] # enumFromThenTo :: PortNumber -> PortNumber -> PortNumber -> [PortNumber] # | |
| Enum Greediness | |
Defined in Text.Regex.Applicative.Types Methods succ :: Greediness -> Greediness # pred :: Greediness -> Greediness fromEnum :: Greediness -> Int # enumFrom :: Greediness -> [Greediness] # enumFromThen :: Greediness -> Greediness -> [Greediness] # enumFromTo :: Greediness -> Greediness -> [Greediness] # enumFromThenTo :: Greediness -> Greediness -> Greediness -> [Greediness] # | |
| a :=> (Enum (Dict a)) | |
Defined in Data.Constraint | |
| () :=> (Enum Bool) | |
Defined in Data.Constraint | |
| () :=> (Enum Char) | |
Defined in Data.Constraint | |
| () :=> (Enum Double) | |
Defined in Data.Constraint | |
| () :=> (Enum Float) | |
Defined in Data.Constraint | |
| () :=> (Enum Int) | |
Defined in Data.Constraint | |
| () :=> (Enum Integer) | |
Defined in Data.Constraint | |
| () :=> (Enum Natural) | |
Defined in Data.Constraint | |
| () :=> (Enum Ordering) | |
Defined in Data.Constraint | |
| () :=> (Enum Word) | |
Defined in Data.Constraint | |
| () :=> (Enum ()) | |
Defined in Data.Constraint | |
| Class () (Enum a) | |
Defined in Data.Constraint | |
| Integral a => Enum (Ratio a) | |
Defined in GHC.Real Methods pred :: Ratio a -> Ratio a 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 (First a) | |
Defined in Data.Semigroup Methods pred :: First a -> First a 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] # | |
| Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
| Enum a => Enum (Down a) | |
Defined in Data.Ord | |
| Enum (Offset ty) | |
Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty fromEnum :: Offset ty -> Int # enumFrom :: Offset ty -> [Offset ty] # enumFromThen :: Offset ty -> Offset ty -> [Offset ty] # enumFromTo :: Offset ty -> Offset ty -> [Offset ty] # enumFromThenTo :: Offset ty -> Offset ty -> Offset ty -> [Offset ty] # | |
| Enum (CountOf ty) | |
Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty fromEnum :: CountOf ty -> Int # enumFrom :: CountOf ty -> [CountOf ty] # enumFromThen :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromTo :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromThenTo :: CountOf ty -> CountOf ty -> CountOf ty -> [CountOf ty] # | |
| SizeValid n => Enum (Bits n) | |
Defined in Basement.Bits | |
| a => Enum (Dict a) | |
Defined in Data.Constraint | |
| (Enum a) :=> (Enum (Identity a)) | |
Defined in Data.Constraint | |
| (Enum a) :=> (Enum (Const a b)) | |
Defined in Data.Constraint | |
| (Integral a) :=> (Enum (Ratio a)) | |
Defined in Data.Constraint | |
| Enum (Proxy s) | |
Defined in Data.Proxy Methods pred :: Proxy s -> Proxy s 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 (Fixed a) | |
Defined in Data.Fixed Methods pred :: Fixed a -> Fixed a 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] # | |
| Class (Real a, Enum a) (Integral a) | |
Defined in Data.Constraint | |
| Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
| Enum (f a) => Enum (Ap f a) | |
Defined in Data.Monoid | |
| Enum (f a) => Enum (Alt f a) | |
Defined in Data.Semigroup.Internal Methods pred :: Alt f a -> Alt f a enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] # | |
| Enum a => Enum (Tagged s a) | |
Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a # pred :: Tagged s a -> Tagged s a fromEnum :: Tagged s a -> Int # enumFrom :: Tagged s a -> [Tagged s a] # enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a] # | |
Instances
| Eq Bool | |
| Eq Char | |
| Eq Double | |
| Eq Float | |
| Eq Int | |
| Eq Int8 | |
| Eq Int16 | |
| Eq Int32 | |
| Eq Int64 | |
| Eq Integer | |
| Eq Natural | |
| Eq Ordering | |
| Eq Word | |
| Eq Word8 | |
| Eq Word16 | |
| Eq Word32 | |
| Eq Word64 | |
| Eq SomeTypeRep | |
| Eq Exp | |
| Eq Match | |
| Eq Clause | |
| Eq Pat | |
| Eq Type | |
| Eq Dec | |
| Eq Name | |
| Eq FunDep | |
| Eq InjectivityAnn | |
| Eq Overlap | |
| Eq () | |
| Eq TyCon | |
| Eq Module | |
| Eq TrName | |
| Eq Lexeme | |
| Eq All | |
| Eq Any | |
| Eq SeekMode | |
| Eq HandlePosn | |
| Eq BufferMode | |
| Eq Handle | |
| Eq Newline | |
| Eq NewlineMode | |
| Eq IOMode | |
| Eq CInt | |
| Eq Errno | |
| Eq CMode | |
| Eq IOException | |
| Eq SrcLoc | |
| Eq GeneralCategory | |
| Eq BigNat | |
| Eq ArrayException | |
| Eq AsyncException | |
| Eq ExitCode | |
| Eq IOErrorType | |
| Eq MaskingState | |
| Eq ByteString | |
| Eq CSize | |
| Eq CChar | |
| Eq CULong | |
| Eq FileNameFormat Source # | |
Defined in Darcs.Patch.Format Methods (==) :: FileNameFormat -> FileNameFormat -> Bool # (/=) :: FileNameFormat -> FileNameFormat -> Bool # | |
| Eq ErrorCall | |
| Eq ArithException | |
| Eq IODeviceType | |
| Eq CDev | |
| Eq CIno | |
| Eq ParseError | |
| Eq SourcePos | |
| Eq UnicodeException | |
| Eq Lit | |
| Eq NameFlavour | |
| Eq ByteString | |
| Eq WordPtr | |
| Eq Message | |
| Eq Day | |
| Eq DayOfWeek | |
| Eq DiffTime | |
| Eq UTCTime | |
| Eq UniversalTime | |
| Eq TimeLocale | |
| Eq LocalTime | |
| Eq TimeOfDay | |
| Eq TimeZone | |
| Eq CalendarTime | |
| Eq ClockTime | |
| Eq Day | |
| Eq Month | |
| Eq TimeDiff | |
| Eq CTime | |
| Eq CSUSeconds | |
| Eq CBool | |
| Eq CClock | |
| Eq CDouble | |
| Eq CFloat | |
| Eq CIntMax | |
| Eq CIntPtr | |
| Eq CLLong | |
| Eq CLong | |
| Eq CPtrdiff | |
| Eq CSChar | |
| Eq CShort | |
| Eq CSigAtomic | |
| Eq CUChar | |
| Eq CUInt | |
| Eq CUIntMax | |
| Eq CUIntPtr | |
| Eq CULLong | |
| Eq CUSeconds | |
| Eq CUShort | |
| Eq CWchar | |
| Eq ConnectionError Source # | |
Defined in Darcs.Util.Download.Request Methods (==) :: ConnectionError -> ConnectionError -> Bool # (/=) :: ConnectionError -> ConnectionError -> Bool # | |
| Eq Cachable Source # | |
| Eq Priority Source # | |
| Eq CodingProgress | |
| Eq CompressionLevel | |
| Eq CompressionStrategy | |
| Eq MemoryLevel | |
| Eq Method | |
| Eq WindowBits | |
| Eq DecompressError | |
| Eq Format | |
| Eq Mode | |
| Eq DictionaryHash | |
| Eq Fd | |
| Eq CBlkCnt | |
| Eq CBlkSize | |
| Eq CCc | |
| Eq CClockId | |
| Eq CFsBlkCnt | |
| Eq CFsFilCnt | |
| Eq CGid | |
| Eq CId | |
| Eq CKey | |
| Eq CNfds | |
| Eq CNlink | |
| Eq COff | |
| Eq CPid | |
| Eq CRLim | |
| Eq CSocklen | |
| Eq CSpeed | |
| Eq CSsize | |
| Eq CTcflag | |
| Eq CTimer | |
| Eq CUid | |
| Eq SpecConstrAnnotation | |
| Eq Version | |
| Eq ShortByteString | |
| Eq IntSet | |
| Eq Associativity | |
| Eq DecidedStrictness | |
| Eq Fixity | |
| Eq SourceStrictness | |
| Eq SourceUnpackedness | |
| Eq ForeignSrcLang | |
| Eq Extension | |
| Eq Fingerprint | |
| Eq IntPtr | |
| Eq ThreadId | |
| Eq Void | |
| Eq AnnLookup | |
| Eq AnnTarget | |
| Eq Bang | |
| Eq Body | |
| Eq Bytes | |
| Eq Callconv | |
| Eq Con | |
| Eq DecidedStrictness | |
| Eq DerivClause | |
| Eq DerivStrategy | |
| Eq FamilyResultSig | |
| Eq Fixity | |
| Eq FixityDirection | |
| Eq Foreign | |
| Eq Guard | |
| Eq Info | |
| Eq Inline | |
| Eq Loc | |
| Eq ModName | |
| Eq Module | |
| Eq ModuleInfo | |
| Eq NameSpace | |
| Eq OccName | |
| Eq PatSynArgs | |
| Eq PatSynDir | |
| Eq Phases | |
| Eq PkgName | |
| Eq Pragma | |
| Eq Range | |
| Eq Role | |
| Eq RuleBndr | |
| Eq RuleMatch | |
| Eq Safety | |
| Eq SourceStrictness | |
| Eq SourceUnpackedness | |
| Eq Stmt | |
| Eq TyLit | |
| Eq TySynEqn | |
| Eq TyVarBndr | |
| Eq TypeFamilyHead | |
| Eq DiffAlgorithm Source # | |
Defined in Darcs.Util.Diff Methods (==) :: DiffAlgorithm -> DiffAlgorithm -> Bool # (/=) :: DiffAlgorithm -> DiffAlgorithm -> Bool # | |
| Eq PatchFormat Source # | |
Defined in Darcs.Repository.Flags | |
| Eq ForgetParent Source # | |
Defined in Darcs.Repository.Flags | |
| Eq WithWorkingDir Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: WithWorkingDir -> WithWorkingDir -> Bool # (/=) :: WithWorkingDir -> WithWorkingDir -> Bool # | |
| Eq WantGuiPause Source # | |
Defined in Darcs.Repository.Flags | |
| Eq WorkRepo Source # | |
| Eq ExternalMerge Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: ExternalMerge -> ExternalMerge -> Bool # (/=) :: ExternalMerge -> ExternalMerge -> Bool # | |
| Eq AllowConflicts Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: AllowConflicts -> AllowConflicts -> Bool # (/=) :: AllowConflicts -> AllowConflicts -> Bool # | |
| Eq CloneKind Source # | |
| Eq ScanKnown Source # | |
| Eq UseIndex Source # | |
| Eq InheritDefault Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: InheritDefault -> InheritDefault -> Bool # (/=) :: InheritDefault -> InheritDefault -> Bool # | |
| Eq SetDefault Source # | |
Defined in Darcs.Repository.Flags | |
| Eq RemoteRepos Source # | |
Defined in Darcs.Repository.Flags | |
| Eq LeaveTestDir Source # | |
Defined in Darcs.Repository.Flags | |
| Eq SetScriptsExecutable Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: SetScriptsExecutable -> SetScriptsExecutable -> Bool # (/=) :: SetScriptsExecutable -> SetScriptsExecutable -> Bool # | |
| Eq RunTest Source # | |
| Eq IncludeBoring Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: IncludeBoring -> IncludeBoring -> Bool # (/=) :: IncludeBoring -> IncludeBoring -> Bool # | |
| Eq LookForMoves Source # | |
Defined in Darcs.Repository.Flags | |
| Eq LookForReplaces Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: LookForReplaces -> LookForReplaces -> Bool # (/=) :: LookForReplaces -> LookForReplaces -> Bool # | |
| Eq LookForAdds Source # | |
Defined in Darcs.Repository.Flags | |
| Eq UMask Source # | |
| Eq DryRun Source # | |
| Eq UseCache Source # | |
| Eq UpdatePending Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: UpdatePending -> UpdatePending -> Bool # (/=) :: UpdatePending -> UpdatePending -> Bool # | |
| Eq Reorder Source # | |
| Eq RemoteDarcs Source # | |
Defined in Darcs.Repository.Flags | |
| Eq WithPatchIndex Source # | |
Defined in Darcs.Repository.Flags Methods (==) :: WithPatchIndex -> WithPatchIndex -> Bool # (/=) :: WithPatchIndex -> WithPatchIndex -> Bool # | |
| Eq Compression Source # | |
Defined in Darcs.Repository.Flags | |
| Eq Verbosity Source # | |
| Eq ByteArray | |
| Eq AsyncCancelled | |
| Eq Proxy | |
| Eq Value | |
| Eq JSONPathElement | |
| Eq Pos | |
| Eq More | |
| Eq StreamFileStatus | |
| Eq ResponseTimeout | |
| Eq Cookie | |
| Eq CookieJar | |
| Eq ByteRange | |
| Eq Permissions | |
| Eq XdgDirectory | |
| Eq XdgDirectoryList | |
| Eq AbsoluteTime | |
| Eq Number | |
| Eq URIAuth | |
| Eq ResponseClose | |
| Eq URI | |
| Eq AddrInfo | |
| Eq AddrInfoFlag | |
| Eq NameInfoFlag | |
| Eq SockAddr | |
| Eq Family | |
| Eq SocketType | |
| Eq Socket | |
| Eq Encoding | |
| Eq String | |
| Eq ASCII7_Invalid | |
| Eq ISO_8859_1_Invalid | |
| Eq UTF16_Invalid | |
| Eq UTF32_Invalid | |
| Eq FileSize | |
| Eq CryptoError | |
| Eq SharedSecret | |
| Eq DotNetTime | |
| Eq SumEncoding | |
| Eq StdGen | |
| Eq UUID | |
| Eq UnpackedUUID | |
| Eq ConnHost | |
| Eq ConnKey | |
| Eq StatusHeaders | |
| Eq SHA1 Source # | |
| Eq Hash Source # | |
| Eq Number | |
| Eq SomeNat | |
| Eq BlockReason | |
| Eq ThreadStatus | |
| Eq CmdSpec | |
| Eq CreateProcess | |
| Eq StdStream | |
| Eq DoPa | |
| Eq Action | |
| Eq OP | |
| Eq QT | |
| Eq TagTask | |
| Eq TagUpdate | |
| Eq WhichTest | |
| Eq SshSettings Source # | |
Defined in Darcs.Util.Ssh | |
| Eq AnchoredPath Source # | |
Defined in Darcs.Util.Path | |
| Eq Name Source # | |
| Eq AbsoluteOrRemotePath Source # | |
Defined in Darcs.Util.Path Methods (==) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool # (/=) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool # | |
| Eq AbsolutePathOrStd Source # | |
Defined in Darcs.Util.Path Methods (==) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool # (/=) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool # | |
| Eq AbsolutePath Source # | |
Defined in Darcs.Util.Path | |
| Eq SubPath Source # | |
| Eq ItemType Source # | |
| Eq RepoProperty Source # | |
Defined in Darcs.Repository.Format | |
| Eq CacheLoc Source # | |
| Eq CacheType Source # | |
| Eq WritableOrNot Source # | |
Defined in Darcs.Repository.Cache Methods (==) :: WritableOrNot -> WritableOrNot -> Bool # (/=) :: WritableOrNot -> WritableOrNot -> Bool # | |
| Eq FileType | |
| Eq DarcsFlag Source # | |
| Eq FileType Source # | |
| Eq SummOp Source # | |
| Eq SummDetail Source # | |
Defined in Darcs.Patch.SummaryData | |
| Eq Location Source # | |
| Eq UUID Source # | |
| Eq Label Source # | |
| Eq PatchId Source # | |
| Eq FileId Source # | |
| Eq PatchInfo Source # | |
| Eq Inventory Source # | |
| Eq PristineHash Source # | |
Defined in Darcs.Repository.Inventory | |
| Eq PatchHash Source # | |
| Eq InventoryHash Source # | |
Defined in Darcs.Repository.Inventory Methods (==) :: InventoryHash -> InventoryHash -> Bool # (/=) :: InventoryHash -> InventoryHash -> Bool # | |
| Eq ConflictState Source # | |
Defined in Darcs.Patch.Summary Methods (==) :: ConflictState -> ConflictState -> Bool # (/=) :: ConflictState -> ConflictState -> Bool # | |
| Eq ShowDepsFormat Source # | |
Defined in Darcs.Patch.Named Methods (==) :: ShowDepsFormat -> ShowDepsFormat -> Bool # (/=) :: ShowDepsFormat -> ShowDepsFormat -> Bool # | |
| Eq PristineType Source # | |
Defined in Darcs.Repository.InternalTypes | |
| Eq GzcrcsAction Source # | |
Defined in Darcs.UI.Options.All | |
| Eq TestStrategy Source # | |
Defined in Darcs.UI.Options.All | |
| Eq ChangesFormat Source # | |
Defined in Darcs.UI.Options.All Methods (==) :: ChangesFormat -> ChangesFormat -> Bool # (/=) :: ChangesFormat -> ChangesFormat -> Bool # | |
| Eq WithSummary Source # | |
Defined in Darcs.UI.Options.All | |
| Eq Output Source # | |
| Eq Verify Source # | |
| Eq Sign Source # | |
| Eq TestChanges Source # | |
Defined in Darcs.UI.Options.All | |
| Eq ExternalDiff Source # | |
Defined in Darcs.UI.Options.All | |
| Eq WithContext Source # | |
Defined in Darcs.UI.Options.All | |
| Eq AskLongComment Source # | |
Defined in Darcs.UI.Options.All Methods (==) :: AskLongComment -> AskLongComment -> Bool # (/=) :: AskLongComment -> AskLongComment -> Bool # | |
| Eq RepoCombinator Source # | |
Defined in Darcs.UI.Options.All Methods (==) :: RepoCombinator -> RepoCombinator -> Bool # (/=) :: RepoCombinator -> RepoCombinator -> Bool # | |
| Eq SelectDeps Source # | |
Defined in Darcs.UI.Options.All | |
| Eq XmlOutput Source # | |
| Eq StdCmdAction Source # | |
Defined in Darcs.UI.Options.All | |
| Eq RootAction Source # | |
Defined in Darcs.UI.Options.All | |
| Eq EnumPatches Source # | |
Defined in Darcs.UI.Options.All | |
| Eq PortNumber | |
| Eq UpdatePristine Source # | |
Defined in Darcs.Repository.Hashed Methods (==) :: UpdatePristine -> UpdatePristine -> Bool # (/=) :: UpdatePristine -> UpdatePristine -> Bool # | |
| Eq FormatError | |
| Eq Entry | |
| Eq EntryContent | |
| Eq Format | |
| Eq LinkTarget | |
| Eq Ownership | |
| Eq TarPath | |
| Eq PrimPatchId Source # | |
Defined in Darcs.Patch.Prim.Named | |
| Eq WhichChanges Source # | |
Defined in Darcs.UI.SelectChanges | |
| Eq CompressionMethod | |
| Eq EncryptionMethod | |
| Eq Entry | |
| Eq ZipException | |
| Eq ZipOption | |
| Eq MSDOSDateTime | |
| Eq PKWAREVerificationType | |
| Eq CodePoint | |
| Eq DecoderState | |
| Eq Greediness | |
| () :=> (Eq Bool) | |
Defined in Data.Constraint | |
| () :=> (Eq Double) | |
Defined in Data.Constraint | |
| () :=> (Eq Float) | |
Defined in Data.Constraint | |
| () :=> (Eq Int) | |
Defined in Data.Constraint | |
| () :=> (Eq Integer) | |
Defined in Data.Constraint | |
| () :=> (Eq Natural) | |
Defined in Data.Constraint | |
| () :=> (Eq Word) | |
Defined in Data.Constraint | |
| () :=> (Eq ()) | |
Defined in Data.Constraint | |
| () :=> (Eq (a :- b)) | |
Defined in Data.Constraint | |
| () :=> (Eq (Dict a)) | |
Defined in Data.Constraint | |
| Class () (Eq a) | |
Defined in Data.Constraint | |
| Eq a => Eq [a] | |
| Eq a => Eq (Maybe a) | |
| Eq a => Eq (Ratio a) | |
| Eq (StablePtr a) | |
| Eq (Ptr a) | |
| Eq (FunPtr a) | |
| Eq p => Eq (Par1 p) | |
| Eq a => Eq (ZipList a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq a => Eq (Dual a) | |
| Eq a => Eq (Product a) | |
| Eq a => Eq (Sum a) | |
| Eq a => Eq (NonEmpty a) | |
| Eq a => Eq (First a) | |
| Eq a => Eq (Last a) | |
| Eq a => Eq (Max a) | |
| Eq a => Eq (Min a) | |
| Eq a => Eq (Option a) | |
| Eq m => Eq (WrappedMonoid m) | |
| Eq a => Eq (Identity a) | |
| Eq a => Eq (Down a) | |
| Eq (ForeignPtr a) | |
| Eq (MVar a) | |
| Eq (IORef a) | |
| Eq a => Eq (Set a) | |
| Eq a => Eq (Hashed a) | |
| Eq a => Eq (IntMap a) | |
| Eq a => Eq (Seq a) | |
| Eq a => Eq (ViewL a) | |
| Eq a => Eq (ViewR a) | |
| Eq a => Eq (Tree a) | |
| Eq a => Eq (Complex a) | |
| Eq a => Eq (Vector a) | |
| Eq a => Eq (Array a) | |
| Eq (MutableByteArray s) | |
| (Prim a, Eq a) => Eq (Vector a) | |
| (Eq a, Prim a) => Eq (PrimArray a) | |
| Eq a => Eq (SmallArray a) | |
| Eq (Async a) | |
| Eq a => Eq (CryptoFailable a) | |
| Eq mono => Eq (NonNull mono) | |
| Eq a => Eq (Flush a) | |
| Eq body => Eq (Response body) | |
| Eq a => Eq (Result a) | |
| Eq s => Eq (CI s) | |
| (PrimType ty, Eq ty) => Eq (UArray ty) | |
| Eq (Offset ty) | |
| Eq (CountOf ty) | |
| (PrimType ty, Eq ty) => Eq (Block ty) | |
| Eq a => Eq (NonEmpty a) | |
| Eq (Bits n) | |
| Eq a => Eq (HashSet a) | |
| (Storable a, Eq a) => Eq (Vector a) | |
| Eq (Zn n) | |
| Eq (Zn64 n) | |
| Eq (Digest a) | |
| Eq a => Eq (IResult a) | |
| Eq1 f => Eq (Fix f) | |
| (Functor f, Eq1 f) => Eq (Mu f) | |
| (Functor f, Eq1 f) => Eq (Nu f) | |
| Eq a => Eq (DNonEmpty a) | |
| Eq a => Eq (DList a) | |
| Eq g => Eq (StateGen g) | |
| Eq g => Eq (AtomicGen g) | |
| Eq g => Eq (IOGen g) | |
| Eq g => Eq (STGen g) | |
| Eq a => Eq (Maybe a) | |
| Eq (TVar a) | |
| Eq (Dict a) | |
| Eq2 a => Eq (Sealed (a wX)) Source # | |
| Eq a => Eq (PatchMod a) Source # | |
| Eq e => Eq (Entries e) | |
| (Eq a) :=> (Eq [a]) | |
Defined in Data.Constraint | |
| (Eq a) :=> (Eq (Maybe a)) | |
Defined in Data.Constraint | |
| (Eq a) :=> (Eq (Complex a)) | |
Defined in Data.Constraint | |
| (Eq a) :=> (Eq (Ratio a)) | |
Defined in Data.Constraint | |
| (Eq a) :=> (Eq (Identity a)) | |
Defined in Data.Constraint | |
| (Eq a) :=> (Eq (Const a b)) | |
Defined in Data.Constraint | |
| Class (Eq a) (Ord a) | |
Defined in Data.Constraint | |
| Class (Eq a) (Bits a) | |
Defined in Data.Constraint | |
| (Eq a, Eq b) => Eq (Either a b) | |
| Eq (V1 p) | |
| Eq (U1 p) | |
| Eq (TypeRep a) | |
| (Eq a, Eq b) => Eq (a, b) | |
| Eq a => Eq (Arg a b) | |
| (Ix i, Eq e) => Eq (Array i e) | |
| Eq (Proxy s) | |
| Eq (EqCheck wA wB) Source # | |
| Eq (Fixed a) | |
| (Eq k, Eq a) => Eq (Map k a) | |
| (Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e) | |
| Eq (IOArray i e) | |
| Eq (MutableArray s a) | |
| (Eq1 m, Eq a) => Eq (ListT m a) | |
| (Eq1 m, Eq a) => Eq (MaybeT m a) | |
| Eq (MutablePrimArray s a) | |
| Eq (SmallMutableArray s a) | |
| (Eq k, Eq v) => Eq (HashMap k v) | |
| (Eq k, Eq v) => Eq (Leaf k v) | |
| (Eq a, Eq b) => Eq (Either a b) | |
| (Eq a, Eq b) => Eq (These a b) | |
| (Eq a, Eq b) => Eq (These a b) | |
| (Eq a, Eq b) => Eq (Pair a b) | |
| Eq (a :- b) | |
| Ident p => Eq (Contexted p wX) Source # | Equality between |
| Eq (DirPatchType wX wY) Source # | |
Defined in Darcs.Patch.Prim.V1.Core Methods (==) :: DirPatchType wX wY -> DirPatchType wX wY -> Bool # (/=) :: DirPatchType wX wY -> DirPatchType wX wY -> Bool # | |
| Eq (FilePatchType wX wY) Source # | |
Defined in Darcs.Patch.Prim.V1.Core Methods (==) :: FilePatchType wX wY -> FilePatchType wX wY -> Bool # (/=) :: FilePatchType wX wY -> FilePatchType wX wY -> Bool # | |
| Eq (Prim wX wY) Source # | |
| Eq (Prim wX wY) Source # | |
| Eq (HunkMove wX wY) Source # | |
| Eq (Hunk wX wY) Source # | |
| (Commute p, Eq2 p, Eq2 (PrimOf p)) => Eq (Non p wX) Source # | Nons are equal if their context patches are equal, and they have an equal prim patch. |
| Eq (RebaseName wX wY) Source # | |
Defined in Darcs.Patch.Rebase.Name Methods (==) :: RebaseName wX wY -> RebaseName wX wY -> Bool # (/=) :: RebaseName wX wY -> RebaseName wX wY -> Bool # | |
| (Eq a, Eq b) :=> (Eq (a, b)) | |
Defined in Data.Constraint | |
| (Eq a, Eq b) :=> (Eq (Either a b)) | |
| Eq (f p) => Eq (Rec1 f p) | |
| Eq (URec (Ptr ()) p) | |
| Eq (URec Char p) | |
| Eq (URec Double p) | |
| Eq (URec Float p) | |
| Eq (URec Int p) | |
| Eq (URec Word p) | |
| (Eq a, Eq b, Eq c) => Eq (a, b, c) | |
| Eq a => Eq (Const a b) | |
| Eq (f a) => Eq (Ap f a) | |
| Eq (f a) => Eq (Alt f a) | |
| (Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) | |
| Eq (STUArray s i e) | |
| Eq (STArray s i e) | |
| (Eq1 f, Eq a) => Eq (IdentityT f a) | |
| (Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
| (Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
| (Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
| Eq b => Eq (Tagged s b) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (These1 f g a) | |
| Eq2 prim => Eq (RepoPatchV1 prim wX wY) Source # | |
Defined in Darcs.Patch.V1.Commute Methods (==) :: RepoPatchV1 prim wX wY -> RepoPatchV1 prim wX wY -> Bool # (/=) :: RepoPatchV1 prim wX wY -> RepoPatchV1 prim wX wY -> Bool # | |
| Eq c => Eq (K1 i c p) | |
| (Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
| (Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Product f g a) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Sum f g a) | |
| (Eq2 a, Eq2 b) => Eq ((a :> b) wX wY) Source # | |
| Eq (f p) => Eq (M1 i c f p) | |
| Eq (f (g p)) => Eq ((f :.: g) p) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
| (Eq1 f, Eq1 g, Eq a) => Eq (Compose f g a) | |
| Eq (p b a) => Eq (Flip p a b) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
| (Eq (f a b), Eq (g a b)) => Eq (Product f g a b) | |
| (Eq (p a b), Eq (q a b)) => Eq (Sum p q a b) | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
| Eq (f (p a b)) => Eq (Tannen f p a b) | |
| (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 (p (f a) (g b)) => Eq (Biff p f g a b) | |
| (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 Fractional a => Floating a where #
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Methods
Instances
| Floating Double | |
| Floating Float | |
| Floating CDouble | |
| Floating CFloat | |
| () :=> (Floating Double) | |
Defined in Data.Constraint | |
| () :=> (Floating Float) | |
Defined in Data.Constraint | |
| Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity Methods pi :: Identity a 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) | |
| RealFloat a => Floating (Complex a) | |
Defined in Data.Complex Methods pi :: Complex a 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.Constraint | |
| (Floating a) :=> (Floating (Const a b)) | |
Defined in Data.Constraint | |
| (RealFloat a) :=> (Floating (Complex a)) | |
Defined in Data.Constraint | |
| Class (Fractional a) (Floating a) | |
Defined in Data.Constraint Methods cls :: Floating a :- Fractional a | |
| Class (RealFrac a, Floating a) (RealFloat a) | |
Defined in Data.Constraint | |
| Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const Methods pi :: Const a b exp :: Const a b -> Const a b # log :: Const a b -> Const a b sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b log1pexp :: Const a b -> Const a b log1mexp :: Const a b -> Const a b | |
| Floating a => Floating (Tagged s a) | |
Defined in Data.Tagged Methods pi :: Tagged s a exp :: Tagged s a -> Tagged s a # log :: Tagged s a -> Tagged s a sqrt :: Tagged s a -> Tagged s a # (**) :: Tagged s a -> Tagged s a -> Tagged s a # logBase :: Tagged s a -> Tagged s a -> Tagged s a # sin :: Tagged s a -> Tagged s a # cos :: Tagged s a -> Tagged s a # tan :: Tagged s a -> Tagged s a # asin :: Tagged s a -> Tagged s a # acos :: Tagged s a -> Tagged s a # atan :: Tagged s a -> Tagged s a # sinh :: Tagged s a -> Tagged s a # cosh :: Tagged s a -> Tagged s a # tanh :: Tagged s a -> Tagged s a # asinh :: Tagged s a -> Tagged s a # acosh :: Tagged s a -> Tagged s a # atanh :: Tagged s a -> Tagged s a # log1p :: Tagged s a -> Tagged s a expm1 :: Tagged s a -> Tagged s a log1pexp :: Tagged s a -> Tagged s a log1mexp :: Tagged s a -> Tagged s a | |
class Num a => Fractional a where #
Minimal complete definition
fromRational, (recip | (/))
Instances
class (Real a, Enum a) => Integral a where #
Methods
Instances
| Integral Int | |
| Integral Int8 | |
| Integral Int16 | |
| Integral Int32 | |
| Integral Int64 | |
| Integral Integer | |
Defined in GHC.Real | |
| Integral Natural | |
Defined in GHC.Real | |
| Integral Word | |
| Integral Word8 | |
| Integral Word16 | |
| Integral Word32 | |
| Integral Word64 | |
| Integral CInt | |
| Integral CMode | |
| Integral CSize | |
| Integral CChar | |
| Integral CULong | |
Defined in Foreign.C.Types | |
| Integral CDev | |
| Integral CIno | |
| Integral WordPtr | |
Defined in Foreign.Ptr | |
| Integral CBool | |
| 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 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 CUShort | |
Defined in Foreign.C.Types | |
| Integral CWchar | |
Defined in Foreign.C.Types | |
| Integral Fd | |
| Integral CBlkCnt | |
Defined in System.Posix.Types | |
| Integral CBlkSize | |
Defined in System.Posix.Types | |
| Integral CClockId | |
Defined in System.Posix.Types | |
| 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 CKey | |
| 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 IntPtr | |
Defined in Foreign.Ptr | |
| Integral PortNumber | |
Defined in Network.Socket.Types Methods quot :: PortNumber -> PortNumber -> PortNumber # rem :: PortNumber -> PortNumber -> PortNumber # div :: PortNumber -> PortNumber -> PortNumber # mod :: PortNumber -> PortNumber -> PortNumber # quotRem :: PortNumber -> PortNumber -> (PortNumber, PortNumber) # divMod :: PortNumber -> PortNumber -> (PortNumber, PortNumber) # | |
| () :=> (Integral Int) | |
Defined in Data.Constraint | |
| () :=> (Integral Integer) | |
Defined in Data.Constraint | |
| () :=> (Integral Natural) | |
Defined in Data.Constraint | |
| () :=> (Integral Word) | |
Defined in Data.Constraint | |
| 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 (Down a) | |
| (Integral a) :=> (RealFrac (Ratio a)) | |
Defined in Data.Constraint | |
| (Integral a) :=> (Real (Ratio a)) | |
Defined in Data.Constraint | |
| (Integral a) :=> (Ord (Ratio a)) | |
Defined in Data.Constraint | |
| (Integral a) :=> (Num (Ratio a)) | |
Defined in Data.Constraint | |
| (Integral a) :=> (Integral (Identity a)) | |
Defined in Data.Constraint | |
| (Integral a) :=> (Integral (Const a b)) | |
Defined in Data.Constraint | |
| (Integral a) :=> (Fractional (Ratio a)) | |
Defined in Data.Constraint Methods ins :: Integral a :- Fractional (Ratio a) | |
| (Integral a) :=> (Enum (Ratio a)) | |
Defined in Data.Constraint | |
| (Integral a, Show a) :=> (Show (Ratio a)) | |
Defined in Data.Constraint | |
| (Integral a, Read a) :=> (Read (Ratio a)) | |
Defined in Data.Constraint | |
| Class (Real a, Enum a) (Integral a) | |
Defined in Data.Constraint | |
| 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 a => Integral (Tagged s a) | |
Defined in Data.Tagged Methods quot :: Tagged s a -> Tagged s a -> Tagged s a # rem :: Tagged s a -> Tagged s a -> Tagged s a # div :: Tagged s a -> Tagged s a -> Tagged s a # mod :: Tagged s a -> Tagged s a -> Tagged s a # quotRem :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a) # divMod :: Tagged s a -> Tagged s a -> (Tagged s a, Tagged s a) # | |
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
| Monad [] | |
| Monad Maybe | |
| Monad IO | |
| Monad Par1 | |
| Monad Q | |
| Monad P | |
| Monad ReadP | |
| Monad ReadPrec | |
| Monad First | |
| Monad Last | |
| Monad Dual | |
| Monad Product | |
| Monad Sum | |
| Monad NonEmpty | |
| Monad First | |
| Monad Last | |
| Monad Max | |
| Monad Min | |
| Monad Option | |
| Monad Identity | |
| Monad Down | |
| Monad PutM | |
| Monad Get | |
| Monad Stream | |
| Monad Seq | |
| Monad Tree | |
| Monad Complex | |
| Monad Vector | |
| Monad Id | |
| Monad Array | |
| Monad Box | |
| Monad SmallArray | |
| Monad STM | |
| Monad CryptoFailable | |
| Monad Result | |
| Monad IResult | |
| Monad Parser | |
| Monad DNonEmpty | |
| Monad DList | |
| Monad Capability | |
| Monad Put | |
| Monad Perhaps Source # | |
| Monad DefaultIO Source # | |
| () :=> (Monad ((->) a :: Type -> Type)) | |
Defined in Data.Constraint | |
| () :=> (Monad []) | |
Defined in Data.Constraint | |
| () :=> (Monad IO) | |
Defined in Data.Constraint | |
| () :=> (Monad (Either a)) | |
Defined in Data.Constraint | |
| () :=> (Monad Identity) | |
Defined in Data.Constraint | |
| Monad (Either e) | |
| Monad (U1 :: Type -> Type) | |
| Monoid a => Monad ((,) a) | |
| Monad m => Monad (WrappedMonad m) | |
| Monad (Proxy :: Type -> Type) | |
| Monad (ST s) | |
| ArrowApply a => Monad (ArrowMonad a) | |
| Monad (ST s) | |
| Monad m => Monad (ListT m) | |
| Monad m => Monad (MaybeT m) | |
| DRG gen => Monad (MonadPseudoRandom gen) | |
| Monad m => Monad (ResourceT m) | |
| Monad (Parser i) | |
| Monad f => Monad (WrappedPoly f) | |
| Semigroup a => Monad (These a) | |
| Semigroup a => Monad (These a) | |
| Monad m => Monad (InputT m) | |
| Monad (Partial e) | |
| (Monad m) :=> (Functor (WrappedMonad m)) | |
Defined in Data.Constraint | |
| (Monad m) :=> (Applicative (WrappedMonad m)) | |
Defined in Data.Constraint Methods ins :: Monad m :- Applicative (WrappedMonad m) | |
| Class (Applicative f) (Monad f) | |
Defined in Data.Constraint Methods cls :: Monad f :- Applicative f | |
| Monad f => Monad (Rec1 f) | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | |
| Monad f => Monad (Ap f) | |
| Monad f => Monad (Alt f) | |
| Monad m => Monad (Kleisli m a) | |
| (Monad m, Error e) => Monad (ErrorT e m) | |
| (Applicative f, Monad f) => Monad (WhenMissing f x) | |
| Monad m => Monad (IdentityT m) | |
| (Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
| Monad m => Monad (ExceptT e m) | |
| Monad m => Monad (ReaderT r m) | |
| Monad m => Monad (SelectT r m) | |
| Monad m => Monad (StateT s m) | |
| Monad m => Monad (StateT s m) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| Monad m => Monad (WriterT w m) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| Monad (Tagged s) | |
| Class (Monad f, Alternative f) (MonadPlus f) | |
Defined in Data.Constraint | |
| Monad ((->) r :: Type -> Type) | |
| (Monad f, Monad g) => Monad (f :*: g) | |
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
| Monad (ParsecT s u m) | |
| (Applicative f, Monad f) => Monad (WhenMissing f k x) | |
| (Monad f, Applicative f) => Monad (WhenMatched f x y) | |
| (Monad f, Monad g) => Monad (Product f g) | |
| Monad (ContT r m) | |
| Monad (ConduitT i o m) | |
| Monad f => Monad (M1 i c f) | |
| (Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
| Monad m => Monad (RWST r w s m) | |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
| Monad m => Monad (Pipe l i o u m) | |
| Monad state => Monad (Builder collection mutCollection step state err) | |
Defined in Basement.MutableBuilder Methods (>>=) :: Builder collection mutCollection step state err a -> (a -> Builder collection mutCollection step state err b) -> Builder collection mutCollection step state err b # (>>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # return :: a -> Builder collection mutCollection step state err a # | |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Methods
fromInteger :: Integer -> a #
Instances
| Num Int | |
| Num Int8 | |
| Num Int16 | |
| Num Int32 | |
| Num Int64 | |
| Num Integer | |
| Num Natural | |
| Num Word | |
| Num Word8 | |
| Num Word16 | |
| Num Word32 | |
| Num Word64 | |
| Num CInt | |
| Num CMode | |
| Num CSize | |
| Num CChar | |
| Num CULong | |
| Num CDev | |
| Num CIno | |
| Num WordPtr | |
| Num DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Num CTime | |
| Num CSUSeconds | |
Defined in Foreign.C.Types | |
| Num CBool | |
| Num CClock | |
| Num CDouble | |
| Num CFloat | |
| Num CIntMax | |
| Num CIntPtr | |
| Num CLLong | |
| Num CLong | |
| Num CPtrdiff | |
| Num CSChar | |
| Num CShort | |
| Num CSigAtomic | |
Defined in Foreign.C.Types | |
| Num CUChar | |
| Num CUInt | |
| Num CUIntMax | |
| Num CUIntPtr | |
| Num CULLong | |
| Num CUSeconds | |
Defined in Foreign.C.Types | |
| Num CUShort | |
| Num CWchar | |
| Num Fd | |
| Num CBlkCnt | |
| Num CBlkSize | |
| Num CCc | |
| Num CClockId | |
| Num CFsBlkCnt | |
Defined in System.Posix.Types | |
| Num CFsFilCnt | |
Defined in System.Posix.Types | |
| Num CGid | |
| Num CId | |
| Num CKey | |
| Num CNfds | |
| Num CNlink | |
| Num COff | |
| Num CPid | |
| Num CRLim | |
| Num CSocklen | |
| Num CSpeed | |
| Num CSsize | |
| Num CTcflag | |
| Num CUid | |
| Num IntPtr | |
| Num Pos | |
| Num Number | |
| Num PortNumber | |
Defined in Network.Socket.Types | |
| Num CodePoint | |
Defined in Data.Text.Encoding | |
| Num DecoderState | |
Defined in Data.Text.Encoding Methods (+) :: DecoderState -> DecoderState -> DecoderState # (-) :: DecoderState -> DecoderState -> DecoderState # (*) :: DecoderState -> DecoderState -> DecoderState # negate :: DecoderState -> DecoderState # abs :: DecoderState -> DecoderState # signum :: DecoderState -> DecoderState # fromInteger :: Integer -> DecoderState # | |
| () :=> (Num Double) | |
Defined in Data.Constraint | |
| () :=> (Num Float) | |
Defined in Data.Constraint | |
| () :=> (Num Int) | |
Defined in Data.Constraint | |
| () :=> (Num Integer) | |
Defined in Data.Constraint | |
| () :=> (Num Natural) | |
Defined in Data.Constraint | |
| () :=> (Num Word) | |
Defined in Data.Constraint | |
| Class () (Num a) | |
Defined in Data.Constraint | |
| Integral a => Num (Ratio a) | |
| Num a => Num (Product a) | |
Defined in Data.Semigroup.Internal | |
| Num a => Num (Sum a) | |
| Num a => Num (Max a) | |
| Num a => Num (Min a) | |
| Num a => Num (Identity a) | |
Defined in Data.Functor.Identity | |
| Num a => Num (Down a) | |
| RealFloat a => Num (Complex a) | |
| Num (Offset ty) | |
Defined in Basement.Types.OffsetSize | |
| Num (CountOf ty) | |
Defined in Basement.Types.OffsetSize | |
| KnownNat n => Num (Zn n) | |
| (KnownNat n, NatWithinBound Word64 n) => Num (Zn64 n) | |
| (Integral a) :=> (Num (Ratio a)) | |
Defined in Data.Constraint | |
| (Num a) :=> (Num (Identity a)) | |
Defined in Data.Constraint | |
| (Num a) :=> (Num (Const a b)) | |
Defined in Data.Constraint | |
| (RealFloat a) :=> (Num (Complex a)) | |
Defined in Data.Constraint | |
| Class (Num a) (Fractional a) | |
Defined in Data.Constraint Methods cls :: Fractional a :- Num a | |
| HasResolution a => Num (Fixed a) | |
| Class (Num a, Ord a) (Real a) | |
Defined in Data.Constraint | |
| Num a => Num (Const a b) | |
Defined in Data.Functor.Const | |
| (Applicative f, Num a) => Num (Ap f a) | |
| Num (f a) => Num (Alt f a) | |
| Num a => Num (Tagged s a) | |
Defined in Data.Tagged | |
Instances
| Ord Bool | |
| Ord Char | |
| Ord Double | |
| Ord Float | |
| Ord Int | |
| Ord Int8 | |
| Ord Int16 | |
| Ord Int32 | |
| Ord Int64 | |
| Ord Integer | |
| Ord Natural | |
| Ord Ordering | |
Defined in GHC.Classes | |
| Ord Word | |
| Ord Word8 | |
| Ord Word16 | |
| Ord Word32 | |
| Ord Word64 | |
| Ord SomeTypeRep | |
Defined in Data.Typeable.Internal | |
| Ord Exp | |
| Ord Match | |
| Ord Clause | |
| Ord Pat | |
| Ord Type | |
| Ord Dec | |
| Ord Name | |
| Ord FunDep | |
| Ord InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax Methods compare :: InjectivityAnn -> InjectivityAnn -> Ordering # (<) :: InjectivityAnn -> InjectivityAnn -> Bool # (<=) :: InjectivityAnn -> InjectivityAnn -> Bool # (>) :: InjectivityAnn -> InjectivityAnn -> Bool # (>=) :: InjectivityAnn -> InjectivityAnn -> Bool # | |
| Ord Overlap | |
Defined in Language.Haskell.TH.Syntax | |
| Ord () | |
| Ord TyCon | |
| Ord All | |
| Ord Any | |
| Ord SeekMode | |
Defined in GHC.IO.Device | |
| Ord BufferMode | |
Defined in GHC.IO.Handle.Types | |
| Ord Newline | |
| Ord NewlineMode | |
Defined in GHC.IO.Handle.Types | |
| Ord IOMode | |
| Ord CInt | |
| Ord CMode | |
| 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 BigNat | |
| 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 ByteString | |
Defined in Data.ByteString.Internal | |
| Ord CSize | |
| Ord CChar | |
| Ord CULong | |
| 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 CDev | |
| Ord CIno | |
| Ord SourcePos | |
| Ord Lit | |
| Ord NameFlavour | |
Defined in Language.Haskell.TH.Syntax | |
| Ord ByteString | |
Defined in Data.ByteString.Lazy.Internal | |
| Ord WordPtr | |
| Ord Message | |
| Ord Day | |
| Ord DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Ord UTCTime | |
Defined in Data.Time.Clock.Internal.UTCTime | |
| Ord UniversalTime | |
Defined in Data.Time.Clock.Internal.UniversalTime Methods compare :: UniversalTime -> UniversalTime -> Ordering # (<) :: UniversalTime -> UniversalTime -> Bool # (<=) :: UniversalTime -> UniversalTime -> Bool # (>) :: UniversalTime -> UniversalTime -> Bool # (>=) :: UniversalTime -> UniversalTime -> Bool # | |
| Ord TimeLocale | |
Defined in Data.Time.Format.Locale | |
| Ord LocalTime | |
Defined in Data.Time.LocalTime.Internal.LocalTime | |
| Ord TimeOfDay | |
Defined in Data.Time.LocalTime.Internal.TimeOfDay | |
| Ord TimeZone | |
Defined in Data.Time.LocalTime.Internal.TimeZone | |
| Ord CalendarTime | |
Defined in System.Time | |
| Ord ClockTime | |
| Ord Day | |
| Ord Month | |
| Ord TimeDiff | |
Defined in System.Time | |
| Ord CTime | |
| Ord CSUSeconds | |
| Ord CBool | |
| Ord CClock | |
| Ord CDouble | |
| Ord CFloat | |
| Ord CIntMax | |
| Ord CIntPtr | |
| Ord CLLong | |
| Ord CLong | |
| Ord CPtrdiff | |
Defined in Foreign.C.Types | |
| Ord CSChar | |
| Ord CShort | |
| Ord CSigAtomic | |
| Ord CUChar | |
| Ord CUInt | |
| Ord CUIntMax | |
Defined in Foreign.C.Types | |
| Ord CUIntPtr | |
Defined in Foreign.C.Types | |
| Ord CULLong | |
| Ord CUSeconds | |
| Ord CUShort | |
| Ord CWchar | |
| Ord CompressionStrategy | |
Defined in Codec.Compression.Zlib.Stream Methods compare :: CompressionStrategy -> CompressionStrategy -> Ordering # (<) :: CompressionStrategy -> CompressionStrategy -> Bool # (<=) :: CompressionStrategy -> CompressionStrategy -> Bool # (>) :: CompressionStrategy -> CompressionStrategy -> Bool # (>=) :: CompressionStrategy -> CompressionStrategy -> Bool # max :: CompressionStrategy -> CompressionStrategy -> CompressionStrategy # min :: CompressionStrategy -> CompressionStrategy -> CompressionStrategy # | |
| Ord Method | |
| Ord WindowBits | |
Defined in Codec.Compression.Zlib.Stream | |
| Ord Format | |
| Ord Mode | |
| Ord DictionaryHash | |
Defined in Codec.Compression.Zlib.Stream Methods compare :: DictionaryHash -> DictionaryHash -> Ordering # (<) :: DictionaryHash -> DictionaryHash -> Bool # (<=) :: DictionaryHash -> DictionaryHash -> Bool # (>) :: DictionaryHash -> DictionaryHash -> Bool # (>=) :: DictionaryHash -> DictionaryHash -> Bool # | |
| Ord Fd | |
| Ord CBlkCnt | |
| Ord CBlkSize | |
Defined in System.Posix.Types | |
| Ord CCc | |
| Ord CClockId | |
Defined in System.Posix.Types | |
| Ord CFsBlkCnt | |
| Ord CFsFilCnt | |
| Ord CGid | |
| Ord CId | |
| Ord CKey | |
| 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 Version | |
| Ord ShortByteString | |
Defined in Data.ByteString.Short.Internal Methods compare :: ShortByteString -> ShortByteString -> Ordering # (<) :: ShortByteString -> ShortByteString -> Bool # (<=) :: ShortByteString -> ShortByteString -> Bool # (>) :: ShortByteString -> ShortByteString -> Bool # (>=) :: ShortByteString -> ShortByteString -> Bool # max :: ShortByteString -> ShortByteString -> ShortByteString # min :: ShortByteString -> ShortByteString -> ShortByteString # | |
| Ord IntSet | |
| Ord 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 Fingerprint | |
Defined in GHC.Fingerprint.Type | |
| Ord IntPtr | |
| Ord ThreadId | |
Defined in GHC.Conc.Sync | |
| Ord Void | |
| Ord AnnLookup | |
| Ord AnnTarget | |
| Ord Bang | |
| Ord Body | |
| Ord Bytes | |
| Ord Callconv | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Con | |
| Ord DecidedStrictness | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering # (<) :: DecidedStrictness -> DecidedStrictness -> Bool # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool # (>) :: DecidedStrictness -> DecidedStrictness -> Bool # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness # | |
| Ord DerivClause | |
Defined in Language.Haskell.TH.Syntax | |
| Ord DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering # (<) :: DerivStrategy -> DerivStrategy -> Bool # (<=) :: DerivStrategy -> DerivStrategy -> Bool # (>) :: DerivStrategy -> DerivStrategy -> Bool # (>=) :: DerivStrategy -> DerivStrategy -> Bool # | |
| Ord FamilyResultSig | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FamilyResultSig -> FamilyResultSig -> Ordering # (<) :: FamilyResultSig -> FamilyResultSig -> Bool # (<=) :: FamilyResultSig -> FamilyResultSig -> Bool # (>) :: FamilyResultSig -> FamilyResultSig -> Bool # (>=) :: FamilyResultSig -> FamilyResultSig -> Bool # max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig # | |
| Ord Fixity | |
| Ord FixityDirection | |
Defined in Language.Haskell.TH.Syntax Methods compare :: FixityDirection -> FixityDirection -> Ordering # (<) :: FixityDirection -> FixityDirection -> Bool # (<=) :: FixityDirection -> FixityDirection -> Bool # (>) :: FixityDirection -> FixityDirection -> Bool # (>=) :: FixityDirection -> FixityDirection -> Bool # max :: FixityDirection -> FixityDirection -> FixityDirection # min :: FixityDirection -> FixityDirection -> FixityDirection # | |
| Ord Foreign | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Guard | |
| Ord Info | |
| Ord Inline | |
| Ord Loc | |
| Ord ModName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Module | |
| Ord ModuleInfo | |
Defined in Language.Haskell.TH.Syntax | |
| Ord NameSpace | |
| Ord OccName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord PatSynArgs | |
Defined in Language.Haskell.TH.Syntax | |
| Ord PatSynDir | |
| Ord Phases | |
| Ord PkgName | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Pragma | |
| Ord Range | |
| Ord Role | |
| Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Ord RuleMatch | |
| Ord Safety | |
| Ord SourceStrictness | |
Defined in Language.Haskell.TH.Syntax Methods compare :: SourceStrictness -> SourceStrictness -> Ordering # (<) :: SourceStrictness -> SourceStrictness -> Bool # (<=) :: SourceStrictness -> SourceStrictness -> Bool # (>) :: SourceStrictness -> SourceStrictness -> Bool # (>=) :: SourceStrictness -> SourceStrictness -> Bool # max :: SourceStrictness -> SourceStrictness -> SourceStrictness # min :: SourceStrictness -> SourceStrictness -> SourceStrictness # | |
| Ord SourceUnpackedness | |
Defined in Language.Haskell.TH.Syntax Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness # | |
| Ord Stmt | |
| Ord TyLit | |
| Ord TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
| Ord TyVarBndr | |
| Ord TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering # (<) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool # | |
| Ord ByteArray | |
| Ord Proxy | |
| Ord Value | |
| Ord JSONPathElement | |
Defined in Data.Aeson.Types.Internal Methods compare :: JSONPathElement -> JSONPathElement -> Ordering # (<) :: JSONPathElement -> JSONPathElement -> Bool # (<=) :: JSONPathElement -> JSONPathElement -> Bool # (>) :: JSONPathElement -> JSONPathElement -> Bool # (>=) :: JSONPathElement -> JSONPathElement -> Bool # max :: JSONPathElement -> JSONPathElement -> JSONPathElement # min :: JSONPathElement -> JSONPathElement -> JSONPathElement # | |
| Ord Pos | |
| Ord StreamFileStatus | |
Defined in Network.HTTP.Client.Types Methods compare :: StreamFileStatus -> StreamFileStatus -> Ordering # (<) :: StreamFileStatus -> StreamFileStatus -> Bool # (<=) :: StreamFileStatus -> StreamFileStatus -> Bool # (>) :: StreamFileStatus -> StreamFileStatus -> Bool # (>=) :: StreamFileStatus -> StreamFileStatus -> Bool # max :: StreamFileStatus -> StreamFileStatus -> StreamFileStatus # min :: StreamFileStatus -> StreamFileStatus -> StreamFileStatus # | |
| Ord Cookie | |
| Ord ByteRange | |
| Ord Permissions | |
Defined in System.Directory.Internal.Common | |
| Ord XdgDirectory | |
Defined in System.Directory.Internal.Common | |
| Ord XdgDirectoryList | |
Defined in System.Directory.Internal.Common Methods compare :: XdgDirectoryList -> XdgDirectoryList -> Ordering # (<) :: XdgDirectoryList -> XdgDirectoryList -> Bool # (<=) :: XdgDirectoryList -> XdgDirectoryList -> Bool # (>) :: XdgDirectoryList -> XdgDirectoryList -> Bool # (>=) :: XdgDirectoryList -> XdgDirectoryList -> Bool # max :: XdgDirectoryList -> XdgDirectoryList -> XdgDirectoryList # min :: XdgDirectoryList -> XdgDirectoryList -> XdgDirectoryList # | |
| Ord AbsoluteTime | |
Defined in Data.Time.Clock.Internal.AbsoluteTime | |
| Ord Number | |
| Ord URIAuth | |
| Ord URI | |
| Ord SockAddr | |
Defined in Network.Socket.Types | |
| Ord Family | |
| Ord SocketType | |
Defined in Network.Socket.Types | |
| Ord Encoding | |
Defined in Basement.String | |
| Ord String | |
| Ord UTF32_Invalid | |
Defined in Basement.String.Encoding.UTF32 Methods compare :: UTF32_Invalid -> UTF32_Invalid -> Ordering # (<) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (<=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>) :: UTF32_Invalid -> UTF32_Invalid -> Bool # (>=) :: UTF32_Invalid -> UTF32_Invalid -> Bool # | |
| Ord FileSize | |
Defined in Basement.Types.OffsetSize | |
| Ord DotNetTime | |
Defined in Data.Aeson.Types.Internal | |
| Ord UUID | |
| Ord UnpackedUUID | |
Defined in Data.UUID.Types.Internal | |
| Ord ConnHost | |
Defined in Network.HTTP.Client.Types | |
| Ord ConnKey | |
Defined in Network.HTTP.Client.Types | |
| Ord StatusHeaders | |
Defined in Network.HTTP.Client.Types Methods compare :: StatusHeaders -> StatusHeaders -> Ordering # (<) :: StatusHeaders -> StatusHeaders -> Bool # (<=) :: StatusHeaders -> StatusHeaders -> Bool # (>) :: StatusHeaders -> StatusHeaders -> Bool # (>=) :: StatusHeaders -> StatusHeaders -> Bool # | |
| Ord SHA1 Source # | |
| Ord Hash Source # | |
| Ord SomeNat | |
| Ord BlockReason | |
Defined in GHC.Conc.Sync | |
| Ord ThreadStatus | |
Defined in GHC.Conc.Sync | |
| Ord DoPa | |
| Ord WhichTest | |
| Ord AnchoredPath Source # | |
Defined in Darcs.Util.Path Methods compare :: AnchoredPath -> AnchoredPath -> Ordering # (<) :: AnchoredPath -> AnchoredPath -> Bool # (<=) :: AnchoredPath -> AnchoredPath -> Bool # (>) :: AnchoredPath -> AnchoredPath -> Bool # (>=) :: AnchoredPath -> AnchoredPath -> Bool # max :: AnchoredPath -> AnchoredPath -> AnchoredPath # min :: AnchoredPath -> AnchoredPath -> AnchoredPath # | |
| Ord Name Source # | |
| Ord AbsoluteOrRemotePath Source # | |
Defined in Darcs.Util.Path Methods compare :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Ordering # (<) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool # (<=) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool # (>) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool # (>=) :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> Bool # max :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> AbsoluteOrRemotePath # min :: AbsoluteOrRemotePath -> AbsoluteOrRemotePath -> AbsoluteOrRemotePath # | |
| Ord AbsolutePathOrStd Source # | |
Defined in Darcs.Util.Path Methods compare :: AbsolutePathOrStd -> AbsolutePathOrStd -> Ordering # (<) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool # (<=) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool # (>) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool # (>=) :: AbsolutePathOrStd -> AbsolutePathOrStd -> Bool # max :: AbsolutePathOrStd -> AbsolutePathOrStd -> AbsolutePathOrStd # min :: AbsolutePathOrStd -> AbsolutePathOrStd -> AbsolutePathOrStd # | |
| Ord AbsolutePath Source # | |
Defined in Darcs.Util.Path Methods compare :: AbsolutePath -> AbsolutePath -> Ordering # (<) :: AbsolutePath -> AbsolutePath -> Bool # (<=) :: AbsolutePath -> AbsolutePath -> Bool # (>) :: AbsolutePath -> AbsolutePath -> Bool # (>=) :: AbsolutePath -> AbsolutePath -> Bool # max :: AbsolutePath -> AbsolutePath -> AbsolutePath # min :: AbsolutePath -> AbsolutePath -> AbsolutePath # | |
| Ord SubPath Source # | |
| Ord ItemType Source # | |
Defined in Darcs.Util.Tree | |
| Ord FileType | |
Defined in System.Directory.Internal.Common | |
| Ord SummOp Source # | |
| Ord SummDetail Source # | |
Defined in Darcs.Patch.SummaryData Methods compare :: SummDetail -> SummDetail -> Ordering # (<) :: SummDetail -> SummDetail -> Bool # (<=) :: SummDetail -> SummDetail -> Bool # (>) :: SummDetail -> SummDetail -> Bool # (>=) :: SummDetail -> SummDetail -> Bool # max :: SummDetail -> SummDetail -> SummDetail # min :: SummDetail -> SummDetail -> SummDetail # | |
| Ord UUID Source # | |
| Ord PatchId Source # | |
Defined in Darcs.Patch.Index.Types | |
| Ord FileId Source # | |
| Ord PatchInfo Source # | |
| Ord ConflictState Source # | |
Defined in Darcs.Patch.Summary Methods compare :: ConflictState -> ConflictState -> Ordering # (<) :: ConflictState -> ConflictState -> Bool # (<=) :: ConflictState -> ConflictState -> Bool # (>) :: ConflictState -> ConflictState -> Bool # (>=) :: ConflictState -> ConflictState -> Bool # max :: ConflictState -> ConflictState -> ConflictState # min :: ConflictState -> ConflictState -> ConflictState # | |
| Ord PortNumber | |
Defined in Network.Socket.Types | |
| Ord EntryContent | |
Defined in Codec.Archive.Tar.Types | |
| Ord Format | |
| Ord LinkTarget | |
Defined in Codec.Archive.Tar.Types | |
| Ord Ownership | |
| Ord TarPath | |
Defined in Codec.Archive.Tar.Types | |
| Ord PrimPatchId Source # | |
Defined in Darcs.Patch.Prim.Named Methods compare :: PrimPatchId -> PrimPatchId -> Ordering # (<) :: PrimPatchId -> PrimPatchId -> Bool # (<=) :: PrimPatchId -> PrimPatchId -> Bool # (>) :: PrimPatchId -> PrimPatchId -> Bool # (>=) :: PrimPatchId -> PrimPatchId -> Bool # max :: PrimPatchId -> PrimPatchId -> PrimPatchId # min :: PrimPatchId -> PrimPatchId -> PrimPatchId # | |
| Ord Greediness | |
Defined in Text.Regex.Applicative.Types | |
| () :=> (Ord Bool) | |
Defined in Data.Constraint | |
| () :=> (Ord Char) | |
Defined in Data.Constraint | |
| () :=> (Ord Double) | |
Defined in Data.Constraint | |
| () :=> (Ord Float) | |
Defined in Data.Constraint | |
| () :=> (Ord Int) | |
Defined in Data.Constraint | |
| () :=> (Ord Integer) | |
Defined in Data.Constraint | |
| () :=> (Ord Natural) | |
Defined in Data.Constraint | |
| () :=> (Ord Word) | |
Defined in Data.Constraint | |
| () :=> (Ord ()) | |
Defined in Data.Constraint | |
| () :=> (Ord (a :- b)) | |
Defined in Data.Constraint | |
| () :=> (Ord (Dict a)) | |
Defined in Data.Constraint | |
| Ord a => Ord [a] | |
| Ord a => Ord (Maybe a) | |
| Integral a => Ord (Ratio a) | |
| Ord (Ptr a) | |
| Ord (FunPtr a) | |
Defined in GHC.Ptr | |
| Ord p => Ord (Par1 p) | |
| Ord a => Ord (ZipList a) | |
| Ord a => Ord (First a) | |
| Ord a => Ord (Last a) | |
| Ord a => Ord (Dual a) | |
| Ord a => Ord (Product a) | |
| Ord a => Ord (Sum a) | |
| Ord a => Ord (NonEmpty a) | |
| Ord a => Ord (First a) | |
| Ord a => Ord (Last a) | |
| Ord a => Ord (Max a) | |
| Ord a => Ord (Min a) | |
| Ord a => Ord (Option a) | |
Defined in Data.Semigroup | |
| Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup Methods compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering # (<) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool # max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # | |
| Ord a => Ord (Identity a) | |
Defined in Data.Functor.Identity | |
| Ord a => Ord (Down a) | |
| Ord (ForeignPtr a) | |
Defined in GHC.ForeignPtr | |
| Ord a => Ord (Set a) | |
| Ord a => Ord (Hashed a) | |
Defined in Data.Hashable.Class | |
| Ord a => Ord (IntMap a) | |
Defined in Data.IntMap.Internal | |
| Ord a => Ord (Seq a) | |
| Ord a => Ord (ViewL a) | |
Defined in Data.Sequence.Internal | |
| Ord a => Ord (ViewR a) | |
Defined in Data.Sequence.Internal | |
| Ord a => Ord (Tree a) | |
| Ord a => Ord (Vector a) | |
Defined in Data.Vector | |
| Ord a => Ord (Array a) | |
Defined in Data.Primitive.Array | |
| (Prim a, Ord a) => Ord (Vector a) | |
Defined in Data.Vector.Primitive | |
| (Ord a, Prim a) => Ord (PrimArray a) | |
Defined in Data.Primitive.PrimArray | |
| Ord a => Ord (SmallArray a) | |
Defined in Data.Primitive.SmallArray | |
| Ord (Async a) | |
Defined in Control.Concurrent.Async | |
| Ord mono => Ord (NonNull mono) | |
Defined in Data.NonNull | |
| Ord a => Ord (Flush a) | |
Defined in Data.Conduit.Internal.Conduit | |
| Ord s => Ord (CI s) | |
| (PrimType ty, Ord ty) => Ord (UArray ty) | |
| Ord (Offset ty) | |
| Ord (CountOf ty) | |
Defined in Basement.Types.OffsetSize | |
| (PrimType ty, Ord ty) => Ord (Block ty) | |
Defined in Basement.Block.Base | |
| Ord (Bits n) | |
| Ord a => Ord (HashSet a) | |
| (Storable a, Ord a) => Ord (Vector a) | |
Defined in Data.Vector.Storable | |
| Ord (Zn n) | |
| Ord (Zn64 n) | |
| Ord (Digest a) | |
Defined in Crypto.Hash.Types | |
| Ord1 f => Ord (Fix f) | |
| (Functor f, Ord1 f) => Ord (Mu f) | |
| (Functor f, Ord1 f) => Ord (Nu f) | |
| Ord a => Ord (DNonEmpty a) | |
Defined in Data.DList.DNonEmpty.Internal | |
| Ord a => Ord (DList a) | |
| Ord g => Ord (StateGen g) | |
Defined in System.Random.Internal | |
| Ord g => Ord (AtomicGen g) | |
Defined in System.Random.Stateful | |
| Ord g => Ord (IOGen g) | |
Defined in System.Random.Stateful | |
| Ord g => Ord (STGen g) | |
Defined in System.Random.Stateful | |
| Ord a => Ord (Maybe a) | |
| Ord (Dict a) | |
| (Integral a) :=> (Ord (Ratio a)) | |
Defined in Data.Constraint | |
| (Ord a) :=> (Ord (Maybe a)) | |
Defined in Data.Constraint | |
| (Ord a) :=> (Ord [a]) | |
Defined in Data.Constraint | |
| (Ord a) :=> (Ord (Identity a)) | |
Defined in Data.Constraint | |
| (Ord a) :=> (Ord (Const a b)) | |
Defined in Data.Constraint | |
| Class (Eq a) (Ord a) | |
Defined in Data.Constraint | |
| (Ord a, Ord b) => Ord (Either a b) | |
| Ord (V1 p) | |
| Ord (U1 p) | |
| Ord (TypeRep a) | |
| (Ord a, Ord b) => Ord (a, b) | |
| Ord a => Ord (Arg a b) | |
| (Ix i, Ord e) => Ord (Array i e) | |
| Ord (Proxy s) | |
| Ord (Fixed a) | |
| (Ord k, Ord v) => Ord (Map k v) | |
| (Ix ix, Ord e, IArray UArray e) => Ord (UArray ix e) | |
Defined in Data.Array.Base | |
| (Ord1 m, Ord a) => Ord (ListT m a) | |
| (Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
| (Ord k, Ord v) => Ord (HashMap k v) | |
Defined in Data.HashMap.Internal | |
| (Ord a, Ord b) => Ord (Either a b) | |
| (Ord a, Ord b) => Ord (These a b) | |
| (Ord a, Ord b) => Ord (These a b) | |
| (Ord a, Ord b) => Ord (Pair a b) | |
Defined in Data.Strict.Tuple | |
| Ord (a :- b) | |
Defined in Data.Constraint | |
| Ident p => Ord (Contexted p wX) Source # | |
Defined in Darcs.Patch.V3.Contexted Methods compare :: Contexted p wX -> Contexted p wX -> Ordering # (<) :: Contexted p wX -> Contexted p wX -> Bool # (<=) :: Contexted p wX -> Contexted p wX -> Bool # (>) :: Contexted p wX -> Contexted p wX -> Bool # (>=) :: Contexted p wX -> Contexted p wX -> Bool # | |
| Ord (DirPatchType wX wY) Source # | |
Defined in Darcs.Patch.Prim.V1.Core Methods compare :: DirPatchType wX wY -> DirPatchType wX wY -> Ordering # (<) :: DirPatchType wX wY -> DirPatchType wX wY -> Bool # (<=) :: DirPatchType wX wY -> DirPatchType wX wY -> Bool # (>) :: DirPatchType wX wY -> DirPatchType wX wY -> Bool # (>=) :: DirPatchType wX wY -> DirPatchType wX wY -> Bool # max :: DirPatchType wX wY -> DirPatchType wX wY -> DirPatchType wX wY # min :: DirPatchType wX wY -> DirPatchType wX wY -> DirPatchType wX wY # | |
| Ord (FilePatchType wX wY) Source # | |
Defined in Darcs.Patch.Prim.V1.Core Methods compare :: FilePatchType wX wY -> FilePatchType wX wY -> Ordering # (<) :: FilePatchType wX wY -> FilePatchType wX wY -> Bool # (<=) :: FilePatchType wX wY -> FilePatchType wX wY -> Bool # (>) :: FilePatchType wX wY -> FilePatchType wX wY -> Bool # (>=) :: FilePatchType wX wY -> FilePatchType wX wY -> Bool # max :: FilePatchType wX wY -> FilePatchType wX wY -> FilePatchType wX wY # min :: FilePatchType wX wY -> FilePatchType wX wY -> FilePatchType wX wY # | |
| (Ord a, Ord b) :=> (Ord (a, b)) | |
Defined in Data.Constraint | |
| (Ord a, Ord b) :=> (Ord (Either a b)) | |
| Class (Num a, Ord a) (Real a) | |
Defined in Data.Constraint | |
| 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 a => Ord (Const a b) | |
| Ord (f a) => Ord (Ap f a) | |
| Ord (f a) => Ord (Alt f a) | |
Defined in Data.Semigroup.Internal | |
| (Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
| (Ord1 f, Ord a) => Ord (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity Methods compare :: IdentityT f a -> IdentityT f a -> Ordering # (<) :: IdentityT f a -> IdentityT f a -> Bool # (<=) :: IdentityT f a -> IdentityT f a -> Bool # (>) :: IdentityT f a -> IdentityT f a -> Bool # (>=) :: IdentityT f a -> IdentityT f a -> Bool # | |
| (Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # | |
| (Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
| (Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods compare :: WriterT w m a -> WriterT w m a -> Ordering # (<) :: WriterT w m a -> WriterT w m a -> Bool # (<=) :: WriterT w m a -> WriterT w m a -> Bool # (>) :: WriterT w m a -> WriterT w m a -> Bool # (>=) :: WriterT w m a -> WriterT w m a -> Bool # | |
| Ord b => Ord (Tagged s b) | |
| (Ord1 f, Ord1 g, Ord a) => Ord (These1 f g a) | |
Defined in Data.Functor.These | |
| Ord c => Ord (K1 i c p) | |
Defined in GHC.Generics | |
| (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 a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool # (<=) :: Product f g a -> Product f g a -> Bool # (>) :: Product f g a -> Product f g a -> Bool # (>=) :: Product f g a -> Product f g a -> Bool # | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a) | |
| Ord (f p) => Ord (M1 i c f p) | |
| Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Generics | |
| (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) # | |
| (Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool # (<=) :: Compose f g a -> Compose f g a -> Bool # (>) :: Compose f g a -> Compose f g a -> Bool # (>=) :: Compose f g a -> Compose f g a -> Bool # | |
| Ord (p b a) => Ord (Flip p a b) | |
Defined in Data.Bifunctor.Flip | |
| (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 (f a b), Ord (g a b)) => Ord (Product f g a b) | |
Defined in Data.Bifunctor.Product Methods compare :: Product f g a b -> Product f g a b -> Ordering # (<) :: Product f g a b -> Product f g a b -> Bool # (<=) :: Product f g a b -> Product f g a b -> Bool # (>) :: Product f g a b -> Product f g a b -> Bool # (>=) :: Product f g a b -> Product f g a b -> Bool # max :: Product f g a b -> Product f g a b -> Product f g a b # min :: Product f g a b -> Product f g a b -> Product f g a b # | |
| (Ord (p a b), Ord (q a b)) => Ord (Sum p q a b) | |
Defined in Data.Bifunctor.Sum | |
| (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 (f (p a b)) => Ord (Tannen f p a b) | |
Defined in Data.Bifunctor.Tannen Methods compare :: Tannen f p a b -> Tannen f p a b -> Ordering # (<) :: Tannen f p a b -> Tannen f p a b -> Bool # (<=) :: Tannen f p a b -> Tannen f p a b -> Bool # (>) :: Tannen f p a b -> Tannen f p a b -> Bool # (>=) :: Tannen f p a b -> Tannen f p a b -> Bool # | |
| (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 (p (f a) (g b)) => Ord (Biff p f g a b) | |
Defined in Data.Bifunctor.Biff Methods compare :: Biff p f g a b -> Biff p f g a b -> Ordering # (<) :: Biff p f g a b -> Biff p f g a b -> Bool # (<=) :: Biff p f g a b -> Biff p f g a b -> Bool # (>) :: Biff p f g a b -> Biff p f g a b -> Bool # (>=) :: Biff p f g a b -> Biff p f g a b -> Bool # | |
| (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) # | |
Minimal complete definition
readsPrec | readPrec
Instances
| Read Bool | |
| Read Char | |
| Read Double | |
| Read Float | |
| Read Int | |
| Read Int8 | |
| Read Int16 | |
| Read Int32 | |
| Read Int64 | |
| Read Integer | |
| Read Natural | |
| Read Ordering | |
| Read Word | |
| Read Word8 | |
| Read Word16 | |
| Read Word32 | |
| Read Word64 | |
| Read () | |
| Read Lexeme | |
| Read All | |
Defined in Data.Semigroup.Internal | |
| Read Any | |
Defined in Data.Semigroup.Internal | |
| Read SeekMode | |
Defined in GHC.IO.Device | |
| 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 CInt | |
Defined in Foreign.C.Types | |
| Read CMode | |
Defined in System.Posix.Types | |
| Read GeneralCategory | |
| Read ExitCode | |
Defined in GHC.IO.Exception | |
| Read ByteString | |
Defined in Data.ByteString.Internal | |
| Read CSize | |
Defined in Foreign.C.Types | |
| Read CChar | |
Defined in Foreign.C.Types | |
| Read CULong | |
Defined in Foreign.C.Types | |
| Read CDev | |
Defined in System.Posix.Types | |
| Read CIno | |
Defined in System.Posix.Types | |
| Read ByteString | |
Defined in Data.ByteString.Lazy.Internal | |
| Read WordPtr | |
Defined in Foreign.Ptr | |
| Read DayOfWeek | |
Defined in Data.Time.Calendar.Week | |
| Read CalendarTime | |
Defined in System.Time | |
| Read Day | |
Defined in System.Time | |
| Read Month | |
Defined in System.Time | |
| Read TimeDiff | |
Defined in System.Time | |
| Read CTime | |
Defined in Foreign.C.Types | |
| Read CSUSeconds | |
Defined in Foreign.C.Types | |
| Read CBool | |
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 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 CShort | |
Defined in Foreign.C.Types | |
| Read CSigAtomic | |
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 CUSeconds | |
Defined in Foreign.C.Types | |
| Read CUShort | |
Defined in Foreign.C.Types | |
| Read CWchar | |
Defined in Foreign.C.Types | |
| Read ConnectionError Source # | |
Defined in Darcs.Util.Download.Request Methods readsPrec :: Int -> ReadS ConnectionError # readList :: ReadS [ConnectionError] # readPrec :: ReadPrec ConnectionError readListPrec :: ReadPrec [ConnectionError] | |
| Read Mode | |
Defined in System.IO.MMap | |
| Read DictionaryHash | |
Defined in Codec.Compression.Zlib.Stream | |
| Read Fd | |
Defined in System.Posix.Types | |
| 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 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 CKey | |
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 Version | |
Defined in Data.Version | |
| Read ShortByteString | |
Defined in Data.ByteString.Short.Internal | |
| Read IntSet | |
Defined in Data.IntSet.Internal | |
| 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 IntPtr | |
Defined in Foreign.Ptr | |
| Read Void | |
| Read Proxy | |
Defined in Network.HTTP.Client.Types | |
| Read Value | |
Defined in Data.Aeson.Types.Internal | |
| Read Cookie | |
Defined in Network.HTTP.Client.Types | |
| Read CookieJar | |
Defined in Network.HTTP.Client.Types | |
| Read Permissions | |
Defined in System.Directory.Internal.Common | |
| Read XdgDirectory | |
Defined in System.Directory.Internal.Common | |
| Read XdgDirectoryList | |
Defined in System.Directory.Internal.Common | |
| Read AddrInfoFlag | |
Defined in Network.Socket.Info | |
| Read NameInfoFlag | |
Defined in Network.Socket.Info | |
| Read Family | |
Defined in Network.Socket.Types | |
| Read SocketType | |
Defined in Network.Socket.Types | |
| Read DotNetTime | |
Defined in Data.Aeson.Types.Internal | |
| Read UUID | |
Defined in Data.UUID.Types.Internal | |
| Read UnpackedUUID | |
Defined in Data.UUID.Types.Internal | |
| Read Hash Source # | |
| Read SomeNat | |
Defined in GHC.TypeNats | |
| Read CompOption | |
Defined in Text.Regex.TDFA.Common | |
| Read ExecOption | |
Defined in Text.Regex.TDFA.Common | |
| Read FileType | |
Defined in System.Directory.Internal.Common | |
| Read ConflictState Source # | |
Defined in Darcs.Patch.Summary Methods readsPrec :: Int -> ReadS ConflictState # readList :: ReadS [ConflictState] # readPrec :: ReadPrec ConflictState readListPrec :: ReadPrec [ConflictState] | |
| Read PortNumber | |
Defined in Network.Socket.Types | |
| Read Archive | |
Defined in Codec.Archive.Zip | |
| Read CompressionMethod | |
Defined in Codec.Archive.Zip | |
| Read EncryptionMethod | |
Defined in Codec.Archive.Zip | |
| Read Entry | |
Defined in Codec.Archive.Zip | |
| Read ZipOption | |
Defined in Codec.Archive.Zip | |
| Read MSDOSDateTime | |
Defined in Codec.Archive.Zip | |
| Read PKWAREVerificationType | |
Defined in Codec.Archive.Zip | |
| Read Greediness | |
Defined in Text.Regex.Applicative.Types | |
| a :=> (Read (Dict a)) | |
Defined in Data.Constraint | |
| () :=> (Read Bool) | |
Defined in Data.Constraint | |
| () :=> (Read Char) | |
Defined in Data.Constraint | |
| () :=> (Read Int) | |
Defined in Data.Constraint | |
| () :=> (Read Natural) | |
Defined in Data.Constraint | |
| () :=> (Read Ordering) | |
Defined in Data.Constraint | |
| () :=> (Read Word) | |
Defined in Data.Constraint | |
| () :=> (Read ()) | |
Defined in Data.Constraint | |
| Class () (Read a) | |
Defined in Data.Constraint | |
| Read a => Read [a] | |
| Read a => Read (Maybe a) | |
| (Integral a, Read a) => Read (Ratio a) | |
| Read p => Read (Par1 p) | |
Defined in GHC.Generics | |
| Read a => Read (ZipList a) | |
Defined in Control.Applicative | |
| Read a => Read (First a) | |
Defined in Data.Monoid | |
| Read a => Read (Last a) | |
Defined in Data.Monoid | |
| Read a => Read (Dual a) | |
Defined in Data.Semigroup.Internal | |
| Read a => Read (Product a) | |
Defined in Data.Semigroup.Internal | |
| Read a => Read (Sum a) | |
Defined in Data.Semigroup.Internal | |
| Read a => Read (NonEmpty 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 a => Read (Option a) | |
Defined in Data.Semigroup | |
| Read m => Read (WrappedMonoid m) | |
Defined in Data.Semigroup | |
| Read a => Read (Identity a) | |
Defined in Data.Functor.Identity | |
| Read a => Read (Down a) | |
| (Read a, Ord a) => Read (Set a) | |
Defined in Data.Set.Internal | |
| Read e => Read (IntMap e) | |
Defined in Data.IntMap.Internal | |
| Read a => Read (Seq a) | |
Defined in Data.Sequence.Internal | |
| Read a => Read (ViewL a) | |
Defined in Data.Sequence.Internal | |
| Read a => Read (ViewR a) | |
Defined in Data.Sequence.Internal | |
| Read a => Read (Tree a) | |
| Read a => Read (Complex a) | |
Defined in Data.Complex | |
| Read a => Read (Vector a) | |
Defined in Data.Vector | |
| Read a => Read (Array a) | |
Defined in Data.Primitive.Array | |
| (Read a, Prim a) => Read (Vector a) | |
Defined in Data.Vector.Primitive | |
| Read a => Read (SmallArray a) | |
Defined in Data.Primitive.SmallArray | |
| Read mono => Read (NonNull mono) | |
Defined in Data.NonNull | |
| (Read s, FoldCase s) => Read (CI s) | |
Defined in Data.CaseInsensitive.Internal | |
| (Eq a, Hashable a, Read a) => Read (HashSet a) | |
Defined in Data.HashSet.Internal | |
| (Read a, Storable a) => Read (Vector a) | |
Defined in Data.Vector.Storable | |
| HashAlgorithm a => Read (Digest a) | |
Defined in Crypto.Hash.Types | |
| Read1 f => Read (Fix f) | |
| (Functor f, Read1 f) => Read (Mu f) | |
| (Functor f, Read1 f) => Read (Nu f) | |
| Read a => Read (DNonEmpty a) | |
Defined in Data.DList.DNonEmpty.Internal | |
| Read a => Read (DList a) | |
Defined in Data.DList.Internal | |
| Read a => Read (Maybe a) | |
Defined in Data.Strict.Maybe | |
| a => Read (Dict a) | |
Defined in Data.Constraint | |
| (Read a) :=> (Read (Complex a)) | |
Defined in Data.Constraint | |
| (Read a) :=> (Read [a]) | |
Defined in Data.Constraint | |
| (Read a) :=> (Read (Maybe a)) | |
Defined in Data.Constraint | |
| (Read a) :=> (Read (Identity a)) | |
Defined in Data.Constraint | |
| (Read a) :=> (Read (Const a b)) | |
Defined in Data.Constraint | |
| (Read a, Read b) => Read (Either a b) | |
| Read (V1 p) | |
Defined in GHC.Generics | |
| Read (U1 p) | |
Defined in GHC.Generics | |
| (Read a, Read b) => Read (a, b) | |
| (Read a, Read b) => Read (Arg a b) | |
Defined in Data.Semigroup | |
| (Ix a, Read a, Read b) => Read (Array a b) | |
| Read (Proxy t) | |
Defined in Data.Proxy | |
| HasResolution a => Read (Fixed a) | |
Defined in Data.Fixed | |
| (Ord k, Read k, Read e) => Read (Map k e) | |
Defined in Data.Map.Internal | |
| (Ix ix, Read ix, Read e, IArray UArray e) => Read (UArray ix e) | |
Defined in Data.Array.Base | |
| (Read1 m, Read a) => Read (ListT m a) | |
Defined in Control.Monad.Trans.List | |
| (Read1 m, Read a) => Read (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
| (Eq k, Hashable k, Read k, Read e) => Read (HashMap k e) | |
Defined in Data.HashMap.Internal | |
| (Read a, Read b) => Read (Either a b) | |
Defined in Data.Strict.Either | |
| (Read a, Read b) => Read (These a b) | |
Defined in Data.Strict.These | |
| (Read a, Read b) => Read (These a b) | |
Defined in Data.These | |
| (Read a, Read b) => Read (Pair a b) | |
Defined in Data.Strict.Tuple | |
| (Integral a, Read a) :=> (Read (Ratio a)) | |
Defined in Data.Constraint | |
| (Read a, Read b) :=> (Read (a, b)) | |
Defined in Data.Constraint | |
| (Read a, Read b) :=> (Read (Either a b)) | |
| Read (f p) => Read (Rec1 f p) | |
Defined in GHC.Generics | |
| (Read a, Read b, Read c) => Read (a, b, c) | |
| Read a => Read (Const a b) | |
Defined in Data.Functor.Const | |
| Read (f a) => Read (Ap f a) | |
Defined in Data.Monoid | |
| Read (f a) => Read (Alt f a) | |
Defined in Data.Semigroup.Internal | |
| (Read e, Read1 m, Read a) => Read (ErrorT e m a) | |
Defined in Control.Monad.Trans.Error | |
| (Read1 f, Read a) => Read (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity | |
| (Read e, Read1 m, Read a) => Read (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except | |
| (Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| Read b => Read (Tagged s b) | |
Defined in Data.Tagged | |
| (Read1 f, Read1 g, Read a) => Read (These1 f g a) | |
Defined in Data.Functor.These | |
| Read c => Read (K1 i c p) | |
Defined in GHC.Generics | |
| (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 a, Read b, Read c, Read d) => Read (a, b, c, d) | |
| (Read1 f, Read1 g, Read a) => Read (Product f g a) | |
Defined in Data.Functor.Product | |
| (Read1 f, Read1 g, Read a) => Read (Sum f g a) | |
Defined in Data.Functor.Sum | |
| Read (f p) => Read (M1 i c f p) | |
Defined in GHC.Generics | |
| Read (f (g p)) => Read ((f :.: g) p) | |
Defined in GHC.Generics | |
| (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) | |
| (Read1 f, Read1 g, Read a) => Read (Compose f g a) | |
Defined in Data.Functor.Compose | |
| Read (p b a) => Read (Flip p a b) | |
Defined in Data.Bifunctor.Flip | |
| (Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) | |
| (Read (f a b), Read (g a b)) => Read (Product f g a b) | |
Defined in Data.Bifunctor.Product | |
| (Read (p a b), Read (q a b)) => Read (Sum p q a b) | |
Defined in Data.Bifunctor.Sum | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) | |
| Read (f (p a b)) => Read (Tannen f p a b) | |
Defined in Data.Bifunctor.Tannen | |
| (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 (p (f a) (g b)) => Read (Biff p f g a b) | |
Defined in Data.Bifunctor.Biff | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Read | |
class (Num a, Ord a) => Real a where #
Methods
toRational :: a -> Rational #
Instances
| Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Real Int8 | |
Defined in GHC.Int Methods toRational :: Int8 -> 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 Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
| Real Natural | |
Defined in GHC.Real Methods toRational :: Natural -> Rational # | |
| Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
| Real Word8 | |
Defined in GHC.Word Methods toRational :: Word8 -> 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 CInt | |
Defined in Foreign.C.Types Methods toRational :: CInt -> Rational # | |
| Real CMode | |
Defined in System.Posix.Types Methods toRational :: CMode -> Rational # | |
| Real CSize | |
Defined in Foreign.C.Types Methods toRational :: CSize -> Rational # | |
| Real CChar | |
Defined in Foreign.C.Types Methods toRational :: CChar -> Rational # | |
| Real CULong | |
Defined in Foreign.C.Types Methods toRational :: CULong -> Rational # | |
| Real CDev | |
Defined in System.Posix.Types Methods toRational :: CDev -> Rational # | |
| Real CIno | |
Defined in System.Posix.Types Methods toRational :: CIno -> Rational # | |
| Real WordPtr | |
Defined in Foreign.Ptr Methods toRational :: WordPtr -> Rational # | |
| Real DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime Methods toRational :: DiffTime -> Rational # | |
| Real CTime | |
Defined in Foreign.C.Types Methods toRational :: CTime -> Rational # | |
| Real CSUSeconds | |
Defined in Foreign.C.Types Methods toRational :: CSUSeconds -> Rational # | |
| Real CBool | |
Defined in Foreign.C.Types Methods toRational :: CBool -> 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 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 CShort | |
Defined in Foreign.C.Types Methods toRational :: CShort -> Rational # | |
| Real CSigAtomic | |
Defined in Foreign.C.Types Methods toRational :: CSigAtomic -> 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 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 Fd | |
Defined in System.Posix.Types Methods toRational :: Fd -> 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 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 CKey | |
Defined in System.Posix.Types Methods toRational :: CKey -> 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 IntPtr | |
Defined in Foreign.Ptr Methods toRational :: IntPtr -> Rational # | |
| Real Number | |
Defined in Data.Attoparsec.Number Methods toRational :: Number -> Rational # | |
| Real PortNumber | |
Defined in Network.Socket.Types Methods toRational :: PortNumber -> Rational # | |
| () :=> (Real Double) | |
Defined in Data.Constraint | |
| () :=> (Real Float) | |
Defined in Data.Constraint | |
| () :=> (Real Int) | |
Defined in Data.Constraint | |
| () :=> (Real Integer) | |
Defined in Data.Constraint | |
| () :=> (Real Natural) | |
Defined in Data.Constraint | |
| () :=> (Real Word) | |
Defined in Data.Constraint | |
| Integral a => Real (Ratio a) | |
Defined in GHC.Real Methods toRational :: Ratio 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 Data.Constraint | |
| (Real a) :=> (Real (Identity a)) | |
Defined in Data.Constraint | |
| (Real a) :=> (Real (Const a b)) | |
Defined in Data.Constraint | |
| HasResolution a => Real (Fixed a) | |
Defined in Data.Fixed Methods toRational :: Fixed a -> Rational # | |
| Class (Num a, Ord a) (Real a) | |
Defined in Data.Constraint | |
| Class (Real a, Fractional a) (RealFrac a) | |
Defined in Data.Constraint Methods cls :: RealFrac a :- (Real a, Fractional a) | |
| Class (Real a, Enum a) (Integral a) | |
Defined in Data.Constraint | |
| Real a => Real (Const a b) | |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational # | |
| Real a => Real (Tagged s a) | |
Defined in Data.Tagged Methods toRational :: Tagged s a -> Rational # | |
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
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 #
Instances
| RealFrac DiffTime | |
| RealFrac CDouble | |
| RealFrac CFloat | |
| RealFrac Number | |
| () :=> (RealFrac Double) | |
Defined in Data.Constraint | |
| () :=> (RealFrac Float) | |
Defined in Data.Constraint | |
| Integral a => RealFrac (Ratio a) | |
| RealFrac a => RealFrac (Identity a) | |
| RealFrac a => RealFrac (Down a) | |
| (Integral a) :=> (RealFrac (Ratio a)) | |
Defined in Data.Constraint | |
| (RealFrac a) :=> (RealFrac (Identity a)) | |
Defined in Data.Constraint | |
| (RealFrac a) :=> (RealFrac (Const a b)) | |
Defined in Data.Constraint | |
| HasResolution a => RealFrac (Fixed a) | |
| Class (Real a, Fractional a) (RealFrac a) | |
Defined in Data.Constraint Methods cls :: RealFrac a :- (Real a, Fractional a) | |
| Class (RealFrac a, Floating a) (RealFloat a) | |
Defined in Data.Constraint | |
| RealFrac a => RealFrac (Const a b) | |
| RealFrac a => RealFrac (Tagged s a) | |
Instances
| Show Bool | |
| Show Char | |
| Show Int | |
| Show Int8 | |
| Show Int16 | |
| Show Int32 | |
| Show Int64 | |
| Show Integer | |
| Show Natural | |
| Show Ordering | |
| Show Word | |
| Show Word8 | |
| Show Word16 | |
| Show Word32 | |
| Show Word64 | |
| Show RuntimeRep | |
| Show VecCount | |
| Show VecElem | |
| Show CallStack | |
| Show SomeTypeRep | |
| Show Exp | |
| Show Match | |
| Show Clause | |
| Show Pat | |
| Show Type | |
| Show Dec | |
| Show Name | |
| Show FunDep | |
| Show InjectivityAnn | |
| Show Overlap | |
| Show () | |
| Show TyCon | |
| Show Module | |
| Show TrName | |
| Show KindRep | |
| Show TypeLitSort | |
| Show Lexeme | |
| Show All | |
| Show Any | |
| Show SomeException | |
| Show SeekMode | |
| Show TextEncoding | |
| Show HandlePosn | |
| Show BufferMode | |
| Show Handle | |
| Show Newline | |
| Show NewlineMode | |
| Show IOMode | |
| Show CInt | |
| Show BlockedIndefinitelyOnMVar | |
| Show CMode | |
| Show IOException | |
| Show SrcLoc | |
| Show GeneralCategory | |
| Show AllocationLimitExceeded | |
| Show ArrayException | |
| Show AssertionFailed | |
| Show AsyncException | |
| Show BlockedIndefinitelyOnSTM | |
| Show CompactionFailed | |
| Show Deadlock | |
| Show ExitCode | |
| Show FixIOException | |
| Show IOErrorType | |
| Show SomeAsyncException | |
| Show MaskingState | |
| Show ByteString | |
| Show CSize | |
| Show CChar | |
| Show CULong | |
| Show FileNameFormat Source # | |
Defined in Darcs.Patch.Format Methods showsPrec :: Int -> FileNameFormat -> ShowS # show :: FileNameFormat -> String # showList :: [FileNameFormat] -> ShowS # | |
| Show NestedAtomically | |
| Show NoMethodError | |
| Show NonTermination | |
| Show PatternMatchFail | |
| Show RecConError | |
| Show RecSelError | |
| Show RecUpdError | |
| Show TypeError | |
| Show ErrorCall | |
| Show ArithException | |
| Show CDev | |
| Show CIno | |
| Show HandleType | |
| Show ParseError | |
| Show SourcePos | |
| Show UnicodeException | |
| Show Lit | |
| Show NameFlavour | |
| Show ByteString | |
| Show WordPtr | |
| Show DayOfWeek | |
| Show DiffTime | |
| Show TimeLocale | |
| Show LocalTime | |
| Show TimeOfDay | |
| Show TimeZone | |
| Show ZonedTime | |
| Show CalendarTime | |
| Show ClockTime | |
| Show Day | |
| Show Month | |
| Show TimeDiff | |
| Show CTime | |
| Show CSUSeconds | |
| Show CBool | |
| Show CClock | |
| Show CDouble | |
| Show CFloat | |
| Show CIntMax | |
| Show CIntPtr | |
| Show CLLong | |
| Show CLong | |
| Show CPtrdiff | |
| Show CSChar | |
| Show CShort | |
| Show CSigAtomic | |
| Show CUChar | |
| Show CUInt | |
| Show CUIntMax | |
| Show CUIntPtr | |
| Show CULLong | |
| Show CUSeconds | |
| Show CUShort | |
| Show CWchar | |
| Show ConnectionError Source # | |
Defined in Darcs.Util.Download.Request Methods showsPrec :: Int -> ConnectionError -> ShowS # show :: ConnectionError -> String # showList :: [ConnectionError] -> ShowS # | |
| Show Cachable Source # | |
| Show CodingProgress | |
| Show CompressParams | |
| Show DecompressParams | |
| Show CompressionLevel | |
| Show CompressionStrategy | |
| Show MemoryLevel | |
| Show Method | |
| Show WindowBits | |
| Show DecompressError | |
| Show Format | |
| Show Mode | |
| Show DictionaryHash | |
| Show Fd | |
| Show CBlkCnt | |
| Show CBlkSize | |
| Show CCc | |
| Show CClockId | |
| Show CFsBlkCnt | |
| Show CFsFilCnt | |
| Show CGid | |
| Show CId | |
| Show CKey | |
| Show CNfds | |
| Show CNlink | |
| Show COff | |
| Show CPid | |
| Show CRLim | |
| Show CSocklen | |
| Show CSpeed | |
| Show CSsize | |
| Show CTcflag | |
| Show CTimer | |
| Show CUid | |
| Show Version | |
| Show ShortByteString | |
| Show IntSet | |
| Show Associativity | |
| Show DecidedStrictness | |
| Show Fixity | |
| Show SourceStrictness | |
| Show SourceUnpackedness | |
| Show ForeignSrcLang | |
| Show Extension | |
| Show Fingerprint | |
| Show IntPtr | |
| Show ThreadId | |
| Show Void | |
| Show AnnLookup | |
| Show AnnTarget | |
| Show Bang | |
| Show Body | |
| Show Bytes | |
| Show Callconv | |
| Show Con | |
| Show DecidedStrictness | |
| Show DerivClause | |
| Show DerivStrategy | |
| Show FamilyResultSig | |
| Show Fixity | |
| Show FixityDirection | |
| Show Foreign | |
| Show Guard | |
| Show Info | |
| Show Inline | |
| Show Loc | |
| Show ModName | |
| Show Module | |
| Show ModuleInfo | |
| Show NameSpace | |
| Show OccName | |
| Show PatSynArgs | |
| Show PatSynDir | |
| Show Phases | |
| Show PkgName | |
| Show Pragma | |
| Show Range | |
| Show Role | |
| Show RuleBndr | |
| Show RuleMatch | |
| Show Safety | |
| Show SourceStrictness | |
| Show SourceUnpackedness | |
| Show Stmt | |
| Show TyLit | |
| Show TySynEqn | |
| Show TyVarBndr | |
| Show TypeFamilyHead | |
| Show DiffAlgorithm Source # | |
Defined in Darcs.Util.Diff Methods showsPrec :: Int -> DiffAlgorithm -> ShowS # show :: DiffAlgorithm -> String # showList :: [DiffAlgorithm] -> ShowS # | |
| Show PatchFormat Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> PatchFormat -> ShowS # show :: PatchFormat -> String # showList :: [PatchFormat] -> ShowS # | |
| Show ForgetParent Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> ForgetParent -> ShowS # show :: ForgetParent -> String # showList :: [ForgetParent] -> ShowS # | |
| Show WithWorkingDir Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> WithWorkingDir -> ShowS # show :: WithWorkingDir -> String # showList :: [WithWorkingDir] -> ShowS # | |
| Show WantGuiPause Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> WantGuiPause -> ShowS # show :: WantGuiPause -> String # showList :: [WantGuiPause] -> ShowS # | |
| Show WorkRepo Source # | |
| Show ExternalMerge Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> ExternalMerge -> ShowS # show :: ExternalMerge -> String # showList :: [ExternalMerge] -> ShowS # | |
| Show AllowConflicts Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> AllowConflicts -> ShowS # show :: AllowConflicts -> String # showList :: [AllowConflicts] -> ShowS # | |
| Show CloneKind Source # | |
| Show ScanKnown Source # | |
| Show UseIndex Source # | |
| Show InheritDefault Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> InheritDefault -> ShowS # show :: InheritDefault -> String # showList :: [InheritDefault] -> ShowS # | |
| Show SetDefault Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> SetDefault -> ShowS # show :: SetDefault -> String # showList :: [SetDefault] -> ShowS # | |
| Show RemoteRepos Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> RemoteRepos -> ShowS # show :: RemoteRepos -> String # showList :: [RemoteRepos] -> ShowS # | |
| Show LeaveTestDir Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> LeaveTestDir -> ShowS # show :: LeaveTestDir -> String # showList :: [LeaveTestDir] -> ShowS # | |
| Show SetScriptsExecutable Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> SetScriptsExecutable -> ShowS # show :: SetScriptsExecutable -> String # showList :: [SetScriptsExecutable] -> ShowS # | |
| Show RunTest Source # | |
| Show IncludeBoring Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> IncludeBoring -> ShowS # show :: IncludeBoring -> String # showList :: [IncludeBoring] -> ShowS # | |
| Show LookForMoves Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> LookForMoves -> ShowS # show :: LookForMoves -> String # showList :: [LookForMoves] -> ShowS # | |
| Show LookForReplaces Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> LookForReplaces -> ShowS # show :: LookForReplaces -> String # showList :: [LookForReplaces] -> ShowS # | |
| Show LookForAdds Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> LookForAdds -> ShowS # show :: LookForAdds -> String # showList :: [LookForAdds] -> ShowS # | |
| Show UMask Source # | |
| Show DryRun Source # | |
| Show UseCache Source # | |
| Show UpdatePending Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> UpdatePending -> ShowS # show :: UpdatePending -> String # showList :: [UpdatePending] -> ShowS # | |
| Show RemoteDarcs Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> RemoteDarcs -> ShowS # show :: RemoteDarcs -> String # showList :: [RemoteDarcs] -> ShowS # | |
| Show WithPatchIndex Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> WithPatchIndex -> ShowS # show :: WithPatchIndex -> String # showList :: [WithPatchIndex] -> ShowS # | |
| Show Compression Source # | |
Defined in Darcs.Repository.Flags Methods showsPrec :: Int -> Compression -> ShowS # show :: Compression -> String # showList :: [Compression] -> ShowS # | |
| Show Verbosity Source # | |
| Show ByteArray | |
| Show Component Source # | |
| Show AsyncCancelled | |
| Show ExceptionInLinkedThread | |
| Show Decoding | |
| Show HttpException | |
| Show Proxy | |
| Show Request | |
| Show JSONException | |
| Show Value | |
| Show JSONPathElement | |
| Show Pos | |
| Show More | |
| Show StreamFileStatus | |
| Show ResponseTimeout | |
| Show Cookie | |
| Show CookieJar | |
| Show HttpExceptionContent | |
| Show ByteRange | |
| Show Permissions | |
| Show XdgDirectory | |
| Show XdgDirectoryList | |
| Show Number | |
| Show URIAuth | |
| Show ResponseClose | |
| Show URI | |
| Show AddrInfo | |
| Show AddrInfoFlag | |
| Show NameInfoFlag | |
| Show Family | |
| Show SocketType | |
| Show Socket | |
| Show NullError | |
| Show InvalidAccess | |
| Show ResourceCleanupException | |
| Show Encoding | |
| Show String | |
| Show ASCII7_Invalid | |
| Show ISO_8859_1_Invalid | |
| Show UTF16_Invalid | |
| Show UTF32_Invalid | |
| Show FileSize | |
| Show CryptoError | |
| Show Curve_Edwards25519 | |
| Show Curve_P256R1 | |
| Show Curve_P384R1 | |
| Show Curve_P521R1 | |
| Show Curve_X25519 | |
| Show Curve_X448 | |
| Show Blake2b_160 | |
| Show Blake2b_224 | |
| Show Blake2b_256 | |
| Show Blake2b_384 | |
| Show Blake2b_512 | |
| Show Blake2bp_512 | |
| Show Blake2s_160 | |
| Show Blake2s_224 | |
| Show Blake2s_256 | |
| Show Blake2sp_224 | |
| Show Blake2sp_256 | |
| Show Keccak_224 | |
| Show Keccak_256 | |
| Show Keccak_384 | |
| Show Keccak_512 | |
| Show MD2 | |
| Show MD4 | |
| Show MD5 | |
| Show RIPEMD160 | |
| Show SHA1 | |
| Show SHA224 | |
| Show SHA256 | |
| Show SHA3_224 | |
| Show SHA3_256 | |
| Show SHA3_384 | |
| Show SHA3_512 | |
| Show SHA384 | |
| Show SHA512 | |
| Show SHA512t_224 | |
| Show SHA512t_256 | |
| Show Skein256_224 | |
| Show Skein256_256 | |
| Show Skein512_224 | |
| Show Skein512_256 | |
| Show Skein512_384 | |
| Show Skein512_512 | |
| Show Tiger | |
| Show Whirlpool | |
| Show DotNetTime | |
| Show Options | |
| Show SumEncoding | |
| Show StdGen | |
| Show UUID | |
| Show UnpackedUUID | |
| Show ConnHost | |
| Show ConnKey | |
| Show HttpExceptionContentWrapper | |
| Show StatusHeaders | |
| Show SHA1 Source # | |
| Show Hash Source # | |
| Show Number | |
| Show MCalendarTime Source # | |
Defined in Darcs.Util.IsoDate Methods showsPrec :: Int -> MCalendarTime -> ShowS # show :: MCalendarTime -> String # showList :: [MCalendarTime] -> ShowS # | |
| Show SomeNat | |
| Show SetupTermError | |
| Show BlockReason | |
| Show ThreadStatus | |
| Show CmdSpec | |
| Show CreateProcess | |
| Show StdStream | |
| Show ExecException Source # | |
Defined in Darcs.Util.Exec Methods showsPrec :: Int -> ExecException -> ShowS # show :: ExecException -> String # showList :: [ExecException] -> ShowS # | |
| Show Redirect Source # | |
| Show CompOption | |
| Show ExecOption | |
| Show DoPa | |
| Show Action | |
| Show DFA | |
| Show DT | |
| Show GroupInfo | |
| Show Instructions | |
| Show OP | |
| Show Orbits | |
| Show QNFA | |
| Show QT | |
| Show TagTask | |
| Show TagUpdate | |
| Show WhichTest | |
| Show WinEmpty | |
| Show BSWrapper Source # | |
| Show SshSettings Source # | |
Defined in Darcs.Util.Ssh Methods showsPrec :: Int -> SshSettings -> ShowS # show :: SshSettings -> String # showList :: [SshSettings] -> ShowS # | |
| Show AnchoredPath Source # | |
Defined in Darcs.Util.Path Methods showsPrec :: Int -> AnchoredPath -> ShowS # show :: AnchoredPath -> String # showList :: [AnchoredPath] -> ShowS # | |
| Show Name Source # | |
| Show AbsoluteOrRemotePath Source # | |
Defined in Darcs.Util.Path Methods showsPrec :: Int -> AbsoluteOrRemotePath -> ShowS # show :: AbsoluteOrRemotePath -> String # showList :: [AbsoluteOrRemotePath] -> ShowS # | |
| Show AbsolutePathOrStd Source # | |
Defined in Darcs.Util.Path Methods showsPrec :: Int -> AbsolutePathOrStd -> ShowS # show :: AbsolutePathOrStd -> String # showList :: [AbsolutePathOrStd] -> ShowS # | |
| Show AbsolutePath Source # | |
Defined in Darcs.Util.Path Methods showsPrec :: Int -> AbsolutePath -> ShowS # show :: AbsolutePath -> String # showList :: [AbsolutePath] -> ShowS # | |
| Show SubPath Source # | |
| Show ItemType Source # | |
| Show RepoFormat Source # | |
Defined in Darcs.Repository.Format Methods showsPrec :: Int -> RepoFormat -> ShowS # show :: RepoFormat -> String # showList :: [RepoFormat] -> ShowS # | |
| Show RepoProperty Source # | |
Defined in Darcs.Repository.Format Methods showsPrec :: Int -> RepoProperty -> ShowS # show :: RepoProperty -> String # showList :: [RepoProperty] -> ShowS # | |
| Show Cache Source # | |
| Show CacheLoc Source # | |
| Show CacheType Source # | |
| Show WritableOrNot Source # | |
Defined in Darcs.Repository.Cache Methods showsPrec :: Int -> WritableOrNot -> ShowS # show :: WritableOrNot -> String # showList :: [WritableOrNot] -> ShowS # | |
| Show FileType | |
| Show DarcsFlag Source # | |
| Show Location Source # | |
| Show UUID Source # | |
| Show PatchId Source # | |
| Show FileId Source # | |
| Show PatchInfo Source # | |
| Show Inventory Source # | |
| Show PristineHash Source # | |
Defined in Darcs.Repository.Inventory Methods showsPrec :: Int -> PristineHash -> ShowS # show :: PristineHash -> String # showList :: [PristineHash] -> ShowS # | |
| Show PatchHash Source # | |
| Show InventoryHash Source # | |
Defined in Darcs.Repository.Inventory Methods showsPrec :: Int -> InventoryHash -> ShowS # show :: InventoryHash -> String # showList :: [InventoryHash] -> ShowS # | |
| Show ConflictState Source # | |
Defined in Darcs.Patch.Summary Methods showsPrec :: Int -> ConflictState -> ShowS # show :: ConflictState -> String # showList :: [ConflictState] -> ShowS # | |
| Show PristineType Source # | |
Defined in Darcs.Repository.InternalTypes Methods showsPrec :: Int -> PristineType -> ShowS # show :: PristineType -> String # showList :: [PristineType] -> ShowS # | |
| Show MatchFlag Source # | |
| Show GzcrcsAction Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> GzcrcsAction -> ShowS # show :: GzcrcsAction -> String # showList :: [GzcrcsAction] -> ShowS # | |
| Show TestStrategy Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> TestStrategy -> ShowS # show :: TestStrategy -> String # showList :: [TestStrategy] -> ShowS # | |
| Show ChangesFormat Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> ChangesFormat -> ShowS # show :: ChangesFormat -> String # showList :: [ChangesFormat] -> ShowS # | |
| Show WithSummary Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> WithSummary -> ShowS # show :: WithSummary -> String # showList :: [WithSummary] -> ShowS # | |
| Show Output Source # | |
| Show Verify Source # | |
| Show Sign Source # | |
| Show ExternalDiff Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> ExternalDiff -> ShowS # show :: ExternalDiff -> String # showList :: [ExternalDiff] -> ShowS # | |
| Show WithContext Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> WithContext -> ShowS # show :: WithContext -> String # showList :: [WithContext] -> ShowS # | |
| Show AskLongComment Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> AskLongComment -> ShowS # show :: AskLongComment -> String # showList :: [AskLongComment] -> ShowS # | |
| Show RepoCombinator Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> RepoCombinator -> ShowS # show :: RepoCombinator -> String # showList :: [RepoCombinator] -> ShowS # | |
| Show SelectDeps Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> SelectDeps -> ShowS # show :: SelectDeps -> String # showList :: [SelectDeps] -> ShowS # | |
| Show XmlOutput Source # | |
| Show StdCmdAction Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> StdCmdAction -> ShowS # show :: StdCmdAction -> String # showList :: [StdCmdAction] -> ShowS # | |
| Show RootAction Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> RootAction -> ShowS # show :: RootAction -> String # showList :: [RootAction] -> ShowS # | |
| Show EnumPatches Source # | |
Defined in Darcs.UI.Options.All Methods showsPrec :: Int -> EnumPatches -> ShowS # show :: EnumPatches -> String # showList :: [EnumPatches] -> ShowS # | |
| Show PortNumber | |
| Show FormatError | |
| Show Entry | |
| Show EntryContent | |
| Show Format | |
| Show LinkTarget | |
| Show Ownership | |
| Show TarPath | |
| Show PrimPatchId Source # | |
Defined in Darcs.Patch.Prim.Named Methods showsPrec :: Int -> PrimPatchId -> ShowS # show :: PrimPatchId -> String # showList :: [PrimPatchId] -> ShowS # | |
| Show WhichChanges Source # | |
Defined in Darcs.UI.SelectChanges Methods showsPrec :: Int -> WhichChanges -> ShowS # show :: WhichChanges -> String # showList :: [WhichChanges] -> ShowS # | |
| Show HotLink | |
| Show Html | |
| Show HtmlAttr | |
| Show HtmlTable | |
| Show Archive | |
| Show CompressionMethod | |
| Show EncryptionMethod | |
| Show Entry | |
| Show ZipException | |
| Show ZipOption | |
| Show MSDOSDateTime | |
| Show PKWAREVerificationType | |
| Show CodePoint | |
| Show DecoderState | |
| Show Greediness | |
| () :=> (Show Bool) | |
Defined in Data.Constraint | |
| () :=> (Show Char) | |
Defined in Data.Constraint | |
| () :=> (Show Int) | |
Defined in Data.Constraint | |
| () :=> (Show Natural) | |
Defined in Data.Constraint | |
| () :=> (Show Ordering) | |
Defined in Data.Constraint | |
| () :=> (Show Word) | |
Defined in Data.Constraint | |
| () :=> (Show ()) | |
Defined in Data.Constraint | |
| () :=> (Show (a :- b)) | |
Defined in Data.Constraint | |
| () :=> (Show (Dict a)) | |
Defined in Data.Constraint | |
| Class () (Show a) | |
Defined in Data.Constraint | |
| Show a => Show [a] | |
| Show a => Show (Maybe a) | |
| Show a => Show (Ratio a) | |
| Show (Ptr a) | |
| Show (FunPtr a) | |
| Show p => Show (Par1 p) | |
| Show a => Show (ZipList a) | |
| Show a => Show (First a) | |
| Show a => Show (Last a) | |
| Show a => Show (Dual a) | |
| Show a => Show (Product a) | |
| Show a => Show (Sum a) | |
| Show a => Show (NonEmpty a) | |
| Show a => Show (First a) | |
| Show a => Show (Last a) | |
| Show a => Show (Max a) | |
| Show a => Show (Min a) | |
| Show a => Show (Option a) | |
| Show m => Show (WrappedMonoid m) | |
| Show a => Show (Identity a) | |
| Show a => Show (Down a) | |
| Show (ForeignPtr a) | |
| Show a => Show (Decoder a) | |
| Show a => Show (Set a) | |
| Show a => Show (Hashed a) | |
| Show a => Show (IntMap a) | |
| Show a => Show (Seq a) | |
| Show a => Show (ViewL a) | |
| Show a => Show (ViewR a) | |
| Show a => Show (Tree a) | |
| Show a => Show (Complex a) | |
| Show a => Show (Vector a) | |
| Show a => Show (Array a) | |
| (Show a, Prim a) => Show (Vector a) | |
| (Show a, Prim a) => Show (PrimArray a) | |
| Show a => Show (SmallArray a) | |
| Show a => Show (CryptoFailable a) | |
| Show mono => Show (NonNull mono) | |
| Show a => Show (Flush a) | |
| Show body => Show (Response body) | |
| Show a => Show (Result a) | |
| Show s => Show (CI s) | |
| (PrimType ty, Show ty) => Show (UArray ty) | |
| Show (Offset ty) | |
| Show (CountOf ty) | |
| (PrimType ty, Show ty) => Show (Block ty) | |
| Show a => Show (NonEmpty a) | |
| Show (Bits n) | |
| Show a => Show (HashSet a) | |
| (Show a, Storable a) => Show (Vector a) | |
| Show (Zn n) | |
| Show (Zn64 n) | |
| Show a => Show (ExitCase a) | |
| Show (Blake2b bitlen) | |
| Show (Blake2bp bitlen) | |
| Show (Blake2s bitlen) | |
| Show (Blake2sp bitlen) | |
| Show (Digest a) | |
| Show (SHAKE128 bitlen) | |
| Show (SHAKE256 bitlen) | |
| Show body => Show (HistoriedResponse body) | |
| Show a => Show (IResult a) | |
| Show1 f => Show (Fix f) | |
| (Functor f, Show1 f) => Show (Mu f) | |
| (Functor f, Show1 f) => Show (Nu f) | |
| Show a => Show (DNonEmpty a) | |
| Show a => Show (DList a) | |
| Show g => Show (StateGen g) | |
| Show g => Show (AtomicGen g) | |
| Show g => Show (IOGen g) | |
| Show g => Show (STGen g) | |
| Show a => Show (Maybe a) | |
| Show (Dict a) | |
| Show2 a => Show (Sealed2 a) Source # | |
| Show1 a => Show (Sealed a) Source # | |
| Show a => Show (PatchMod a) Source # | |
| Show2 prim => Show (IsConflictedPrim prim) Source # | |
Defined in Darcs.Patch.Summary Methods showsPrec :: Int -> IsConflictedPrim prim -> ShowS # show :: IsConflictedPrim prim -> String # showList :: [IsConflictedPrim prim] -> ShowS # | |
| Show e => Show (Entries e) | |
| (Show a) :=> (Show (Complex a)) | |
Defined in Data.Constraint | |
| (Show a) :=> (Show [a]) | |
Defined in Data.Constraint | |
| (Show a) :=> (Show (Maybe a)) | |
Defined in Data.Constraint | |
| (Show a) :=> (Show (Identity a)) | |
Defined in Data.Constraint | |
| (Show a) :=> (Show (Const a b)) | |
Defined in Data.Constraint | |
| (Show a, Show b) => Show (Either a b) | |
| Show (V1 p) | |
| Show (U1 p) | |
| Show (TypeRep a) | |
| (Show a, Show b) => Show (a, b) | |
| (Show a, Show b) => Show (Arg a b) | |
| (Ix a, Show a, Show b) => Show (Array a b) | |
| Show (Proxy s) | |
| Show (ST s a) | |
| Show (EqCheck wA wB) Source # | |
| HasResolution a => Show (Fixed a) | |
| (Show k, Show a) => Show (Map k a) | |
| (Ix ix, Show ix, Show e, IArray UArray e) => Show (UArray ix e) | |
| (Show1 m, Show a) => Show (ListT m a) | |
| (Show1 m, Show a) => Show (MaybeT m a) | |
| (Show i, Show r) => Show (IResult i r) | |
| (Show k, Show v) => Show (HashMap k v) | |
| (Show a, Show b) => Show (Either a b) | |
| (Show a, Show b) => Show (These a b) | |
| (Show a, Show b) => Show (These a b) | |
| (Show a, Show b) => Show (Pair a b) | |
| Show (a :- b) | |
| Show2 p => Show (Contexted p wX) Source # | |
| Show (DirPatchType wX wY) Source # | |
Defined in Darcs.Patch.Prim.V1.Show Methods showsPrec :: Int -> DirPatchType wX wY -> ShowS # show :: DirPatchType wX wY -> String # showList :: [DirPatchType wX wY] -> ShowS # | |
| Show (FilePatchType wX wY) Source # | |
Defined in Darcs.Patch.Prim.V1.Show Methods showsPrec :: Int -> FilePatchType wX wY -> ShowS # show :: FilePatchType wX wY -> String # showList :: [FilePatchType wX wY] -> ShowS # | |
| Show (Prim wX wY) Source # | |
| Show (Prim wX wY) Source # | |
| Show (HunkMove wX wY) Source # | |
| Show (Hunk wX wY) Source # | |
| (Show2 p, Show2 (PrimOf p)) => Show (Non p wX) Source # | |
| Show (RebaseName wX wY) Source # | |
Defined in Darcs.Patch.Rebase.Name Methods showsPrec :: Int -> RebaseName wX wY -> ShowS # show :: RebaseName wX wY -> String # showList :: [RebaseName wX wY] -> ShowS # | |
| Show (Prim x y) Source # | |
| Show (Prim x y) Source # | |
| (Integral a, Show a) :=> (Show (Ratio a)) | |
Defined in Data.Constraint | |
| (Show a, Show b) :=> (Show (a, b)) | |
Defined in Data.Constraint | |
| (Show a, Show b) :=> (Show (Either 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 a => Show (Const a b) | |
| Show (f a) => Show (Ap f a) | |
| Show (f a) => Show (Alt f a) | |
| (Show e, Show1 m, Show a) => Show (ErrorT e m a) | |
| (Show1 f, Show a) => Show (IdentityT f a) | |
| (Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
| (Show w, Show1 m, Show a) => Show (WriterT w m a) | |
| (Show w, Show1 m, Show a) => Show (WriterT w m a) | |
| Show b => Show (Tagged s b) | |
| (Show1 f, Show1 g, Show a) => Show (These1 f g a) | |
| Show2 a => Show (RL a wX wZ) Source # | |
| Show2 a => Show (FL a wX wZ) Source # | |
| Show2 prim => Show (RepoPatchV1 prim wX wY) Source # | |
Defined in Darcs.Patch.V1.Core Methods showsPrec :: Int -> RepoPatchV1 prim wX wY -> ShowS # show :: RepoPatchV1 prim wX wY -> String # showList :: [RepoPatchV1 prim wX wY] -> ShowS # | |
| Show2 prim => Show (Unwound prim wX wY) Source # | |
| Show2 prim => Show (RepoPatchV2 prim wX wY) Source # | |
Defined in Darcs.Patch.V2.RepoPatch Methods showsPrec :: Int -> RepoPatchV2 prim wX wY -> ShowS # show :: RepoPatchV2 prim wX wY -> String # showList :: [RepoPatchV2 prim wX wY] -> ShowS # | |
| Show2 p => Show (Named p wX wY) Source # | |
| Show2 prim => Show (RebaseFixup prim wX wY) Source # | |
Defined in Darcs.Patch.Rebase.Fixup Methods showsPrec :: Int -> RebaseFixup prim wX wY -> ShowS # show :: RebaseFixup prim wX wY -> String # showList :: [RebaseFixup prim wX wY] -> ShowS # | |
| Show (a wX wY) => Show (Hopefully a wX wY) Source # | |
| Show2 prim => Show (RebaseChange prim wX wY) Source # | |
Defined in Darcs.Patch.Rebase.Change Methods showsPrec :: Int -> RebaseChange prim wX wY -> ShowS # show :: RebaseChange prim wX wY -> String # showList :: [RebaseChange prim wX wY] -> ShowS # | |
| (Show2 p, Show2 (PrimOf p)) => Show (RebaseItem p wX wY) Source # | |
Defined in Darcs.Patch.Rebase.Legacy.Item Methods showsPrec :: Int -> RebaseItem p wX wY -> ShowS # show :: RebaseItem p wX wY -> String # showList :: [RebaseItem p wX wY] -> ShowS # | |
| (Show2 p, Show2 (PrimOf p)) => Show (Suspended p wX wY) Source # | |
| Show c => Show (K1 i c p) | |
| (Show (f p), Show (g p)) => Show ((f :+: g) p) | |
| (Show (f p), Show (g p)) => Show ((f :*: g) p) | |
| (Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
| (Show1 f, Show1 g, Show a) => Show (Product f g a) | |
| (Show1 f, Show1 g, Show a) => Show (Sum f g a) | |
| (Show2 a, Show2 b) => Show ((a :/\: b) wX wY) Source # | |
| (Show2 a, Show2 b) => Show ((a :\/: b) wX wY) Source # | |
| (Show2 a, Show2 b) => Show ((a :> b) wX wY) Source # | |
| Show (p wA wB) => Show (PatchInfoAndG rt p wA wB) Source # | |
Defined in Darcs.Patch.PatchInfoAnd Methods showsPrec :: Int -> PatchInfoAndG rt p wA wB -> ShowS # show :: PatchInfoAndG rt p wA wB -> String # showList :: [PatchInfoAndG rt p wA wB] -> ShowS # | |
| Show2 p => Show (Tagged rt p wX wZ) Source # | |
| Show2 p => Show (PatchSet rt p wStart wY) Source # | |
| Show2 p => Show (WrappedNamed rt p wX wY) Source # | |
Defined in Darcs.Patch.Named.Wrapped Methods showsPrec :: Int -> WrappedNamed rt p wX wY -> ShowS # show :: WrappedNamed rt p wX wY -> String # showList :: [WrappedNamed rt p wX wY] -> ShowS # | |
| (Show2 p, Show name) => Show (PrimWithName name p wX wY) Source # | |
Defined in Darcs.Patch.Prim.WithName Methods showsPrec :: Int -> PrimWithName name p wX wY -> ShowS # show :: PrimWithName name p wX wY -> String # showList :: [PrimWithName name p wX wY] -> ShowS # | |
| (Show name, Show2 prim) => Show (RepoPatchV3 name prim wX wY) Source # | |
Defined in Darcs.Patch.V3.Core Methods showsPrec :: Int -> RepoPatchV3 name prim wX wY -> ShowS # show :: RepoPatchV3 name prim wX wY -> String # showList :: [RepoPatchV3 name prim wX wY] -> ShowS # | |
| Show (f p) => Show (M1 i c f p) | |
| Show (f (g p)) => Show ((f :.: g) p) | |
| (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
| (Show1 f, Show1 g, Show a) => Show (Compose f g a) | |
| Show (p b a) => Show (Flip p a b) | |
| Show (Repository rt p wRecordedstate wUnrecordedstate wTentativestate) Source # | |
Defined in Darcs.Repository.InternalTypes Methods showsPrec :: Int -> Repository rt p wRecordedstate wUnrecordedstate wTentativestate -> ShowS # show :: Repository rt p wRecordedstate wUnrecordedstate wTentativestate -> String # showList :: [Repository rt p wRecordedstate wUnrecordedstate wTentativestate] -> ShowS # | |
| (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
| (Show (f a b), Show (g a b)) => Show (Product f g a b) | |
| (Show (p a b), Show (q a b)) => Show (Sum p q a b) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
| Show (f (p a b)) => Show (Tannen f p a b) | |
| (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 (p (f a) (g b)) => Show (Biff p f g a b) | |
| (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) | |
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
class Foldable (t :: Type -> Type) where #
Methods
foldMap :: Monoid m => (a -> m) -> t a -> m #
foldr :: (a -> b -> b) -> b -> t a -> b #
foldl :: (b -> a -> b) -> b -> t a -> b #
foldr1 :: (a -> a -> a) -> t a -> a #
foldl1 :: (a -> a -> a) -> t a -> a #
elem :: Eq a => a -> t a -> Bool #
maximum :: Ord a => t a -> a #
Instances
| Foldable [] | |
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 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 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 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 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 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 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 Option | |
Defined in Data.Semigroup Methods fold :: Monoid m => Option m -> m foldMap :: Monoid m => (a -> m) -> Option a -> m # foldMap' :: Monoid m => (a -> m) -> Option a -> m foldr :: (a -> b -> b) -> b -> Option a -> b # foldr' :: (a -> b -> b) -> b -> Option a -> b foldl :: (b -> a -> b) -> b -> Option a -> b # foldl' :: (b -> a -> b) -> b -> Option a -> b foldr1 :: (a -> a -> a) -> Option a -> a # foldl1 :: (a -> a -> a) -> Option a -> a # toList :: Option a -> [a] elem :: Eq a => a -> Option a -> Bool # maximum :: Ord a => Option a -> a # minimum :: Ord a => Option 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 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 Set | |
Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
| Foldable Hashed | |
Defined in Data.Hashable.Class Methods fold :: Monoid m => Hashed m -> m foldMap :: Monoid m => (a -> m) -> Hashed a -> m # foldMap' :: Monoid m => (a -> m) -> Hashed a -> m foldr :: (a -> b -> b) -> b -> Hashed a -> b # foldr' :: (a -> b -> b) -> b -> Hashed a -> b foldl :: (b -> a -> b) -> b -> Hashed a -> b # foldl' :: (b -> a -> b) -> b -> Hashed a -> b foldr1 :: (a -> a -> a) -> Hashed a -> a # foldl1 :: (a -> a -> a) -> Hashed a -> a # toList :: Hashed a -> [a] elem :: Eq a => a -> Hashed a -> Bool # maximum :: Ord a => Hashed a -> a # minimum :: Ord a => Hashed a -> a # | |
| Foldable IntMap | |
Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # toList :: IntMap a -> [a] elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # minimum :: Ord a => IntMap a -> a # | |
| Foldable Digit | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldMap' :: Monoid m => (a -> m) -> Digit a -> m foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # toList :: Digit a -> [a] elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # minimum :: Ord a => Digit a -> a # | |
| Foldable Elem | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldMap' :: Monoid m => (a -> m) -> Elem a -> m foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # toList :: Elem a -> [a] elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # | |
| Foldable FingerTree | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # | |
| Foldable Node | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # toList :: Node a -> [a] elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
| Foldable Seq | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # | |
| Foldable ViewL | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # toList :: ViewL a -> [a] elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # minimum :: Ord a => ViewL a -> a # | |
| Foldable ViewR | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # toList :: ViewR a -> [a] elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # minimum :: Ord a => ViewR a -> a # | |
| Foldable Tree | |
Defined in Data.Tree Methods fold :: Monoid m => Tree m -> m foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldMap' :: Monoid m => (a -> m) -> Tree a -> m foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # toList :: Tree a -> [a] elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
| Foldable 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 Vector | |
Defined in Data.Vector Methods fold :: Monoid m => Vector m -> m foldMap :: Monoid m => (a -> m) -> Vector a -> m # foldMap' :: Monoid m => (a -> m) -> Vector a -> m foldr :: (a -> b -> b) -> b -> Vector a -> b # foldr' :: (a -> b -> b) -> b -> Vector a -> b foldl :: (b -> a -> b) -> b -> Vector a -> b # foldl' :: (b -> a -> b) -> b -> Vector a -> b foldr1 :: (a -> a -> a) -> Vector a -> a # foldl1 :: (a -> a -> a) -> Vector a -> a # toList :: Vector a -> [a] elem :: Eq a => a -> Vector a -> Bool # maximum :: Ord a => Vector a -> a # minimum :: Ord a => Vector a -> a # | |
| Foldable Array | |
Defined in Data.Primitive.Array Methods fold :: Monoid m => Array m -> m foldMap :: Monoid m => (a -> m) -> Array a -> m # foldMap' :: Monoid m => (a -> m) -> Array a -> m foldr :: (a -> b -> b) -> b -> Array a -> b # foldr' :: (a -> b -> b) -> b -> Array a -> b foldl :: (b -> a -> b) -> b -> Array a -> b # foldl' :: (b -> a -> b) -> b -> Array a -> b foldr1 :: (a -> a -> a) -> Array a -> a # foldl1 :: (a -> a -> a) -> Array a -> a # toList :: Array a -> [a] elem :: Eq a => a -> Array a -> Bool # maximum :: Ord a => Array a -> a # minimum :: Ord a => Array a -> a # | |
| Foldable SmallArray | |
Defined in Data.Primitive.SmallArray Methods fold :: Monoid m => SmallArray m -> m foldMap :: Monoid m => (a -> m) -> SmallArray a -> m # foldMap' :: Monoid m => (a -> m) -> SmallArray a -> m foldr :: (a -> b -> b) -> b -> SmallArray a -> b # foldr' :: (a -> b -> b) -> b -> SmallArray a -> b foldl :: (b -> a -> b) -> b -> SmallArray a -> b # foldl' :: (b -> a -> b) -> b -> SmallArray a -> b foldr1 :: (a -> a -> a) -> SmallArray a -> a # foldl1 :: (a -> a -> a) -> SmallArray a -> a # toList :: SmallArray a -> [a] null :: SmallArray a -> Bool # length :: SmallArray a -> Int # elem :: Eq a => a -> SmallArray a -> Bool # maximum :: Ord a => SmallArray a -> a # minimum :: Ord a => SmallArray a -> a # | |
| Foldable Response | |
Defined in Network.HTTP.Client.Types Methods fold :: Monoid m => Response m -> m foldMap :: Monoid m => (a -> m) -> Response a -> m # foldMap' :: Monoid m => (a -> m) -> Response a -> m foldr :: (a -> b -> b) -> b -> Response a -> b # foldr' :: (a -> b -> b) -> b -> Response a -> b foldl :: (b -> a -> b) -> b -> Response a -> b # foldl' :: (b -> a -> b) -> b -> Response a -> b foldr1 :: (a -> a -> a) -> Response a -> a # foldl1 :: (a -> a -> a) -> Response a -> a # toList :: Response a -> [a] elem :: Eq a => a -> Response a -> Bool # maximum :: Ord a => Response a -> a # minimum :: Ord a => Response a -> a # | |
| Foldable Result | |
Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => Result m -> m foldMap :: Monoid m => (a -> m) -> Result a -> m # foldMap' :: Monoid m => (a -> m) -> Result a -> m foldr :: (a -> b -> b) -> b -> Result a -> b # foldr' :: (a -> b -> b) -> b -> Result a -> b foldl :: (b -> a -> b) -> b -> Result a -> b # foldl' :: (b -> a -> b) -> b -> Result a -> b foldr1 :: (a -> a -> a) -> Result a -> a # foldl1 :: (a -> a -> a) -> Result a -> a # toList :: Result a -> [a] elem :: Eq a => a -> Result a -> Bool # maximum :: Ord a => Result a -> a # minimum :: Ord a => Result a -> a # | |
| Foldable HashSet | |
Defined in Data.HashSet.Internal Methods fold :: Monoid m => HashSet m -> m foldMap :: Monoid m => (a -> m) -> HashSet a -> m # foldMap' :: Monoid m => (a -> m) -> HashSet a -> m foldr :: (a -> b -> b) -> b -> HashSet a -> b # foldr' :: (a -> b -> b) -> b -> HashSet a -> b foldl :: (b -> a -> b) -> b -> HashSet a -> b # foldl' :: (b -> a -> b) -> b -> HashSet a -> b foldr1 :: (a -> a -> a) -> HashSet a -> a # foldl1 :: (a -> a -> a) -> HashSet a -> a # toList :: HashSet a -> [a] elem :: Eq a => a -> HashSet a -> Bool # maximum :: Ord a => HashSet a -> a # minimum :: Ord a => HashSet a -> a # | |
| Foldable HistoriedResponse | |
Defined in Network.HTTP.Client Methods fold :: Monoid m => HistoriedResponse m -> m foldMap :: Monoid m => (a -> m) -> HistoriedResponse a -> m # foldMap' :: Monoid m => (a -> m) -> HistoriedResponse a -> m foldr :: (a -> b -> b) -> b -> HistoriedResponse a -> b # foldr' :: (a -> b -> b) -> b -> HistoriedResponse a -> b foldl :: (b -> a -> b) -> b -> HistoriedResponse a -> b # foldl' :: (b -> a -> b) -> b -> HistoriedResponse a -> b foldr1 :: (a -> a -> a) -> HistoriedResponse a -> a # foldl1 :: (a -> a -> a) -> HistoriedResponse a -> a # toList :: HistoriedResponse a -> [a] null :: HistoriedResponse a -> Bool # length :: HistoriedResponse a -> Int # elem :: Eq a => a -> HistoriedResponse a -> Bool # maximum :: Ord a => HistoriedResponse a -> a # minimum :: Ord a => HistoriedResponse a -> a # | |
| Foldable IResult | |
Defined in Data.Aeson.Types.Internal Methods fold :: Monoid m => IResult m -> m foldMap :: Monoid m => (a -> m) -> IResult a -> m # foldMap' :: Monoid m => (a -> m) -> IResult a -> m foldr :: (a -> b -> b) -> b -> IResult a -> b # foldr' :: (a -> b -> b) -> b -> IResult a -> b foldl :: (b -> a -> b) -> b -> IResult a -> b # foldl' :: (b -> a -> b) -> b -> IResult a -> b foldr1 :: (a -> a -> a) -> IResult a -> a # foldl1 :: (a -> a -> a) -> IResult a -> a # toList :: IResult a -> [a] elem :: Eq a => a -> IResult a -> Bool # maximum :: Ord a => IResult a -> a # minimum :: Ord a => IResult a -> a # | |
| Foldable DNonEmpty | |
Defined in Data.DList.DNonEmpty.Internal Methods fold :: Monoid m => DNonEmpty m -> m foldMap :: Monoid m => (a -> m) -> DNonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> DNonEmpty a -> m foldr :: (a -> b -> b) -> b -> DNonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> DNonEmpty a -> b foldl :: (b -> a -> b) -> b -> DNonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> DNonEmpty a -> b foldr1 :: (a -> a -> a) -> DNonEmpty a -> a # foldl1 :: (a -> a -> a) -> DNonEmpty a -> a # toList :: DNonEmpty a -> [a] length :: DNonEmpty a -> Int # elem :: Eq a => a -> DNonEmpty a -> Bool # maximum :: Ord a => DNonEmpty a -> a # minimum :: Ord a => DNonEmpty a -> a # | |
| Foldable DList | |
Defined in Data.DList.Internal Methods fold :: Monoid m => DList m -> m foldMap :: Monoid m => (a -> m) -> DList a -> m # foldMap' :: Monoid m => (a -> m) -> DList a -> m foldr :: (a -> b -> b) -> b -> DList a -> b # foldr' :: (a -> b -> b) -> b -> DList a -> b foldl :: (b -> a -> b) -> b -> DList a -> b # foldl' :: (b -> a -> b) -> b -> DList a -> b foldr1 :: (a -> a -> a) -> DList a -> a # foldl1 :: (a -> a -> a) -> DList a -> a # toList :: DList a -> [a] elem :: Eq a => a -> DList a -> Bool # maximum :: Ord a => DList a -> a # minimum :: Ord a => DList a -> a # | |
| Foldable Maybe | |
Defined in Data.Strict.Maybe 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 # toList :: Maybe a -> [a] elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe 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 (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 (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 ((,) 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 (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 (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 (Map k) | |
Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # toList :: Map k a -> [a] elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # minimum :: Ord a => Map k a -> a # | |
| Foldable f => Foldable (ListT f) | |
Defined in Control.Monad.Trans.List Methods fold :: Monoid m => ListT f m -> m foldMap :: Monoid m => (a -> m) -> ListT f a -> m # foldMap' :: Monoid m => (a -> m) -> ListT f a -> m foldr :: (a -> b -> b) -> b -> ListT f a -> b # foldr' :: (a -> b -> b) -> b -> ListT f a -> b foldl :: (b -> a -> b) -> b -> ListT f a -> b # foldl' :: (b -> a -> b) -> b -> ListT f a -> b foldr1 :: (a -> a -> a) -> ListT f a -> a # foldl1 :: (a -> a -> a) -> ListT f a -> a # toList :: ListT f a -> [a] elem :: Eq a => a -> ListT f a -> Bool # maximum :: Ord a => ListT f a -> a # minimum :: Ord a => ListT f a -> a # | |
| Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
| MonoFoldable mono => Foldable (WrappedMono mono) | |
Defined in Data.MonoTraversable Methods fold :: Monoid m => WrappedMono mono m -> m foldMap :: Monoid m => (a -> m) -> WrappedMono mono a -> m # foldMap' :: Monoid m => (a -> m) -> WrappedMono mono a -> m foldr :: (a -> b -> b) -> b -> WrappedMono mono a -> b # foldr' :: (a -> b -> b) -> b -> WrappedMono mono a -> b foldl :: (b -> a -> b) -> b -> WrappedMono mono a -> b # foldl' :: (b -> a -> b) -> b -> WrappedMono mono a -> b foldr1 :: (a -> a -> a) -> WrappedMono mono a -> a # foldl1 :: (a -> a -> a) -> WrappedMono mono a -> a # toList :: WrappedMono mono a -> [a] null :: WrappedMono mono a -> Bool # length :: WrappedMono mono a -> Int # elem :: Eq a => a -> WrappedMono mono a -> Bool # maximum :: Ord a => WrappedMono mono a -> a # minimum :: Ord a => WrappedMono mono a -> a # | |
| Foldable f => Foldable (WrappedPoly f) | |
Defined in Data.MonoTraversable Methods fold :: Monoid m => WrappedPoly f m -> m foldMap :: Monoid m => (a -> m) -> WrappedPoly f a -> m # foldMap' :: Monoid m => (a -> m) -> WrappedPoly f a -> m foldr :: (a -> b -> b) -> b -> WrappedPoly f a -> b # foldr' :: (a -> b -> b) -> b -> WrappedPoly f a -> b foldl :: (b -> a -> b) -> b -> WrappedPoly f a -> b # foldl' :: (b -> a -> b) -> b -> WrappedPoly f a -> b foldr1 :: (a -> a -> a) -> WrappedPoly f a -> a # foldl1 :: (a -> a -> a) -> WrappedPoly f a -> a # toList :: WrappedPoly f a -> [a] null :: WrappedPoly f a -> Bool # length :: WrappedPoly f a -> Int # elem :: Eq a => a -> WrappedPoly f a -> Bool # maximum :: Ord a => WrappedPoly f a -> a # minimum :: Ord a => WrappedPoly f a -> a # | |
| Foldable (HashMap k) | |
Defined in Data.HashMap.Internal Methods fold :: Monoid m => HashMap k m -> m foldMap :: Monoid m => (a -> m) -> HashMap k a -> m # foldMap' :: Monoid m => (a -> m) -> HashMap k a -> m foldr :: (a -> b -> b) -> b -> HashMap k a -> b # foldr' :: (a -> b -> b) -> b -> HashMap k a -> b foldl :: (b -> a -> b) -> b -> HashMap k a -> b # foldl' :: (b -> a -> b) -> b -> HashMap k a -> b foldr1 :: (a -> a -> a) -> HashMap k a -> a # foldl1 :: (a -> a -> a) -> HashMap k a -> a # toList :: HashMap k a -> [a] length :: HashMap k a -> Int # elem :: Eq a => a -> HashMap k a -> Bool # maximum :: Ord a => HashMap k a -> a # minimum :: Ord a => HashMap k a -> a # | |
| Foldable (Either e) | |
Defined in Data.Strict.Either Methods fold :: Monoid m => Either e m -> m foldMap :: Monoid m => (a -> m) -> Either e a -> m # foldMap' :: Monoid m => (a -> m) -> Either e a -> m foldr :: (a -> b -> b) -> b -> Either e a -> b # foldr' :: (a -> b -> b) -> b -> Either e a -> b foldl :: (b -> a -> b) -> b -> Either e a -> b # foldl' :: (b -> a -> b) -> b -> Either e a -> b foldr1 :: (a -> a -> a) -> Either e a -> a # foldl1 :: (a -> a -> a) -> Either e a -> a # toList :: Either e a -> [a] elem :: Eq a => a -> Either e a -> Bool # maximum :: Ord a => Either e a -> a # minimum :: Ord a => Either e a -> a # | |
| Foldable (These a) | |
Defined in Data.Strict.These Methods fold :: Monoid m => These a m -> m foldMap :: Monoid m => (a0 -> m) -> These a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> These a a0 -> m foldr :: (a0 -> b -> b) -> b -> These a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> These a a0 -> b foldl :: (b -> a0 -> b) -> b -> These a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> These a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # toList :: These a a0 -> [a0] elem :: Eq a0 => a0 -> These a a0 -> Bool # maximum :: Ord a0 => These a a0 -> a0 # minimum :: Ord a0 => These a a0 -> a0 # | |
| Foldable (These a) | |
Defined in Data.These Methods fold :: Monoid m => These a m -> m foldMap :: Monoid m => (a0 -> m) -> These a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> These a a0 -> m foldr :: (a0 -> b -> b) -> b -> These a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> These a a0 -> b foldl :: (b -> a0 -> b) -> b -> These a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> These a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> These a a0 -> a0 # toList :: These a a0 -> [a0] elem :: Eq a0 => a0 -> These a a0 -> Bool # maximum :: Ord a0 => These a a0 -> a0 # minimum :: Ord a0 => These a a0 -> a0 # | |
| Foldable (Pair e) | |
Defined in Data.Strict.Tuple Methods fold :: Monoid m => Pair e m -> m foldMap :: Monoid m => (a -> m) -> Pair e a -> m # foldMap' :: Monoid m => (a -> m) -> Pair e a -> m foldr :: (a -> b -> b) -> b -> Pair e a -> b # foldr' :: (a -> b -> b) -> b -> Pair e a -> b foldl :: (b -> a -> b) -> b -> Pair e a -> b # foldl' :: (b -> a -> b) -> b -> Pair e a -> b foldr1 :: (a -> a -> a) -> Pair e a -> a # foldl1 :: (a -> a -> a) -> Pair e a -> a # toList :: Pair e a -> [a] elem :: Eq a => a -> Pair e a -> Bool # maximum :: Ord a => Pair e a -> a # minimum :: Ord a => Pair e 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 (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 (ErrorT e f) | |
Defined in Control.Monad.Trans.Error Methods fold :: Monoid m => ErrorT e f m -> m foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ErrorT e f a -> m foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b foldr1 :: (a -> a -> a) -> ErrorT e f a -> a # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a # toList :: ErrorT e f a -> [a] null :: ErrorT e f a -> Bool # length :: ErrorT e f a -> Int # elem :: Eq a => a -> ErrorT e f a -> Bool # maximum :: Ord a => ErrorT e f a -> a # minimum :: Ord a => ErrorT e f a -> a # | |
| Foldable f => Foldable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # | |
| Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
| Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Strict Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
| Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
| Foldable (Tagged s) | |
Defined in Data.Tagged Methods fold :: Monoid m => Tagged s m -> m foldMap :: Monoid m => (a -> m) -> Tagged s a -> m # foldMap' :: Monoid m => (a -> m) -> Tagged s a -> m foldr :: (a -> b -> b) -> b -> Tagged s a -> b # foldr' :: (a -> b -> b) -> b -> Tagged s a -> b foldl :: (b -> a -> b) -> b -> Tagged s a -> b # foldl' :: (b -> a -> b) -> b -> Tagged s a -> b foldr1 :: (a -> a -> a) -> Tagged s a -> a # foldl1 :: (a -> a -> a) -> Tagged s a -> a # toList :: Tagged s a -> [a] elem :: Eq a => a -> Tagged s a -> Bool # maximum :: Ord a => Tagged s a -> a # minimum :: Ord a => Tagged s a -> a # | |
| (Foldable f, Foldable g) => Foldable (These1 f g) | |
Defined in Data.Functor.These Methods fold :: Monoid m => These1 f g m -> m foldMap :: Monoid m => (a -> m) -> These1 f g a -> m # foldMap' :: Monoid m => (a -> m) -> These1 f g a -> m foldr :: (a -> b -> b) -> b -> These1 f g a -> b # foldr' :: (a -> b -> b) -> b -> These1 f g a -> b foldl :: (b -> a -> b) -> b -> These1 f g a -> b # foldl' :: (b -> a -> b) -> b -> These1 f g a -> b foldr1 :: (a -> a -> a) -> These1 f g a -> a # foldl1 :: (a -> a -> a) -> These1 f g a -> a # toList :: These1 f g a -> [a] null :: These1 f g a -> Bool # length :: These1 f g a -> Int # elem :: Eq a => a -> These1 f g a -> Bool # maximum :: Ord a => These1 f g a -> a # minimum :: Ord a => These1 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 (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 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 (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 # | |
| (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 (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 # | |
| Bifoldable p => Foldable (Flip p a) | |
Defined in Data.Bifunctor.Flip Methods fold :: Monoid m => Flip p a m -> m foldMap :: Monoid m => (a0 -> m) -> Flip p a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Flip p a a0 -> m foldr :: (a0 -> b -> b) -> b -> Flip p a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Flip p a a0 -> b foldl :: (b -> a0 -> b) -> b -> Flip p a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Flip p a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0 # toList :: Flip p a a0 -> [a0] length :: Flip p a a0 -> Int # elem :: Eq a0 => a0 -> Flip p a a0 -> Bool # maximum :: Ord a0 => Flip p a a0 -> a0 # minimum :: Ord a0 => Flip p a a0 -> a0 # | |
| (Foldable f, Bifoldable p) => Foldable (Tannen f p a) | |
Defined in Data.Bifunctor.Tannen Methods fold :: Monoid m => Tannen f p a m -> m foldMap :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m foldr :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b foldl :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0 # toList :: Tannen f p a a0 -> [a0] null :: Tannen f p a a0 -> Bool # length :: Tannen f p a a0 -> Int # elem :: Eq a0 => a0 -> Tannen f p a a0 -> Bool # maximum :: Ord a0 => Tannen f p a a0 -> a0 # minimum :: Ord a0 => Tannen f p a a0 -> a0 # | |
| (Bifoldable p, Foldable g) => Foldable (Biff p f g a) | |
Defined in Data.Bifunctor.Biff Methods fold :: Monoid m => Biff p f g a m -> m foldMap :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m foldr :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b foldl :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0 # toList :: Biff p f g a a0 -> [a0] null :: Biff p f g a a0 -> Bool # length :: Biff p f g a a0 -> Int # elem :: Eq a0 => a0 -> Biff p f g a a0 -> Bool # maximum :: Ord a0 => Biff p f g a a0 -> a0 # minimum :: Ord a0 => Biff p f g a a0 -> a0 # | |
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #
Methods
sequenceA :: Applicative f => t (f a) -> f (t a) #
Instances
| Traversable [] | |
Defined in Data.Traversable | |
| Traversable Maybe | |
| Traversable Par1 | |
Defined in Data.Traversable | |
| Traversable ZipList | |
Defined in Data.Traversable | |
| Traversable First | |
Defined in Data.Traversable | |
| Traversable Last | |
Defined in Data.Traversable | |
| 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 First | |
Defined in Data.Semigroup | |
| Traversable Last | |
Defined in Data.Semigroup | |
| Traversable Max | |
Defined in Data.Semigroup | |
| Traversable Min | |
Defined in Data.Semigroup | |
| Traversable Option | |
Defined in Data.Semigroup | |
| Traversable Identity | |
Defined in Data.Traversable | |
| Traversable Down | |
Defined in Data.Traversable | |
| Traversable IntMap | |
Defined in Data.IntMap.Internal | |
| Traversable Digit | |
Defined in Data.Sequence.Internal | |
| Traversable Elem | |
Defined in Data.Sequence.Internal | |
| Traversable FingerTree | |
Defined in Data.Sequence.Internal | |
| Traversable Node | |
Defined in Data.Sequence.Internal | |
| Traversable Seq | |
Defined in Data.Sequence.Internal | |
| Traversable ViewL | |
Defined in Data.Sequence.Internal | |
| Traversable ViewR | |
Defined in Data.Sequence.Internal | |
| Traversable Tree | |
| Traversable Complex | |
Defined in Data.Complex | |
| Traversable Vector | |
Defined in Data.Vector | |
| Traversable Array | |
Defined in Data.Primitive.Array | |
| Traversable SmallArray | |
Defined in Data.Primitive.SmallArray | |
| Traversable Response | |
Defined in Network.HTTP.Client.Types | |
| Traversable Result | |
Defined in Data.Aeson.Types.Internal | |
| Traversable HistoriedResponse | |
Defined in Network.HTTP.Client Methods traverse :: Applicative f => (a -> f b) -> HistoriedResponse a -> f (HistoriedResponse b) # sequenceA :: Applicative f => HistoriedResponse (f a) -> f (HistoriedResponse a) # mapM :: Monad m => (a -> m b) -> HistoriedResponse a -> m (HistoriedResponse b) # sequence :: Monad m => HistoriedResponse (m a) -> m (HistoriedResponse a) # | |
| Traversable IResult | |
Defined in Data.Aeson.Types.Internal | |
| Traversable DList | |
Defined in Data.DList.Internal | |
| Traversable Maybe | |
Defined in Data.Strict.Maybe | |
| Traversable (Either a) | |
Defined in Data.Traversable | |
| Traversable (V1 :: Type -> Type) | |
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 ((,) a) | |
Defined in Data.Traversable | |
| Traversable (Arg a) | |
Defined in Data.Semigroup | |
| Ix i => Traversable (Array i) | |
Defined in Data.Traversable | |
| Traversable (Proxy :: Type -> Type) | |
Defined in Data.Traversable | |
| Traversable (Map k) | |
Defined in Data.Map.Internal | |
| Traversable f => Traversable (ListT f) | |
Defined in Control.Monad.Trans.List | |
| Traversable f => Traversable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe | |
| Traversable (HashMap k) | |
Defined in Data.HashMap.Internal | |
| Traversable (Either e) | |
Defined in Data.Strict.Either | |
| Traversable (These a) | |
Defined in Data.Strict.These | |
| Traversable (These a) | |
Defined in Data.These | |
| Traversable (Pair e) | |
Defined in Data.Strict.Tuple | |
| Traversable f => Traversable (Rec1 f) | |
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 (ErrorT e f) | |
Defined in Control.Monad.Trans.Error | |
| Traversable f => Traversable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity | |
| Traversable f => Traversable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except | |
| Traversable f => Traversable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| Traversable f => Traversable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| Traversable (Tagged s) | |
Defined in Data.Tagged | |
| (Traversable f, Traversable g) => Traversable (These1 f g) | |
Defined in Data.Functor.These | |
| Traversable (K1 i c :: Type -> Type) | |
Defined in Data.Traversable | |
| (Traversable f, Traversable g) => Traversable (f :+: g) | |
Defined in Data.Traversable | |
| (Traversable f, Traversable g) => Traversable (f :*: g) | |
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 (M1 i c f) | |
Defined in Data.Traversable | |
| (Traversable f, Traversable g) => Traversable (f :.: g) | |
Defined in Data.Traversable | |
| (Traversable f, Traversable g) => Traversable (Compose f g) | |
Defined in Data.Functor.Compose | |
| Bitraversable p => Traversable (Flip p a) | |
Defined in Data.Bifunctor.Flip | |
| (Traversable f, Bitraversable p) => Traversable (Tannen f p a) | |
Defined in Data.Bifunctor.Tannen Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Tannen f p a a0 -> f0 (Tannen f p a b) # sequenceA :: Applicative f0 => Tannen f p a (f0 a0) -> f0 (Tannen f p a a0) # mapM :: Monad m => (a0 -> m b) -> Tannen f p a a0 -> m (Tannen f p a b) # sequence :: Monad m => Tannen f p a (m a0) -> m (Tannen f p a a0) # | |
| (Bitraversable p, Traversable g) => Traversable (Biff p f g a) | |
Defined in Data.Bifunctor.Biff Methods traverse :: Applicative f0 => (a0 -> f0 b) -> Biff p f g a a0 -> f0 (Biff p f g a b) # sequenceA :: Applicative f0 => Biff p f g a (f0 a0) -> f0 (Biff p f g a a0) # mapM :: Monad m => (a0 -> m b) -> Biff p f g a a0 -> m (Biff p f g a b) # sequence :: Monad m => Biff p f g a (m a0) -> m (Biff p f g a a0) # | |
Instances
| Bounded Bool | |
| Enum Bool | |
| Eq Bool | |
| Ord Bool | |
| Read Bool | |
| Show Bool | |
| Ix Bool | |
| Generic Bool | |
| Binary Bool | |
| Bits Bool | |
Defined in Data.Bits | |
| FiniteBits Bool | |
Defined in Data.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |
| Storable Bool | |
Defined in Foreign.Storable | |
| Hashable Bool | |
Defined in Data.Hashable.Class | |
| SingKind Bool | |
Defined in GHC.Generics Associated Types type DemoteRep Bool | |
| Unbox Bool | |
Defined in Data.Vector.Unboxed.Base | |
| BitOps Bool | |
| FiniteBitsOps Bool | |
| Uniform Bool | |
Defined in System.Random.Internal | |
| UniformRange Bool | |
Defined in System.Random.Internal | |
| Lift Bool | |
| IArray UArray Bool | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Bool -> (i, i) numElements :: Ix i => UArray i Bool -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Bool)] -> UArray i Bool unsafeAt :: Ix i => UArray i Bool -> Int -> Bool unsafeReplace :: Ix i => UArray i Bool -> [(Int, Bool)] -> UArray i Bool unsafeAccum :: Ix i => (Bool -> e' -> Bool) -> UArray i Bool -> [(Int, e')] -> UArray i Bool unsafeAccumArray :: Ix i => (Bool -> e' -> Bool) -> Bool -> (i, i) -> [(Int, e')] -> UArray i Bool | |
| SingI 'False | |
Defined in GHC.Generics | |
| SingI 'True | |
Defined in GHC.Generics | |
| Vector Vector Bool | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) basicLength :: Vector Bool -> Int basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () | |
| MVector MVector Bool | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) | |
| () :=> (Bounded Bool) | |
Defined in Data.Constraint | |
| () :=> (Enum Bool) | |
Defined in Data.Constraint | |
| () :=> (Eq Bool) | |
Defined in Data.Constraint | |
| () :=> (Ord Bool) | |
Defined in Data.Constraint | |
| () :=> (Read Bool) | |
Defined in Data.Constraint | |
| () :=> (Show Bool) | |
Defined in Data.Constraint | |
| () :=> (Bits Bool) | |
Defined in Data.Constraint | |
| MArray (STUArray s) Bool (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Bool -> ST s (i, i) getNumElements :: Ix i => STUArray s i Bool -> ST s Int newArray :: Ix i => (i, i) -> Bool -> ST s (STUArray s i Bool) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Bool) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Bool) unsafeRead :: Ix i => STUArray s i Bool -> Int -> ST s Bool unsafeWrite :: Ix i => STUArray s i Bool -> Int -> Bool -> ST s () | |
| type Rep Bool | |
Defined in GHC.Generics | |
| type DemoteRep Bool | |
Defined in GHC.Generics | |
| data Sing (a :: Bool) | |
| newtype Vector Bool | |
Defined in Data.Vector.Unboxed.Base | |
| newtype MVector s Bool | |
Defined in Data.Vector.Unboxed.Base | |
Instances
| Bounded Char | |
| Enum Char | |
| Eq Char | |
| Ord Char | |
| Read Char | |
| Show Char | |
| Ix Char | |
| Binary Char | |
| PrintfArg Char | |
Defined in Text.Printf | |
| ErrorList Char | |
Defined in Control.Monad.Trans.Error | |
| Storable Char | |
Defined in Foreign.Storable | |
| Hashable Char | |
Defined in Data.Hashable.Class | |
| Unbox Char | |
Defined in Data.Vector.Unboxed.Base | |
| Prim Char | |
Defined in Data.Primitive.Types Methods alignment# :: Char -> Int# indexByteArray# :: ByteArray# -> Int# -> Char readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Char #) writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Char readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Char #) writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s | |
| PrimType Char | |
Defined in Basement.PrimType Associated Types type PrimSize Char :: Nat Methods primSizeInBytes :: Proxy Char -> CountOf Word8 primShiftToBytes :: Proxy Char -> Int primBaUIndex :: ByteArray# -> Offset Char -> Char primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> prim Char primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Char -> Char -> prim () primAddrIndex :: Addr# -> Offset Char -> Char primAddrRead :: PrimMonad prim => Addr# -> Offset Char -> prim Char primAddrWrite :: PrimMonad prim => Addr# -> Offset Char -> Char -> prim () | |
| Subtractive Char | |
| PrimMemoryComparable Char | |
Defined in Basement.PrimType | |
| Uniform Char | |
Defined in System.Random.Internal | |
| UniformRange Char | |
Defined in System.Random.Internal | |
| FoldCase Char | |
Defined in Data.CaseInsensitive.Internal | |
| IsChar Char | |
| Extract String | |
| HTML Char | |
Defined in Text.Html | |
| Lift Char | |
| IArray UArray Char | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Char -> (i, i) numElements :: Ix i => UArray i Char -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Char)] -> UArray i Char unsafeAt :: Ix i => UArray i Char -> Int -> Char unsafeReplace :: Ix i => UArray i Char -> [(Int, Char)] -> UArray i Char unsafeAccum :: Ix i => (Char -> e' -> Char) -> UArray i Char -> [(Int, e')] -> UArray i Char unsafeAccumArray :: Ix i => (Char -> e' -> Char) -> Char -> (i, i) -> [(Int, e')] -> UArray i Char | |
| Vector Vector Char | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) basicLength :: Vector Char -> Int basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () | |
| MVector MVector Char | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char basicOverlaps :: MVector s Char -> MVector s Char -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) | |
| Monad m => Stream ByteString m Char | |
Defined in Text.Parsec.Prim | |
| Monad m => Stream Text m Char | |
Defined in Text.Parsec.Prim | |
| Monad m => Stream ByteString m Char | |
Defined in Text.Parsec.Prim | |
| Monad m => Stream Text m Char | |
Defined in Text.Parsec.Prim | |
| () :=> (Bounded Char) | |
Defined in Data.Constraint | |
| () :=> (Enum Char) | |
Defined in Data.Constraint | |
| () :=> (Ord Char) | |
Defined in Data.Constraint | |
| () :=> (Read Char) | |
Defined in Data.Constraint | |
| () :=> (Show Char) | |
Defined in Data.Constraint | |
| Generic1 (URec Char :: k -> Type) | |
| Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # | |
| Traversable (UChar :: Type -> Type) | |
Defined in Data.Traversable | |
| OutputCap [Char] | |
Defined in System.Console.Terminfo.Base | |
| TermStr [Char] | |
Defined in System.Console.Terminfo.Base | |
| MArray (STUArray s) Char (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Char -> ST s (i, i) getNumElements :: Ix i => STUArray s i Char -> ST s Int newArray :: Ix i => (i, i) -> Char -> ST s (STUArray s i Char) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Char) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Char) unsafeRead :: Ix i => STUArray s i Char -> Int -> ST s Char unsafeWrite :: Ix i => STUArray s i Char -> Int -> Char -> ST s () | |
| Functor (URec Char :: Type -> Type) | |
| Eq (URec Char p) | |
| Ord (URec Char p) | |
Defined in GHC.Generics | |
| Show (URec Char p) | |
| Generic (URec Char p) | |
| newtype Vector Char | |
Defined in Data.Vector.Unboxed.Base | |
| type Difference Char | |
Defined in Basement.Numerical.Subtractive | |
| type NatNumMaxBound Char | |
Defined in Basement.Nat type NatNumMaxBound Char = 1114111 | |
| type PrimSize Char | |
Defined in Basement.PrimType type PrimSize Char = 4 | |
| data URec Char (p :: k) | |
Defined in GHC.Generics | |
| newtype MVector s Char | |
Defined in Data.Vector.Unboxed.Base | |
| type Rep1 (URec Char :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Char p) | |
Defined in GHC.Generics | |
Instances
| Eq Double | |
| Floating Double | |
| Ord Double | |
| Read 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 # | |
| Binary Double | |
| PrintfArg Double | |
Defined in Text.Printf | |
| Storable Double | |
Defined in Foreign.Storable | |
| Hashable Double | |
Defined in Data.Hashable.Class | |
| Unbox Double | |
Defined in Data.Vector.Unboxed.Base | |
| Prim Double | |
Defined in Data.Primitive.Types Methods alignment# :: Double -> Int# indexByteArray# :: ByteArray# -> Int# -> Double readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Double #) writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Double readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Double #) writeOffAddr# :: Addr# -> Int# -> Double -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Double -> State# s -> State# s | |
| PrimType Double | |
Defined in Basement.PrimType Associated Types type PrimSize Double :: Nat Methods primSizeInBytes :: Proxy Double -> CountOf Word8 primShiftToBytes :: Proxy Double -> Int primBaUIndex :: ByteArray# -> Offset Double -> Double primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> prim Double primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Double -> Double -> prim () primAddrIndex :: Addr# -> Offset Double -> Double primAddrRead :: PrimMonad prim => Addr# -> Offset Double -> prim Double primAddrWrite :: PrimMonad prim => Addr# -> Offset Double -> Double -> prim () | |
| Subtractive Double | |
| UniformRange Double | |
Defined in System.Random.Internal | |
| Lift Double | |
| IArray UArray Double | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Double -> (i, i) numElements :: Ix i => UArray i Double -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Double)] -> UArray i Double unsafeAt :: Ix i => UArray i Double -> Int -> Double unsafeReplace :: Ix i => UArray i Double -> [(Int, Double)] -> UArray i Double unsafeAccum :: Ix i => (Double -> e' -> Double) -> UArray i Double -> [(Int, e')] -> UArray i Double unsafeAccumArray :: Ix i => (Double -> e' -> Double) -> Double -> (i, i) -> [(Int, e')] -> UArray i Double | |
| Vector Vector Double | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) basicLength :: Vector Double -> Int basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () | |
| MVector MVector Double | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double basicOverlaps :: MVector s Double -> MVector s Double -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double) basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double) | |
| () :=> (Enum Double) | |
Defined in Data.Constraint | |
| () :=> (Eq Double) | |
Defined in Data.Constraint | |
| () :=> (Floating Double) | |
Defined in Data.Constraint | |
| () :=> (Fractional Double) | |
Defined in Data.Constraint Methods ins :: () :- Fractional Double | |
| () :=> (Num Double) | |
Defined in Data.Constraint | |
| () :=> (Ord Double) | |
Defined in Data.Constraint | |
| () :=> (Real Double) | |
Defined in Data.Constraint | |
| () :=> (RealFloat Double) | |
Defined in Data.Constraint | |
| () :=> (RealFrac Double) | |
Defined in Data.Constraint | |
| Generic1 (URec Double :: k -> Type) | |
| Foldable (UDouble :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
| Traversable (UDouble :: Type -> Type) | |
Defined in Data.Traversable | |
| MArray (STUArray s) Double (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Double -> ST s (i, i) getNumElements :: Ix i => STUArray s i Double -> ST s Int newArray :: Ix i => (i, i) -> Double -> ST s (STUArray s i Double) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) unsafeRead :: Ix i => STUArray s i Double -> Int -> ST s Double unsafeWrite :: Ix i => STUArray s i Double -> Int -> Double -> ST s () | |
| Functor (URec Double :: Type -> Type) | |
| 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 # | |
| Show (URec Double p) | |
| Generic (URec Double p) | |
| newtype Vector Double | |
Defined in Data.Vector.Unboxed.Base | |
| type Difference Double | |
Defined in Basement.Numerical.Subtractive | |
| type PrimSize Double | |
Defined in Basement.PrimType type PrimSize Double = 8 | |
| data URec Double (p :: k) | |
Defined in GHC.Generics | |
| newtype MVector s Double | |
Defined in Data.Vector.Unboxed.Base | |
| type Rep1 (URec Double :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Double p) | |
Defined in GHC.Generics | |
Instances
| Eq Float | |
| Floating Float | |
| Ord Float | |
| Read 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 # | |
| Binary Float | |
| PrintfArg Float | |
Defined in Text.Printf | |
| Storable Float | |
Defined in Foreign.Storable | |
| Hashable Float | |
Defined in Data.Hashable.Class | |
| Unbox Float | |
Defined in Data.Vector.Unboxed.Base | |
| Prim Float | |
Defined in Data.Primitive.Types Methods alignment# :: Float -> Int# indexByteArray# :: ByteArray# -> Int# -> Float readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Float #) writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Float readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Float #) writeOffAddr# :: Addr# -> Int# -> Float -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Float -> State# s -> State# s | |
| PrimType Float | |
Defined in Basement.PrimType Associated Types type PrimSize Float :: Nat Methods primSizeInBytes :: Proxy Float -> CountOf Word8 primShiftToBytes :: Proxy Float -> Int primBaUIndex :: ByteArray# -> Offset Float -> Float primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> prim Float primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Float -> Float -> prim () primAddrIndex :: Addr# -> Offset Float -> Float primAddrRead :: PrimMonad prim => Addr# -> Offset Float -> prim Float primAddrWrite :: PrimMonad prim => Addr# -> Offset Float -> Float -> prim () | |
| Subtractive Float | |
| UniformRange Float | |
Defined in System.Random.Internal | |
| Lift Float | |
| IArray UArray Float | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Float -> (i, i) numElements :: Ix i => UArray i Float -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Float)] -> UArray i Float unsafeAt :: Ix i => UArray i Float -> Int -> Float unsafeReplace :: Ix i => UArray i Float -> [(Int, Float)] -> UArray i Float unsafeAccum :: Ix i => (Float -> e' -> Float) -> UArray i Float -> [(Int, e')] -> UArray i Float unsafeAccumArray :: Ix i => (Float -> e' -> Float) -> Float -> (i, i) -> [(Int, e')] -> UArray i Float | |
| Vector Vector Float | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) basicLength :: Vector Float -> Int basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () | |
| MVector MVector Float | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float basicOverlaps :: MVector s Float -> MVector s Float -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float) basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float) | |
| () :=> (Enum Float) | |
Defined in Data.Constraint | |
| () :=> (Eq Float) | |
Defined in Data.Constraint | |
| () :=> (Floating Float) | |
Defined in Data.Constraint | |
| () :=> (Fractional Float) | |
Defined in Data.Constraint Methods ins :: () :- Fractional Float | |
| () :=> (Num Float) | |
Defined in Data.Constraint | |
| () :=> (Ord Float) | |
Defined in Data.Constraint | |
| () :=> (Real Float) | |
Defined in Data.Constraint | |
| () :=> (RealFloat Float) | |
Defined in Data.Constraint | |
| () :=> (RealFrac Float) | |
Defined in Data.Constraint | |
| Generic1 (URec Float :: k -> Type) | |
| Foldable (UFloat :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # | |
| Traversable (UFloat :: Type -> Type) | |
Defined in Data.Traversable | |
| MArray (STUArray s) Float (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Float -> ST s (i, i) getNumElements :: Ix i => STUArray s i Float -> ST s Int newArray :: Ix i => (i, i) -> Float -> ST s (STUArray s i Float) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) unsafeRead :: Ix i => STUArray s i Float -> Int -> ST s Float unsafeWrite :: Ix i => STUArray s i Float -> Int -> Float -> ST s () | |
| Functor (URec Float :: Type -> Type) | |
| Eq (URec Float p) | |
| Ord (URec Float p) | |
Defined in GHC.Generics | |
| Show (URec Float p) | |
| Generic (URec Float p) | |
| newtype Vector Float | |
Defined in Data.Vector.Unboxed.Base | |
| type Difference Float | |
Defined in Basement.Numerical.Subtractive | |
| type PrimSize Float | |
Defined in Basement.PrimType type PrimSize Float = 4 | |
| data URec Float (p :: k) | |
Defined in GHC.Generics | |
| newtype MVector s Float | |
Defined in Data.Vector.Unboxed.Base | |
| type Rep1 (URec Float :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Float p) | |
Defined in GHC.Generics | |
Instances
| Bounded Int | |
| Enum Int | |
| Eq Int | |
| Integral Int | |
| Num Int | |
| Ord Int | |
| Read Int | |
| Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Show Int | |
| Ix Int | |
| Binary Int | |
| PrintfArg Int | |
Defined in Text.Printf | |
| Bits Int | |
Defined in Data.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 Data.Bits | |
| Storable Int | |
| Hashable Int | |
Defined in Data.Hashable.Class | |
| Unbox Int | |
Defined in Data.Vector.Unboxed.Base | |
| Prim Int | |
Defined in Data.Primitive.Types Methods alignment# :: Int -> Int# indexByteArray# :: ByteArray# -> Int# -> Int readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int #) writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Int readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int #) writeOffAddr# :: Addr# -> Int# -> Int -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Int -> State# s -> State# s | |
| PrimType Int | |
Defined in Basement.PrimType Associated Types type PrimSize Int :: Nat Methods primSizeInBytes :: Proxy Int -> CountOf Word8 primShiftToBytes :: Proxy Int -> Int primBaUIndex :: ByteArray# -> Offset Int -> Int primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> prim Int primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Int -> Int -> prim () primAddrIndex :: Addr# -> Offset Int -> Int primAddrRead :: PrimMonad prim => Addr# -> Offset Int -> prim Int primAddrWrite :: PrimMonad prim => Addr# -> Offset Int -> Int -> prim () | |
| Subtractive Int | |
| PrimMemoryComparable Int | |
Defined in Basement.PrimType | |
| Uniform Int | |
Defined in System.Random.Internal | |
| UniformRange Int | |
Defined in System.Random.Internal | |
| ByteSource Int | |
Defined in Data.UUID.Types.Internal.Builder | |
| Lift Int | |
| IArray UArray Int | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int -> (i, i) numElements :: Ix i => UArray i Int -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int)] -> UArray i Int unsafeAt :: Ix i => UArray i Int -> Int -> Int unsafeReplace :: Ix i => UArray i Int -> [(Int, Int)] -> UArray i Int unsafeAccum :: Ix i => (Int -> e' -> Int) -> UArray i Int -> [(Int, e')] -> UArray i Int unsafeAccumArray :: Ix i => (Int -> e' -> Int) -> Int -> (i, i) -> [(Int, e')] -> UArray i Int | |
| Vector Vector Int | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) basicLength :: Vector Int -> Int basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () | |
| MVector MVector Int | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int basicOverlaps :: MVector s Int -> MVector s Int -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int) basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) | |
| () :=> (Bounded Int) | |
Defined in Data.Constraint | |
| () :=> (Enum Int) | |
Defined in Data.Constraint | |
| () :=> (Eq Int) | |
Defined in Data.Constraint | |
| () :=> (Integral Int) | |
Defined in Data.Constraint | |
| () :=> (Num Int) | |
Defined in Data.Constraint | |
| () :=> (Ord Int) | |
Defined in Data.Constraint | |
| () :=> (Read Int) | |
Defined in Data.Constraint | |
| () :=> (Real Int) | |
Defined in Data.Constraint | |
| () :=> (Show Int) | |
Defined in Data.Constraint | |
| () :=> (Bits Int) | |
Defined in Data.Constraint | |
| Generic1 (URec Int :: k -> Type) | |
| Foldable (UInt :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
| Traversable (UInt :: Type -> Type) | |
Defined in Data.Traversable | |
| MArray (STUArray s) Int (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int -> ST s (i, i) getNumElements :: Ix i => STUArray s i Int -> ST s Int newArray :: Ix i => (i, i) -> Int -> ST s (STUArray s i Int) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int) unsafeRead :: Ix i => STUArray s i Int -> Int -> ST s Int unsafeWrite :: Ix i => STUArray s i Int -> Int -> Int -> ST s () | |
| Functor (URec Int :: Type -> Type) | |
| Eq (URec Int p) | |
| Ord (URec Int p) | |
| Show (URec Int p) | |
| Generic (URec Int p) | |
| newtype Vector Int | |
Defined in Data.Vector.Unboxed.Base | |
| type Difference Int | |
Defined in Basement.Numerical.Subtractive | |
| type NatNumMaxBound Int | |
Defined in Basement.Nat type NatNumMaxBound Int = NatNumMaxBound Int64 | |
| type PrimSize Int | |
Defined in Basement.PrimType type PrimSize Int = 8 | |
| data URec Int (p :: k) | |
Defined in GHC.Generics | |
| newtype MVector s Int | |
Defined in Data.Vector.Unboxed.Base | |
| type ByteSink Int g | |
Defined in Data.UUID.Types.Internal.Builder type ByteSink Int g = Takes4Bytes g | |
| type Rep1 (URec Int :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Int p) | |
Defined in GHC.Generics | |
Instances
Instances
| Monad Maybe | |
| Functor Maybe | |
| MonadFix Maybe | |
Defined in Control.Monad.Fix | |
| MonadFail Maybe | |
Defined in Control.Monad.Fail | |
| Applicative 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 # | |
| Traversable Maybe | |
| Alternative Maybe | |
| MonadPlus Maybe | |
| 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 | |
| Hashable1 Maybe | |
Defined in Data.Hashable.Class | |
| MonadThrow Maybe | |
Defined in Control.Monad.Catch | |
| MonadFailure Maybe | |
Defined in Basement.Monad Associated Types type Failure Maybe | |
| Lift a => Lift (Maybe a :: Type) | |
| () :=> (Functor Maybe) | |
Defined in Data.Constraint | |
| () :=> (Applicative Maybe) | |
Defined in Data.Constraint Methods ins :: () :- Applicative Maybe | |
| () :=> (Alternative Maybe) | |
Defined in Data.Constraint | |
| () :=> (MonadPlus Maybe) | |
Defined in Data.Constraint | |
| Eq a => Eq (Maybe a) | |
| Ord a => Ord (Maybe a) | |
| Read a => Read (Maybe a) | |
| Show a => Show (Maybe a) | |
| Generic (Maybe a) | |
| Semigroup a => Semigroup (Maybe a) | |
| Semigroup a => Monoid (Maybe a) | |
| Binary a => Binary (Maybe a) | |
| Hashable a => Hashable (Maybe a) | |
Defined in Data.Hashable.Class | |
| SingKind a => SingKind (Maybe a) | |
Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) | |
| MonoFoldable (Maybe a) | |
Defined in Data.MonoTraversable Methods ofoldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m ofoldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b ofoldl' :: (a0 -> Element (Maybe a) -> a0) -> a0 -> Maybe a -> a0 otoList :: Maybe a -> [Element (Maybe a)] oall :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool oany :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool ocompareLength :: Integral i => Maybe a -> i -> Ordering otraverse_ :: Applicative f => (Element (Maybe a) -> f b) -> Maybe a -> f () ofor_ :: Applicative f => Maybe a -> (Element (Maybe a) -> f b) -> f () omapM_ :: Applicative m => (Element (Maybe a) -> m ()) -> Maybe a -> m () oforM_ :: Applicative m => Maybe a -> (Element (Maybe a) -> m ()) -> m () ofoldlM :: Monad m => (a0 -> Element (Maybe a) -> m a0) -> a0 -> Maybe a -> m a0 ofoldMap1Ex :: Semigroup m => (Element (Maybe a) -> m) -> Maybe a -> m ofoldr1Ex :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) ofoldl1Ex' :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) headEx :: Maybe a -> Element (Maybe a) lastEx :: Maybe a -> Element (Maybe a) unsafeHead :: Maybe a -> Element (Maybe a) unsafeLast :: Maybe a -> Element (Maybe a) maximumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) minimumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) | |
| MonoTraversable (Maybe a) | |
Defined in Data.MonoTraversable | |
| MonoFunctor (Maybe a) | |
| MonoPointed (Maybe a) | |
Defined in Data.MonoTraversable | |
| Generic1 Maybe | |
| SingI ('Nothing :: Maybe a) | |
Defined in GHC.Generics | |
| (Eq a) :=> (Eq (Maybe a)) | |
Defined in Data.Constraint | |
| (Ord a) :=> (Ord (Maybe a)) | |
Defined in Data.Constraint | |
| (Read a) :=> (Read (Maybe a)) | |
Defined in Data.Constraint | |
| (Show a) :=> (Show (Maybe a)) | |
Defined in Data.Constraint | |
| (Semigroup a) :=> (Semigroup (Maybe a)) | |
Defined in Data.Constraint | |
| (Monoid a) :=> (Monoid (Maybe a)) | |
Defined in Data.Constraint | |
| SingI a2 => SingI ('Just a2 :: Maybe a1) | |
Defined in GHC.Generics | |
| type Failure Maybe | |
Defined in Basement.Monad type Failure Maybe = () | |
| type Rep (Maybe a) | |
Defined in GHC.Generics | |
| type DemoteRep (Maybe a) | |
Defined in GHC.Generics | |
| data Sing (b :: Maybe a) | |
| type Element (Maybe a) | |
Defined in Data.MonoTraversable type Element (Maybe a) = a | |
| type Rep1 Maybe | |
Instances
| Bounded Ordering | |
| Enum Ordering | |
| Eq Ordering | |
| Ord Ordering | |
Defined in GHC.Classes | |
| Read Ordering | |
| Show Ordering | |
| Ix Ordering | |
Defined in GHC.Ix | |
| Generic Ordering | |
| Semigroup Ordering | |
| Monoid Ordering | |
| Binary Ordering | |
| Hashable Ordering | |
Defined in Data.Hashable.Class | |
| () :=> (Bounded Ordering) | |
Defined in Data.Constraint | |
| () :=> (Enum Ordering) | |
Defined in Data.Constraint | |
| () :=> (Read Ordering) | |
Defined in Data.Constraint | |
| () :=> (Show Ordering) | |
Defined in Data.Constraint | |
| () :=> (Semigroup Ordering) | |
Defined in Data.Constraint | |
| () :=> (Monoid Ordering) | |
Defined in Data.Constraint | |
| type Rep Ordering | |
Instances
| Monad IO | |
| Functor IO | |
| MonadFix IO | |
Defined in Control.Monad.Fix | |
| MonadFail IO | |
Defined in Control.Monad.Fail | |
| Applicative IO | |
| Alternative IO | |
| MonadPlus IO | |
| Quasi IO | |
Defined in Language.Haskell.TH.Syntax Methods qReport :: Bool -> String -> IO () qRecover :: IO a -> IO a -> IO a qLookupName :: Bool -> String -> IO (Maybe Name) qReifyFixity :: Name -> IO (Maybe Fixity) qReifyType :: Name -> IO Type qReifyInstances :: Name -> [Type] -> IO [Dec] qReifyRoles :: Name -> IO [Role] qReifyAnnotations :: Data a => AnnLookup -> IO [a] qReifyModule :: Module -> IO ModuleInfo qReifyConStrictness :: Name -> IO [DecidedStrictness] qAddDependentFile :: FilePath -> IO () qAddTempFile :: String -> IO FilePath qAddTopDecls :: [Dec] -> IO () qAddForeignFilePath :: ForeignSrcLang -> String -> IO () qAddModFinalizer :: Q () -> IO () qAddCorePlugin :: String -> IO () qGetQ :: Typeable a => IO (Maybe a) qPutQ :: Typeable a => a -> IO () qIsExtEnabled :: Extension -> IO Bool qExtsEnabled :: IO [Extension] | |
| MonadIO IO | |
Defined in Control.Monad.IO.Class | |
| PrimMonad IO | |
| PrimBase IO | |
Defined in Control.Monad.Primitive | |
| MonadRandom IO | |
Defined in Crypto.Random.Types Methods getRandomBytes :: ByteArray byteArray => Int -> IO byteArray | |
| MonadThrow IO | |
Defined in Control.Monad.Catch | |
| MonadUnliftIO IO | |
Defined in Control.Monad.IO.Unlift Methods withRunInIO :: ((forall a. IO a -> IO a) -> IO b) -> IO b | |
| PrimMonad IO | |
Defined in Basement.Monad Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a primThrow :: Exception e => e -> IO a unPrimMonad :: IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #) primVarNew :: a -> IO (PrimVar IO a) primVarRead :: PrimVar IO a -> IO a primVarWrite :: PrimVar IO a -> a -> IO () | |
| MonadCatch IO | |
Defined in Control.Monad.Catch | |
| MonadMask IO | |
| MArray IOArray e IO | |
Defined in Data.Array.Base Methods getBounds :: Ix i => IOArray i e -> IO (i, i) getNumElements :: Ix i => IOArray i e -> IO Int newArray :: Ix i => (i, i) -> e -> IO (IOArray i e) newArray_ :: Ix i => (i, i) -> IO (IOArray i e) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOArray i e) unsafeRead :: Ix i => IOArray i e -> Int -> IO e unsafeWrite :: Ix i => IOArray i e -> Int -> e -> IO () | |
| () :=> (Monad IO) | |
Defined in Data.Constraint | |
| () :=> (Functor IO) | |
Defined in Data.Constraint | |
| () :=> (Applicative IO) | |
Defined in Data.Constraint Methods ins :: () :- Applicative IO | |
| Semigroup a => Semigroup (IO a) | |
| Monoid a => Monoid (IO a) | |
| MonoFunctor (IO a) | |
| MonoPointed (IO a) | |
Defined in Data.MonoTraversable | |
| a ~ () => HPrintfType (IO a) | |
Defined in Text.Printf | |
| a ~ () => PrintfType (IO a) | |
Defined in Text.Printf | |
| (Semigroup a) :=> (Semigroup (IO a)) | |
Defined in Data.Constraint | |
| (Monoid a) :=> (Monoid (IO a)) | |
Defined in Data.Constraint | |
| type PrimState IO | |
Defined in Control.Monad.Primitive type PrimState IO = RealWorld | |
| type PrimState IO | |
Defined in Basement.Monad type PrimState IO = RealWorld | |
| type PrimVar IO | |
Defined in Basement.Monad type PrimVar IO = IORef | |
| type Element (IO a) | |
Defined in Data.MonoTraversable type Element (IO a) = a | |
Instances
| Bounded Word | |
| Enum Word | |
| Eq Word | |
| Integral Word | |
| Num Word | |
| Ord Word | |
| Read Word | |
| Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
| Show Word | |
| Ix Word | |
| Binary Word | |
| PrintfArg Word | |
Defined in Text.Printf | |
| Bits Word | |
Defined in Data.Bits | |
| FiniteBits Word | |
Defined in Data.Bits Methods finiteBitSize :: Word -> Int countLeadingZeros :: Word -> Int countTrailingZeros :: Word -> Int | |
| Storable Word | |
Defined in Foreign.Storable | |
| Hashable Word | |
Defined in Data.Hashable.Class | |
| Unbox Word | |
Defined in Data.Vector.Unboxed.Base | |
| Prim Word | |
Defined in Data.Primitive.Types Methods alignment# :: Word -> Int# indexByteArray# :: ByteArray# -> Int# -> Word readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word #) writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s indexOffAddr# :: Addr# -> Int# -> Word readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word #) writeOffAddr# :: Addr# -> Int# -> Word -> State# s -> State# s setOffAddr# :: Addr# -> Int# -> Int# -> Word -> State# s -> State# s | |
| PrimType Word | |
Defined in Basement.PrimType Associated Types type PrimSize Word :: Nat Methods primSizeInBytes :: Proxy Word -> CountOf Word8 primShiftToBytes :: Proxy Word -> Int primBaUIndex :: ByteArray# -> Offset Word -> Word primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> prim Word primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset Word -> Word -> prim () primAddrIndex :: Addr# -> Offset Word -> Word primAddrRead :: PrimMonad prim => Addr# -> Offset Word -> prim Word primAddrWrite :: PrimMonad prim => Addr# -> Offset Word -> Word -> prim () | |
| BitOps Word | |
| FiniteBitsOps Word | |
| Subtractive Word | |
| PrimMemoryComparable Word | |
Defined in Basement.PrimType | |
| Uniform Word | |
Defined in System.Random.Internal | |
| UniformRange Word | |
Defined in System.Random.Internal | |
| Lift Word | |
| IArray UArray Word | |
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word -> (i, i) numElements :: Ix i => UArray i Word -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word)] -> UArray i Word unsafeAt :: Ix i => UArray i Word -> Int -> Word unsafeReplace :: Ix i => UArray i Word -> [(Int, Word)] -> UArray i Word unsafeAccum :: Ix i => (Word -> e' -> Word) -> UArray i Word -> [(Int, e')] -> UArray i Word unsafeAccumArray :: Ix i => (Word -> e' -> Word) -> Word -> (i, i) -> [(Int, e')] -> UArray i Word | |
| Vector Vector Word | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) basicLength :: Vector Word -> Int basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () | |
| MVector MVector Word | |
Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word basicOverlaps :: MVector s Word -> MVector s Word -> Bool basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word) basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) | |
| () :=> (Bounded Word) | |
Defined in Data.Constraint | |
| () :=> (Enum Word) | |
Defined in Data.Constraint | |
| () :=> (Eq Word) | |
Defined in Data.Constraint | |
| () :=> (Integral Word) | |
Defined in Data.Constraint | |
| () :=> (Num Word) | |
Defined in Data.Constraint | |
| () :=> (Ord Word) | |
Defined in Data.Constraint | |
| () :=> (Read Word) | |
Defined in Data.Constraint | |
| () :=> (Real Word) | |
Defined in Data.Constraint | |
| () :=> (Show Word) | |
Defined in Data.Constraint | |
| () :=> (Bits Word) | |
Defined in Data.Constraint | |
| Generic1 (URec Word :: k -> Type) | |
| Foldable (UWord :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # | |
| Traversable (UWord :: Type -> Type) | |
Defined in Data.Traversable | |
| MArray (STUArray s) Word (ST s) | |
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word -> ST s (i, i) getNumElements :: Ix i => STUArray s i Word -> ST s Int newArray :: Ix i => (i, i) -> Word -> ST s (STUArray s i Word) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) unsafeRead :: Ix i => STUArray s i Word -> Int -> ST s Word unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> ST s () | |
| Functor (URec Word :: Type -> Type) | |
| Eq (URec Word p) | |
| Ord (URec Word p) | |
Defined in GHC.Generics | |
| Show (URec Word p) | |
| Generic (URec Word p) | |
| newtype Vector Word | |
Defined in Data.Vector.Unboxed.Base | |
| type Difference Word | |
Defined in Basement.Numerical.Subtractive | |
| type NatNumMaxBound Word | |
Defined in Basement.Nat type NatNumMaxBound Word = NatNumMaxBound Word64 | |
| type PrimSize Word | |
Defined in Basement.PrimType type PrimSize Word = 8 | |
| data URec Word (p :: k) | |
Defined in GHC.Generics | |
| newtype MVector s Word | |
Defined in Data.Vector.Unboxed.Base | |
| type Rep1 (URec Word :: k -> Type) | |
Defined in GHC.Generics | |
| type Rep (URec Word p) | |
Defined in GHC.Generics | |
Instances
| Bifoldable Either | |
| 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 | |
| Show2 Either | |
| 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] | |
| Hashable2 Either | |
Defined in Data.Hashable.Class | |
| () :=> (Monad (Either a)) | |
Defined in Data.Constraint | |
| () :=> (Functor (Either a)) | |
Defined in Data.Constraint | |
| () :=> (Applicative (Either a)) | |
Defined in Data.Constraint Methods ins :: () :- Applicative (Either a) | |
| (Lift a, Lift b) => Lift (Either a b :: Type) | |
| Monad (Either e) | |
| Functor (Either a) | |
| MonadFix (Either e) | |
Defined in Control.Monad.Fix | |
| Applicative (Either e) | |
| 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 # | |
| Traversable (Either a) | |
Defined in Data.Traversable | |
| 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 | |
| Hashable a => Hashable1 (Either a) | |
Defined in Data.Hashable.Class | |
| e ~ SomeException => MonadThrow (Either e) | |
Defined in Control.Monad.Catch | |
| e ~ SomeException => MonadCatch (Either e) | |
Defined in Control.Monad.Catch | |
| e ~ SomeException => MonadMask (Either e) | |
Defined in Control.Monad.Catch | |
| MonadFailure (Either a) | |
Defined in Basement.Monad Associated Types type Failure (Either a) | |
| Generic1 (Either a :: Type -> Type) | |
| (Eq a, Eq b) => Eq (Either a b) | |
| (Ord a, Ord b) => Ord (Either a b) | |
| (Read a, Read b) => Read (Either a b) | |
| (Show a, Show b) => Show (Either a b) | |
| Generic (Either a b) | |
| Semigroup (Either a b) | |
| (Binary a, Binary b) => Binary (Either a b) | |
| (Hashable a, Hashable b) => Hashable (Either a b) | |
Defined in Data.Hashable.Class | |
| MonoFoldable (Either a b) | |
Defined in Data.MonoTraversable Methods ofoldMap :: Monoid m => (Element (Either a b) -> m) -> Either a b -> m ofoldr :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 ofoldl' :: (a0 -> Element (Either a b) -> a0) -> a0 -> Either a b -> a0 otoList :: Either a b -> [Element (Either a b)] oall :: (Element (Either a b) -> Bool) -> Either a b -> Bool oany :: (Element (Either a b) -> Bool) -> Either a b -> Bool olength64 :: Either a b -> Int64 ocompareLength :: Integral i => Either a b -> i -> Ordering otraverse_ :: Applicative f => (Element (Either a b) -> f b0) -> Either a b -> f () ofor_ :: Applicative f => Either a b -> (Element (Either a b) -> f b0) -> f () omapM_ :: Applicative m => (Element (Either a b) -> m ()) -> Either a b -> m () oforM_ :: Applicative m => Either a b -> (Element (Either a b) -> m ()) -> m () ofoldlM :: Monad m => (a0 -> Element (Either a b) -> m a0) -> a0 -> Either a b -> m a0 ofoldMap1Ex :: Semigroup m => (Element (Either a b) -> m) -> Either a b -> m ofoldr1Ex :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Element (Either a b) ofoldl1Ex' :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Element (Either a b) headEx :: Either a b -> Element (Either a b) lastEx :: Either a b -> Element (Either a b) unsafeHead :: Either a b -> Element (Either a b) unsafeLast :: Either a b -> Element (Either a b) maximumByEx :: (Element (Either a b) -> Element (Either a b) -> Ordering) -> Either a b -> Element (Either a b) minimumByEx :: (Element (Either a b) -> Element (Either a b) -> Ordering) -> Either a b -> Element (Either a b) | |
| MonoTraversable (Either a b) | |
Defined in Data.MonoTraversable | |
| MonoFunctor (Either a b) | |
| MonoPointed (Either a b) | |
Defined in Data.MonoTraversable | |
| (Eq a, Eq b) :=> (Eq (Either a b)) | |
| (Ord a, Ord b) :=> (Ord (Either a b)) | |
| (Read a, Read b) :=> (Read (Either a b)) | |
| (Show a, Show b) :=> (Show (Either a b)) | |
| type Failure (Either a) | |
Defined in Basement.Monad type Failure (Either a) = a | |
| 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))) | |
| type Element (Either a b) | |
Defined in Data.MonoTraversable type Element (Either a b) = b | |
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a #
(^^) :: (Fractional a, Integral b) => a -> b -> a #
showString :: String -> ShowS #
appendFile :: FilePath -> String -> IO () #
getContents :: IO String #
class Functor f => Applicative (f :: Type -> Type) where #
Instances
| Applicative [] | |
| Applicative Maybe | |
| Applicative IO | |
| Applicative Par1 | |
| Applicative Q | |
| Applicative ZipList | |
| Applicative P | |
| Applicative ReadP | |
| Applicative ReadPrec | |
| Applicative First | |
| Applicative Last | |
| Applicative Dual | |
| Applicative Product | |
| Applicative Sum | |
| Applicative NonEmpty | |
| Applicative First | |
| Applicative Last | |
| Applicative Max | |
| Applicative Min | |
| Applicative Option | |
| Applicative Identity | |
| Applicative Down | |
| Applicative PutM | |
| Applicative Get | |
| Applicative Stream | |
| Applicative Seq | |
| Applicative Tree | |
| Applicative Complex | |
| Applicative Vector | |
| Applicative Id | |
| Applicative Array | |
| Applicative Box | |
| Applicative SmallArray | |
Defined in Data.Primitive.SmallArray | |
| Applicative Concurrently | |
Defined in Control.Concurrent.Async | |
| Applicative STM | |
| Applicative CryptoFailable | |
Defined in Crypto.Error.Types Methods pure :: a -> CryptoFailable a # (<*>) :: CryptoFailable (a -> b) -> CryptoFailable a -> CryptoFailable b # liftA2 :: (a -> b -> c) -> CryptoFailable a -> CryptoFailable b -> CryptoFailable c # (*>) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable b # (<*) :: CryptoFailable a -> CryptoFailable b -> CryptoFailable a # | |
| Applicative Result | |
| Applicative IResult | |
| Applicative Parser | |
| Applicative DNonEmpty | |
Defined in Data.DList.DNonEmpty.Internal | |
| Applicative DList | |
| Applicative Capability | |
Defined in System.Console.Terminfo.Base | |
| Applicative Put | |
| Applicative Perhaps Source # | |
| Applicative DefaultIO Source # | |
Defined in Darcs.Repository.ApplyPatches | |
| () :=> (Applicative ((->) a :: Type -> Type)) | |
Defined in Data.Constraint Methods ins :: () :- Applicative ((->) a) | |
| () :=> (Applicative []) | |
Defined in Data.Constraint Methods ins :: () :- Applicative [] | |
| () :=> (Applicative Maybe) | |
Defined in Data.Constraint Methods ins :: () :- Applicative Maybe | |
| () :=> (Applicative IO) | |
Defined in Data.Constraint Methods ins :: () :- Applicative IO | |
| () :=> (Applicative (Either a)) | |
Defined in Data.Constraint Methods ins :: () :- Applicative (Either a) | |
| Applicative (Either e) | |
| Applicative (U1 :: Type -> Type) | |
| Monoid a => Applicative ((,) a) | |
| 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 # | |
| Applicative (Proxy :: Type -> Type) | |
| Applicative (ST s) | |
| Arrow a => Applicative (ArrowMonad a) | |
Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 # | |
| Applicative (ST s) | |
| Applicative m => Applicative (ListT m) | |
| (Functor m, Monad m) => Applicative (MaybeT m) | |
| DRG gen => Applicative (MonadPseudoRandom gen) | |
Defined in Crypto.Random.Types Methods pure :: a -> MonadPseudoRandom gen a # (<*>) :: MonadPseudoRandom gen (a -> b) -> MonadPseudoRandom gen a -> MonadPseudoRandom gen b # liftA2 :: (a -> b -> c) -> MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen c # (*>) :: MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen b # (<*) :: MonadPseudoRandom gen a -> MonadPseudoRandom gen b -> MonadPseudoRandom gen a # | |
| Applicative m => Applicative (ResourceT m) | |
Defined in Control.Monad.Trans.Resource.Internal | |
| Applicative (Parser i) | |
| Monad m => Applicative (ZipSource m) | |
Defined in Data.Conduit.Internal.Conduit | |
| Applicative f => Applicative (WrappedPoly f) | |
Defined in Data.MonoTraversable Methods pure :: a -> WrappedPoly f a # (<*>) :: WrappedPoly f (a -> b) -> WrappedPoly f a -> WrappedPoly f b # liftA2 :: (a -> b -> c) -> WrappedPoly f a -> WrappedPoly f b -> WrappedPoly f c # (*>) :: WrappedPoly f a -> WrappedPoly f b -> WrappedPoly f b # (<*) :: WrappedPoly f a -> WrappedPoly f b -> WrappedPoly f a # | |
| Semigroup a => Applicative (These a) | |
| Semigroup a => Applicative (These a) | |
| Applicative m => Applicative (InputT m) | |
| Applicative (Partial e) | |
| Applicative (RE s) | |
| (Monad m) :=> (Applicative (WrappedMonad m)) | |
Defined in Data.Constraint Methods ins :: Monad m :- Applicative (WrappedMonad m) | |
| (Monoid a) :=> (Applicative ((,) a)) | |
Defined in Data.Constraint Methods ins :: Monoid a :- Applicative ((,) a) | |
| (Monoid a) :=> (Applicative (Const a :: Type -> Type)) | |
Defined in Data.Constraint Methods ins :: Monoid a :- Applicative (Const a) | |
| Class (Functor f) (Applicative f) | |
Defined in Data.Constraint Methods cls :: Applicative f :- Functor f | |
| Class (Applicative f) (Monad f) | |
Defined in Data.Constraint Methods cls :: Monad f :- Applicative f | |
| Class (Applicative f) (Alternative f) | |
Defined in Data.Constraint Methods cls :: Alternative f :- Applicative f | |
| Applicative f => Applicative (Rec1 f) | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | |
| 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 # | |
| Monoid m => Applicative (Const m :: Type -> Type) | |
| Applicative f => Applicative (Ap f) | |
| Applicative f => Applicative (Alt f) | |
| Applicative m => Applicative (Kleisli m a) | |
Defined in Control.Arrow | |
| (Functor m, Monad m) => Applicative (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
| (Applicative f, Monad f) => Applicative (WhenMissing f x) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a # | |
| Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
| (Monoid w, Functor m, Monad m) => Applicative (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
| (Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
| Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
| (Functor m, Monad m) => Applicative (SelectT r m) | |
Defined in Control.Monad.Trans.Select | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (Functor m, Monad m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| Monad m => Applicative (ZipSink i m) | |
Defined in Data.Conduit.Internal.Conduit | |
| Applicative (Tagged s) | |
| Applicative ((->) r :: Type -> Type) | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | |
| (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Base | |
| Applicative (ParsecT s u m) | |
Defined in Text.Parsec.Prim Methods pure :: a -> ParsecT s u m a # (<*>) :: ParsecT s u m (a -> b) -> ParsecT s u m a -> ParsecT s u m b # liftA2 :: (a -> b -> c) -> ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m c # (*>) :: ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m b # (<*) :: ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m a # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a # | |
| (Monad f, Applicative f) => Applicative (WhenMatched f x y) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a # | |
| (Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
| Applicative (ContT r m) | |
Defined in Control.Monad.Trans.Cont | |
| Applicative (ConduitT i o m) | |
Defined in Data.Conduit.Internal.Conduit Methods pure :: a -> ConduitT i o m a # (<*>) :: ConduitT i o m (a -> b) -> ConduitT i o m a -> ConduitT i o m b # liftA2 :: (a -> b -> c) -> ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m c # (*>) :: ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m b # (<*) :: ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m a # | |
| Monad m => Applicative (ZipConduit i o m) | |
Defined in Data.Conduit.Internal.Conduit Methods pure :: a -> ZipConduit i o m a # (<*>) :: ZipConduit i o m (a -> b) -> ZipConduit i o m a -> ZipConduit i o m b # liftA2 :: (a -> b -> c) -> ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m c # (*>) :: ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m b # (<*) :: ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m a # | |
| Applicative f => Applicative (M1 i c f) | |
| (Applicative f, Applicative g) => Applicative (f :.: g) | |
| (Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a # | |
| (Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
| (Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
| Monad m => Applicative (Pipe l i o u m) | |
Defined in Data.Conduit.Internal.Pipe Methods pure :: a -> Pipe l i o u m a # (<*>) :: Pipe l i o u m (a -> b) -> Pipe l i o u m a -> Pipe l i o u m b # liftA2 :: (a -> b -> c) -> Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m c # (*>) :: Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m b # (<*) :: Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m a # | |
| Monad state => Applicative (Builder collection mutCollection step state err) | |
Defined in Basement.MutableBuilder Methods pure :: a -> Builder collection mutCollection step state err a # (<*>) :: Builder collection mutCollection step state err (a -> b) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b # liftA2 :: (a -> b -> c) -> Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err c # (*>) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err b # (<*) :: Builder collection mutCollection step state err a -> Builder collection mutCollection step state err b -> Builder collection mutCollection step state err a # | |
class Semigroup a => Monoid a where #
Minimal complete definition
Instances
| Monoid Ordering | |
| Monoid () | |
| Monoid All | |
| Monoid Any | |
| Monoid ByteString | |
| Monoid ByteString | |
| Monoid Builder | |
| Monoid ShortByteString | |
| Monoid IntSet | |
| Monoid ByteArray | |
| Monoid More | |
| Monoid RequestBody | |
| Monoid CookieJar | |
| Monoid String | |
| Monoid Doc Source # | |
| Monoid TermOutput | |
| a :=> (Monoid (Dict a)) | |
Defined in Data.Constraint | |
| () :=> (Monoid [a]) | |
Defined in Data.Constraint | |
| () :=> (Monoid Ordering) | |
Defined in Data.Constraint | |
| () :=> (Monoid ()) | |
Defined in Data.Constraint | |
| Monoid [a] | |
| Semigroup a => Monoid (Maybe a) | |
| Monoid a => Monoid (IO a) | |
| Monoid p => Monoid (Par1 p) | |
| Monoid (First a) | |
| Monoid (Last a) | |
| Monoid a => Monoid (Dual a) | |
| Monoid (Endo a) | |
| Num a => Monoid (Product a) | |
| Num a => Monoid (Sum a) | |
| (Ord a, Bounded a) => Monoid (Max a) | |
| (Ord a, Bounded a) => Monoid (Min a) | |
| Semigroup a => Monoid (Option a) | |
| Monoid m => Monoid (WrappedMonoid m) | |
| Monoid a => Monoid (Identity a) | |
| Monoid a => Monoid (Down a) | |
| Monoid (PutM ()) | |
| Ord a => Monoid (Set a) | |
| Monoid (MergeSet a) | |
| Monoid (IntMap a) | |
| Monoid (Seq a) | |
| Monoid (Vector a) | |
| Monoid (Array a) | |
| Prim a => Monoid (Vector a) | |
| Monoid (PrimArray a) | |
| Monoid (SmallArray a) | |
| (Semigroup a, Monoid a) => Monoid (Concurrently a) | |
| Monoid (Result a) | |
| Monoid s => Monoid (CI s) | |
| PrimType ty => Monoid (UArray ty) | |
| Monoid (CountOf ty) | |
| PrimType ty => Monoid (Block ty) | |
| (Hashable a, Eq a) => Monoid (HashSet a) | |
| Storable a => Monoid (Vector a) | |
| Monoid (IResult a) | |
| Monoid (Parser a) | |
| Monoid (DList a) | |
| Semigroup a => Monoid (Maybe a) | |
| a => Monoid (Dict a) | |
| Monoid (Entries e) | |
| (Monoid a) :=> (Monoid (Maybe a)) | |
Defined in Data.Constraint | |
| (Monoid a) :=> (Monoid (Const a b)) | |
Defined in Data.Constraint | |
| (Monoid a) :=> (Monoid (Identity a)) | |
Defined in Data.Constraint | |
| (Monoid a) :=> (Monoid (IO a)) | |
Defined in Data.Constraint | |
| (Monoid a) :=> (Applicative ((,) a)) | |
Defined in Data.Constraint Methods ins :: Monoid a :- Applicative ((,) a) | |
| (Monoid a) :=> (Applicative (Const a :: Type -> Type)) | |
Defined in Data.Constraint Methods ins :: Monoid a :- Applicative (Const a) | |
| Class (Semigroup a) (Monoid a) | |
Defined in Data.Constraint | |
| Monoid b => Monoid (a -> b) | |
| Monoid (U1 p) | |
| (Monoid a, Monoid b) => Monoid (a, b) | |
| Monoid (Proxy s) | |
| Monoid a => Monoid (ST s a) | |
| Ord k => Monoid (Map k v) | |
| Monoid (Parser i a) | |
| (Eq k, Hashable k) => Monoid (HashMap k v) | |
| (Monoid a, Monoid b) => Monoid (Pair a b) | |
| Monoid a => Monoid (RE s a) | |
| (Monoid a, Monoid b) :=> (Monoid (a, b)) | |
Defined in Data.Constraint | |
| Monoid (f p) => Monoid (Rec1 f p) | |
| (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
| Monoid a => Monoid (Const a b) | |
| (Applicative f, Monoid a) => Monoid (Ap f a) | |
| Alternative f => Monoid (Alt f a) | |
| (Semigroup a, Monoid a) => Monoid (Tagged s a) | |
| Monoid c => Monoid (K1 i c p) | |
| (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
| Monoid (PrimOptSpec d f a [v]) Source # | |
Defined in Darcs.UI.Options.Core Methods mempty :: PrimOptSpec d f a [v] # mappend :: PrimOptSpec d f a [v] -> PrimOptSpec d f a [v] -> PrimOptSpec d f a [v] # mconcat :: [PrimOptSpec d f a [v]] -> PrimOptSpec d f a [v] # | |
| (Monoid a, Semigroup (ParsecT s u m a)) => Monoid (ParsecT s u m a) | |
| Monad m => Monoid (ConduitT i o m ()) | |
| Monoid (f p) => Monoid (M1 i c f p) | |
| Monoid (f (g p)) => Monoid ((f :.: g) p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
| Monad m => Monoid (Pipe l i o u m ()) | |
Minimal complete definition
Instances
| Semigroup Ordering | |
| Semigroup () | |
| Semigroup All | |
| Semigroup Any | |
| Semigroup ByteString | |
| Semigroup ByteString | |
| Semigroup Builder | |
| Semigroup ShortByteString | |
| Semigroup IntSet | |
| Semigroup Void | |
| Semigroup ByteArray | |
| Semigroup More | |
| Semigroup RequestBody | |
| Semigroup CookieJar | |
| Semigroup String | |
| Semigroup Doc Source # | |
| Semigroup TermOutput | |
| () :=> (Semigroup [a]) | |
Defined in Data.Constraint | |
| () :=> (Semigroup Ordering) | |
Defined in Data.Constraint | |
| () :=> (Semigroup ()) | |
Defined in Data.Constraint | |
| () :=> (Semigroup (Dict a)) | |
Defined in Data.Constraint | |
| Class () (Semigroup a) | |
Defined in Data.Constraint | |
| Semigroup [a] | |
| Semigroup a => Semigroup (Maybe a) | |
| Semigroup a => Semigroup (IO a) | |
| Semigroup p => Semigroup (Par1 p) | |
| Semigroup (First a) | |
| Semigroup (Last a) | |
| Semigroup a => Semigroup (Dual a) | |
| Semigroup (Endo a) | |
| Num a => Semigroup (Product a) | |
| Num a => Semigroup (Sum a) | |
| Semigroup (NonEmpty a) | |
| Semigroup (First a) | |
| Semigroup (Last a) | |
| Ord a => Semigroup (Max a) | |
| Ord a => Semigroup (Min a) | |
| Semigroup a => Semigroup (Option a) | |
| Monoid m => Semigroup (WrappedMonoid m) | |
| Semigroup a => Semigroup (Identity a) | |
| Semigroup a => Semigroup (Down a) | |
| Semigroup (PutM ()) | |
| Ord a => Semigroup (Set a) | |
| Semigroup (MergeSet a) | |
| Semigroup (IntMap a) | |
| Semigroup (Seq a) | |
| Semigroup (Vector a) | |
| Semigroup (Array a) | |
| Prim a => Semigroup (Vector a) | |
| Semigroup (PrimArray a) | |
| Semigroup (SmallArray a) | |
| Semigroup a => Semigroup (Concurrently a) | |
| (Semigroup mono, GrowingAppend mono) => Semigroup (NonNull mono) | |
| Semigroup (Result a) | |
| Semigroup s => Semigroup (CI s) | |
| PrimType ty => Semigroup (UArray ty) | |
| Semigroup (CountOf ty) | |
| PrimType ty => Semigroup (Block ty) | |
| (Hashable a, Eq a) => Semigroup (HashSet a) | |
| Storable a => Semigroup (Vector a) | |
| Semigroup (IResult a) | |
| Semigroup (Parser a) | |
| Semigroup (DNonEmpty a) | |
| Semigroup (DList a) | |
| Semigroup a => Semigroup (Maybe a) | |
| Semigroup (Dict a) | |
| Semigroup (Entries e) | |
| (Semigroup a) :=> (Semigroup (Maybe a)) | |
Defined in Data.Constraint | |
| (Semigroup a) :=> (Semigroup (Const a b)) | |
Defined in Data.Constraint | |
| (Semigroup a) :=> (Semigroup (Identity a)) | |
Defined in Data.Constraint | |
| (Semigroup a) :=> (Semigroup (IO a)) | |
Defined in Data.Constraint | |
| Class (Semigroup a) (Monoid a) | |
Defined in Data.Constraint | |
| Semigroup b => Semigroup (a -> b) | |
| Semigroup (Either a b) | |
| Semigroup (V1 p) | |
| Semigroup (U1 p) | |
| (Semigroup a, Semigroup b) => Semigroup (a, b) | |
| Semigroup (Proxy s) | |
| Semigroup a => Semigroup (ST s a) | |
| Ord k => Semigroup (Map k v) | |
| Semigroup (Parser i a) | |
| (Eq k, Hashable k) => Semigroup (HashMap k v) | |
| Semigroup (Either a b) | |
| (Semigroup a, Semigroup b) => Semigroup (These a b) | |
| (Semigroup a, Semigroup b) => Semigroup (These a b) | |
| (Semigroup a, Semigroup b) => Semigroup (Pair a b) | |
| Semigroup a => Semigroup (RE s a) | |
| (Semigroup a, Semigroup b) :=> (Semigroup (a, b)) | |
Defined in Data.Constraint | |
| Semigroup (f p) => Semigroup (Rec1 f p) | |
| (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) | |
| Semigroup a => Semigroup (Const a b) | |
| (Applicative f, Semigroup a) => Semigroup (Ap f a) | |
| Alternative f => Semigroup (Alt f a) | |
| Semigroup a => Semigroup (Tagged s a) | |
| Semigroup c => Semigroup (K1 i c p) | |
| (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) | |
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) | |
| Semigroup (PrimOptSpec d f a [v]) Source # | |
Defined in Darcs.UI.Options.Core Methods (<>) :: PrimOptSpec d f a [v] -> PrimOptSpec d f a [v] -> PrimOptSpec d f a [v] # sconcat :: NonEmpty (PrimOptSpec d f a [v]) -> PrimOptSpec d f a [v] # stimes :: Integral b => b -> PrimOptSpec d f a [v] -> PrimOptSpec d f a [v] # | |
| Semigroup a => Semigroup (ParsecT s u m a) | |
| Monad m => Semigroup (ConduitT i o m ()) | |
| Semigroup (f p) => Semigroup (M1 i c f p) | |
| Semigroup (f (g p)) => Semigroup ((f :.: g) p) | |
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) | |
| Monad m => Semigroup (Pipe l i o u m ()) | |
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) #