Safe Haskell	Safe
Language	Haskell2010

Development.Shake.Classes

Description

This module reexports the six necessary type classes that every Rule type must support. You can use this module to define new rules without depending on the binary, deepseq and hashable packages.

Synopsis

Documentation

class Show a where #

Conversion of values to readable Strings.

Derived instances of Show have the following properties, which are compatible with derived instances of Read:

The result of show is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
If the constructor is defined to be an infix operator, then showsPrec will produce infix applications of the constructor.
the representation will be enclosed in parentheses if the precedence of the top-level constructor in x is less than d (associativity is ignored). Thus, if d is 0 then the result is never surrounded in parentheses; if d is 11 it is always surrounded in parentheses, unless it is an atomic expression.
If the constructor is defined using record syntax, then show will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Show is equivalent to

instance (Show a) => Show (Tree a) where

       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10

       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5

Note that right-associativity of :^: is ignored. For example,

show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

Minimal complete definition

showsPrec | show

Methods

showsPrec :: Int -> a -> ShowS #

Convert a value to a readable String.

showsPrec should satisfy the law

showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)

Derived instances of Read and Show satisfy the following:

(x,"") is an element of (readsPrec d (showsPrec d x "")).

That is, readsPrec parses the string produced by showsPrec, and delivers the value that showsPrec started with.

show :: a -> String #

A specialised variant of showsPrec, using precedence context zero, and returning an ordinary String.

showList :: [a] -> ShowS #

The method showList is provided to allow the programmer to give a specialised way of showing lists of values. For example, this is used by the predefined Show instance of the Char type, where values of type String should be shown in double quotes, rather than between square brackets.

Instances

Show Bool
Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Show Char
Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Show Int
Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Show Int8
Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Show Int16
Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Show Int32
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Show Int64
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Show Integer
Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Show Ordering
Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Show Word
Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Show Word8
Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Show Word16
Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Show Word32
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Show Word64
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Show CallStack
Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
Show TypeRep
Methods showsPrec :: Int -> TypeRep -> ShowS # show :: TypeRep -> String # showList :: [TypeRep] -> ShowS #
Show ()
Methods showsPrec :: Int -> () -> ShowS # show :: () -> String # showList :: [()] -> ShowS #
Show TyCon
Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Show Module
Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show TrName
Methods showsPrec :: Int -> TrName -> ShowS # show :: TrName -> String # showList :: [TrName] -> ShowS #
Show Handle
Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #
Show HandleType
Methods showsPrec :: Int -> HandleType -> ShowS # show :: HandleType -> String # showList :: [HandleType] -> ShowS #
Show Natural
Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Show Void
Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
Show DataType
Methods showsPrec :: Int -> DataType -> ShowS # show :: DataType -> String # showList :: [DataType] -> ShowS #
Show Constr
Methods showsPrec :: Int -> Constr -> ShowS # show :: Constr -> String # showList :: [Constr] -> ShowS #
Show DataRep
Methods showsPrec :: Int -> DataRep -> ShowS # show :: DataRep -> String # showList :: [DataRep] -> ShowS #
Show ConstrRep
Methods showsPrec :: Int -> ConstrRep -> ShowS # show :: ConstrRep -> String # showList :: [ConstrRep] -> ShowS #
Show Fixity
Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show Version
Methods showsPrec :: Int -> Version -> ShowS # show :: Version -> String # showList :: [Version] -> ShowS #
Show HandlePosn
Methods showsPrec :: Int -> HandlePosn -> ShowS # show :: HandlePosn -> String # showList :: [HandlePosn] -> ShowS #
Show PatternMatchFail
Methods showsPrec :: Int -> PatternMatchFail -> ShowS # show :: PatternMatchFail -> String # showList :: [PatternMatchFail] -> ShowS #
Show RecSelError
Methods showsPrec :: Int -> RecSelError -> ShowS # show :: RecSelError -> String # showList :: [RecSelError] -> ShowS #
Show RecConError
Methods showsPrec :: Int -> RecConError -> ShowS # show :: RecConError -> String # showList :: [RecConError] -> ShowS #
Show RecUpdError
Methods showsPrec :: Int -> RecUpdError -> ShowS # show :: RecUpdError -> String # showList :: [RecUpdError] -> ShowS #
Show NoMethodError
Methods showsPrec :: Int -> NoMethodError -> ShowS # show :: NoMethodError -> String # showList :: [NoMethodError] -> ShowS #
Show TypeError
Methods showsPrec :: Int -> TypeError -> ShowS # show :: TypeError -> String # showList :: [TypeError] -> ShowS #
Show NonTermination
Methods showsPrec :: Int -> NonTermination -> ShowS # show :: NonTermination -> String # showList :: [NonTermination] -> ShowS #
Show NestedAtomically
Methods showsPrec :: Int -> NestedAtomically -> ShowS # show :: NestedAtomically -> String # showList :: [NestedAtomically] -> ShowS #
Show CDev
Methods showsPrec :: Int -> CDev -> ShowS # show :: CDev -> String # showList :: [CDev] -> ShowS #
Show CIno
Methods showsPrec :: Int -> CIno -> ShowS # show :: CIno -> String # showList :: [CIno] -> ShowS #
Show CMode
Methods showsPrec :: Int -> CMode -> ShowS # show :: CMode -> String # showList :: [CMode] -> ShowS #
Show COff
Methods showsPrec :: Int -> COff -> ShowS # show :: COff -> String # showList :: [COff] -> ShowS #
Show CPid
Methods showsPrec :: Int -> CPid -> ShowS # show :: CPid -> String # showList :: [CPid] -> ShowS #
Show CSsize
Methods showsPrec :: Int -> CSsize -> ShowS # show :: CSsize -> String # showList :: [CSsize] -> ShowS #
Show CGid
Methods showsPrec :: Int -> CGid -> ShowS # show :: CGid -> String # showList :: [CGid] -> ShowS #
Show CNlink
Methods showsPrec :: Int -> CNlink -> ShowS # show :: CNlink -> String # showList :: [CNlink] -> ShowS #
Show CUid
Methods showsPrec :: Int -> CUid -> ShowS # show :: CUid -> String # showList :: [CUid] -> ShowS #
Show CCc
Methods showsPrec :: Int -> CCc -> ShowS # show :: CCc -> String # showList :: [CCc] -> ShowS #
Show CSpeed
Methods showsPrec :: Int -> CSpeed -> ShowS # show :: CSpeed -> String # showList :: [CSpeed] -> ShowS #
Show CTcflag
Methods showsPrec :: Int -> CTcflag -> ShowS # show :: CTcflag -> String # showList :: [CTcflag] -> ShowS #
Show CRLim
Methods showsPrec :: Int -> CRLim -> ShowS # show :: CRLim -> String # showList :: [CRLim] -> ShowS #
Show Fd
Methods showsPrec :: Int -> Fd -> ShowS # show :: Fd -> String # showList :: [Fd] -> ShowS #
Show ThreadId
Methods showsPrec :: Int -> ThreadId -> ShowS # show :: ThreadId -> String # showList :: [ThreadId] -> ShowS #
Show BlockReason
Methods showsPrec :: Int -> BlockReason -> ShowS # show :: BlockReason -> String # showList :: [BlockReason] -> ShowS #
Show ThreadStatus
Methods showsPrec :: Int -> ThreadStatus -> ShowS # show :: ThreadStatus -> String # showList :: [ThreadStatus] -> ShowS #
Show BlockedIndefinitelyOnMVar
Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> ShowS #
Show BlockedIndefinitelyOnSTM
Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #
Show Deadlock
Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #
Show AllocationLimitExceeded
Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> ShowS #
Show AssertionFailed
Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> ShowS #
Show SomeAsyncException
Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS #
Show AsyncException
Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Show ArrayException
Methods showsPrec :: Int -> ArrayException -> ShowS # show :: ArrayException -> String # showList :: [ArrayException] -> ShowS #
Show ExitCode
Methods showsPrec :: Int -> ExitCode -> ShowS # show :: ExitCode -> String # showList :: [ExitCode] -> ShowS #
Show IOErrorType
Methods showsPrec :: Int -> IOErrorType -> ShowS # show :: IOErrorType -> String # showList :: [IOErrorType] -> ShowS #
Show BufferMode
Methods showsPrec :: Int -> BufferMode -> ShowS # show :: BufferMode -> String # showList :: [BufferMode] -> ShowS #
Show Newline
Methods showsPrec :: Int -> Newline -> ShowS # show :: Newline -> String # showList :: [Newline] -> ShowS #
Show NewlineMode
Methods showsPrec :: Int -> NewlineMode -> ShowS # show :: NewlineMode -> String # showList :: [NewlineMode] -> ShowS #
Show WordPtr
Methods showsPrec :: Int -> WordPtr -> ShowS # show :: WordPtr -> String # showList :: [WordPtr] -> ShowS #
Show IntPtr
Methods showsPrec :: Int -> IntPtr -> ShowS # show :: IntPtr -> String # showList :: [IntPtr] -> ShowS #
Show CChar
Methods showsPrec :: Int -> CChar -> ShowS # show :: CChar -> String # showList :: [CChar] -> ShowS #
Show CSChar
Methods showsPrec :: Int -> CSChar -> ShowS # show :: CSChar -> String # showList :: [CSChar] -> ShowS #
Show CUChar
Methods showsPrec :: Int -> CUChar -> ShowS # show :: CUChar -> String # showList :: [CUChar] -> ShowS #
Show CShort
Methods showsPrec :: Int -> CShort -> ShowS # show :: CShort -> String # showList :: [CShort] -> ShowS #
Show CUShort
Methods showsPrec :: Int -> CUShort -> ShowS # show :: CUShort -> String # showList :: [CUShort] -> ShowS #
Show CInt
Methods showsPrec :: Int -> CInt -> ShowS # show :: CInt -> String # showList :: [CInt] -> ShowS #
Show CUInt
Methods showsPrec :: Int -> CUInt -> ShowS # show :: CUInt -> String # showList :: [CUInt] -> ShowS #
Show CLong
Methods showsPrec :: Int -> CLong -> ShowS # show :: CLong -> String # showList :: [CLong] -> ShowS #
Show CULong
Methods showsPrec :: Int -> CULong -> ShowS # show :: CULong -> String # showList :: [CULong] -> ShowS #
Show CLLong
Methods showsPrec :: Int -> CLLong -> ShowS # show :: CLLong -> String # showList :: [CLLong] -> ShowS #
Show CULLong
Methods showsPrec :: Int -> CULLong -> ShowS # show :: CULLong -> String # showList :: [CULLong] -> ShowS #
Show CFloat
Methods showsPrec :: Int -> CFloat -> ShowS # show :: CFloat -> String # showList :: [CFloat] -> ShowS #
Show CDouble
Methods showsPrec :: Int -> CDouble -> ShowS # show :: CDouble -> String # showList :: [CDouble] -> ShowS #
Show CPtrdiff
Methods showsPrec :: Int -> CPtrdiff -> ShowS # show :: CPtrdiff -> String # showList :: [CPtrdiff] -> ShowS #
Show CSize
Methods showsPrec :: Int -> CSize -> ShowS # show :: CSize -> String # showList :: [CSize] -> ShowS #
Show CWchar
Methods showsPrec :: Int -> CWchar -> ShowS # show :: CWchar -> String # showList :: [CWchar] -> ShowS #
Show CSigAtomic
Methods showsPrec :: Int -> CSigAtomic -> ShowS # show :: CSigAtomic -> String # showList :: [CSigAtomic] -> ShowS #
Show CClock
Methods showsPrec :: Int -> CClock -> ShowS # show :: CClock -> String # showList :: [CClock] -> ShowS #
Show CTime
Methods showsPrec :: Int -> CTime -> ShowS # show :: CTime -> String # showList :: [CTime] -> ShowS #
Show CUSeconds
Methods showsPrec :: Int -> CUSeconds -> ShowS # show :: CUSeconds -> String # showList :: [CUSeconds] -> ShowS #
Show CSUSeconds
Methods showsPrec :: Int -> CSUSeconds -> ShowS # show :: CSUSeconds -> String # showList :: [CSUSeconds] -> ShowS #
Show CIntPtr
Methods showsPrec :: Int -> CIntPtr -> ShowS # show :: CIntPtr -> String # showList :: [CIntPtr] -> ShowS #
Show CUIntPtr
Methods showsPrec :: Int -> CUIntPtr -> ShowS # show :: CUIntPtr -> String # showList :: [CUIntPtr] -> ShowS #
Show CIntMax
Methods showsPrec :: Int -> CIntMax -> ShowS # show :: CIntMax -> String # showList :: [CIntMax] -> ShowS #
Show CUIntMax
Methods showsPrec :: Int -> CUIntMax -> ShowS # show :: CUIntMax -> String # showList :: [CUIntMax] -> ShowS #
Show SeekMode
Methods showsPrec :: Int -> SeekMode -> ShowS # show :: SeekMode -> String # showList :: [SeekMode] -> ShowS #
Show All
Methods showsPrec :: Int -> All -> ShowS # show :: All -> String # showList :: [All] -> ShowS #
Show Any
Methods showsPrec :: Int -> Any -> ShowS # show :: Any -> String # showList :: [Any] -> ShowS #
Show Fixity
Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show Associativity
Methods showsPrec :: Int -> Associativity -> ShowS # show :: Associativity -> String # showList :: [Associativity] -> ShowS #
Show SourceUnpackedness
Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show SourceStrictness
Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show DecidedStrictness
Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show MaskingState
Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Show IOException
Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Show Dynamic
Methods showsPrec :: Int -> Dynamic -> ShowS # show :: Dynamic -> String # showList :: [Dynamic] -> ShowS #
Show ErrorCall
Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Show ArithException
Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Show Fingerprint
Methods showsPrec :: Int -> Fingerprint -> ShowS # show :: Fingerprint -> String # showList :: [Fingerprint] -> ShowS #
Show SomeNat
Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Show SomeSymbol
Methods showsPrec :: Int -> SomeSymbol -> ShowS # show :: SomeSymbol -> String # showList :: [SomeSymbol] -> ShowS #
Show IOMode
Methods showsPrec :: Int -> IOMode -> ShowS # show :: IOMode -> String # showList :: [IOMode] -> ShowS #
Show Lexeme
Methods showsPrec :: Int -> Lexeme -> ShowS # show :: Lexeme -> String # showList :: [Lexeme] -> ShowS #
Show Number
Methods showsPrec :: Int -> Number -> ShowS # show :: Number -> String # showList :: [Number] -> ShowS #
Show GeneralCategory
Methods showsPrec :: Int -> GeneralCategory -> ShowS # show :: GeneralCategory -> String # showList :: [GeneralCategory] -> ShowS #
Show SomeException
Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Show SrcLoc
Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Show ShortByteString
Methods showsPrec :: Int -> ShortByteString -> ShowS # show :: ShortByteString -> String # showList :: [ShortByteString] -> ShowS #
Show ByteString
Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show ByteString
Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show IntSet
Methods showsPrec :: Int -> IntSet -> ShowS # show :: IntSet -> String # showList :: [IntSet] -> ShowS #
Show DirectoryType
Methods showsPrec :: Int -> DirectoryType -> ShowS # show :: DirectoryType -> String # showList :: [DirectoryType] -> ShowS #
Show Permissions
Methods showsPrec :: Int -> Permissions -> ShowS # show :: Permissions -> String # showList :: [Permissions] -> ShowS #
Show XdgDirectory
Methods showsPrec :: Int -> XdgDirectory -> ShowS # show :: XdgDirectory -> String # showList :: [XdgDirectory] -> ShowS #
Show Flot
Methods showsPrec :: Int -> Flot -> ShowS # show :: Flot -> String # showList :: [Flot] -> ShowS #
Show CreateProcess
Methods showsPrec :: Int -> CreateProcess -> ShowS # show :: CreateProcess -> String # showList :: [CreateProcess] -> ShowS #
Show CmdSpec
Methods showsPrec :: Int -> CmdSpec -> ShowS # show :: CmdSpec -> String # showList :: [CmdSpec] -> ShowS #
Show StdStream
Methods showsPrec :: Int -> StdStream -> ShowS # show :: StdStream -> String # showList :: [StdStream] -> ShowS #
Show Padding
Methods showsPrec :: Int -> Padding -> ShowS # show :: Padding -> String # showList :: [Padding] -> ShowS #
Show DateFormatSpec
Methods showsPrec :: Int -> DateFormatSpec -> ShowS # show :: DateFormatSpec -> String # showList :: [DateFormatSpec] -> ShowS #
Show LocalTime
Methods showsPrec :: Int -> LocalTime -> ShowS # show :: LocalTime -> String # showList :: [LocalTime] -> ShowS #
Show ZonedTime
Methods showsPrec :: Int -> ZonedTime -> ShowS # show :: ZonedTime -> String # showList :: [ZonedTime] -> ShowS #
Show TimeOfDay
Methods showsPrec :: Int -> TimeOfDay -> ShowS # show :: TimeOfDay -> String # showList :: [TimeOfDay] -> ShowS #
Show TimeZone
Methods showsPrec :: Int -> TimeZone -> ShowS # show :: TimeZone -> String # showList :: [TimeZone] -> ShowS #
Show NominalDiffTime
Methods showsPrec :: Int -> NominalDiffTime -> ShowS # show :: NominalDiffTime -> String # showList :: [NominalDiffTime] -> ShowS #
Show DiffTime
Methods showsPrec :: Int -> DiffTime -> ShowS # show :: DiffTime -> String # showList :: [DiffTime] -> ShowS #
Show Timeout
Methods showsPrec :: Int -> Timeout -> ShowS # show :: Timeout -> String # showList :: [Timeout] -> ShowS #
Show StdGen
Methods showsPrec :: Int -> StdGen -> ShowS # show :: StdGen -> String # showList :: [StdGen] -> ShowS #
Show Color
Methods showsPrec :: Int -> Color -> ShowS # show :: Color -> String # showList :: [Color] -> ShowS #
Show Progress #
Methods showsPrec :: Int -> Progress -> ShowS # show :: Progress -> String # showList :: [Progress] -> ShowS #
Show TimeSpec
Methods showsPrec :: Int -> TimeSpec -> ShowS # show :: TimeSpec -> String # showList :: [TimeSpec] -> ShowS #
Show Clock
Methods showsPrec :: Int -> Clock -> ShowS # show :: Clock -> String # showList :: [Clock] -> ShowS #
Show Resource #
Methods showsPrec :: Int -> Resource -> ShowS # show :: Resource -> String # showList :: [Resource] -> ShowS #
Show ShakeException #
Methods showsPrec :: Int -> ShakeException -> ShowS # show :: ShakeException -> String # showList :: [ShakeException] -> ShowS #
Show CmdOption #
Methods showsPrec :: Int -> CmdOption -> ShowS # show :: CmdOption -> String # showList :: [CmdOption] -> ShowS #
Show EqualCost #
Methods showsPrec :: Int -> EqualCost -> ShowS # show :: EqualCost -> String # showList :: [EqualCost] -> ShowS #
Show Verbosity #
Methods showsPrec :: Int -> Verbosity -> ShowS # show :: Verbosity -> String # showList :: [Verbosity] -> ShowS #
Show ShakeOptions #
Methods showsPrec :: Int -> ShakeOptions -> ShowS # show :: ShakeOptions -> String # showList :: [ShakeOptions] -> ShowS #
Show Change #
Methods showsPrec :: Int -> Change -> ShowS # show :: Change -> String # showList :: [Change] -> ShowS #
Show Lint #
Methods showsPrec :: Int -> Lint -> ShowS # show :: Lint -> String # showList :: [Lint] -> ShowS #
Show Assume #
Methods showsPrec :: Int -> Assume -> ShowS # show :: Assume -> String # showList :: [Assume] -> ShowS #
Show a => Show [a]
Methods showsPrec :: Int -> [a] -> ShowS # show :: [a] -> String # showList :: [[a]] -> ShowS #
Show a => Show (Maybe a)
Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Show a => Show (Ratio a)
Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Show (Ptr a)
Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
Show (FunPtr a)
Methods showsPrec :: Int -> FunPtr a -> ShowS # show :: FunPtr a -> String # showList :: [FunPtr a] -> ShowS #
Show (V1 p)
Methods showsPrec :: Int -> V1 p -> ShowS # show :: V1 p -> String # showList :: [V1 p] -> ShowS #
Show (U1 p)
Methods showsPrec :: Int -> U1 p -> ShowS # show :: U1 p -> String # showList :: [U1 p] -> ShowS #
Show p => Show (Par1 p)
Methods showsPrec :: Int -> Par1 p -> ShowS # show :: Par1 p -> String # showList :: [Par1 p] -> ShowS #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed
Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Show a => Show (Min a)
Methods showsPrec :: Int -> Min a -> ShowS # show :: Min a -> String # showList :: [Min a] -> ShowS #
Show a => Show (Max a)
Methods showsPrec :: Int -> Max a -> ShowS # show :: Max a -> String # showList :: [Max a] -> ShowS #
Show a => Show (First a)
Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)
Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show m => Show (WrappedMonoid m)
Methods showsPrec :: Int -> WrappedMonoid m -> ShowS # show :: WrappedMonoid m -> String # showList :: [WrappedMonoid m] -> ShowS #
Show a => Show (Option a)
Methods showsPrec :: Int -> Option a -> ShowS # show :: Option a -> String # showList :: [Option a] -> ShowS #
Show a => Show (NonEmpty a)
Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
HasResolution a => Show (Fixed a)
Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed a] -> ShowS #
Show a => Show (Complex a)
Methods showsPrec :: Int -> Complex a -> ShowS # show :: Complex a -> String # showList :: [Complex a] -> ShowS #
Show a => Show (ZipList a)
Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
Show a => Show (Dual a)
Methods showsPrec :: Int -> Dual a -> ShowS # show :: Dual a -> String # showList :: [Dual a] -> ShowS #
Show a => Show (Sum a)
Methods showsPrec :: Int -> Sum a -> ShowS # show :: Sum a -> String # showList :: [Sum a] -> ShowS #
Show a => Show (Product a)
Methods showsPrec :: Int -> Product a -> ShowS # show :: Product a -> String # showList :: [Product a] -> ShowS #
Show a => Show (First a)
Methods showsPrec :: Int -> First a -> ShowS # show :: First a -> String # showList :: [First a] -> ShowS #
Show a => Show (Last a)
Methods showsPrec :: Int -> Last a -> ShowS # show :: Last a -> String # showList :: [Last a] -> ShowS #
Show a => Show (Down a)
Methods showsPrec :: Int -> Down a -> ShowS # show :: Down a -> String # showList :: [Down a] -> ShowS #
Show a => Show (Decoder a)
Methods showsPrec :: Int -> Decoder a -> ShowS # show :: Decoder a -> String # showList :: [Decoder a] -> ShowS #
Show a => Show (IntMap a)
Methods showsPrec :: Int -> IntMap a -> ShowS # show :: IntMap a -> String # showList :: [IntMap a] -> ShowS #
Show a => Show (Tree a)
Methods showsPrec :: Int -> Tree a -> ShowS # show :: Tree a -> String # showList :: [Tree a] -> ShowS #
Show a => Show (Seq a)
Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
Show a => Show (ViewL a)
Methods showsPrec :: Int -> ViewL a -> ShowS # show :: ViewL a -> String # showList :: [ViewL a] -> ShowS #
Show a => Show (ViewR a)
Methods showsPrec :: Int -> ViewR a -> ShowS # show :: ViewR a -> String # showList :: [ViewR a] -> ShowS #
Show a => Show (Set a)
Methods showsPrec :: Int -> Set a -> ShowS # show :: Set a -> String # showList :: [Set a] -> ShowS #
Show a => Show (RB a)
Methods showsPrec :: Int -> RB a -> ShowS # show :: RB a -> String # showList :: [RB a] -> ShowS #
Show a => Show (Hashed a)
Methods showsPrec :: Int -> Hashed a -> ShowS # show :: Hashed a -> String # showList :: [Hashed a] -> ShowS #
Show a => Show (HashSet a)
Methods showsPrec :: Int -> HashSet a -> ShowS # show :: HashSet a -> String # showList :: [HashSet a] -> ShowS #
(Show b, Show a) => Show (Either a b)
Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
Show (f p) => Show (Rec1 f p)
Methods showsPrec :: Int -> Rec1 f p -> ShowS # show :: Rec1 f p -> String # showList :: [Rec1 f p] -> ShowS #
Show (URec Char p)
Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Show (URec Double p)
Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Show (URec Float p)
Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Show (URec Int p)
Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Show (URec Word p)
Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
(Show a, Show b) => Show (a, b)
Methods showsPrec :: Int -> (a, b) -> ShowS # show :: (a, b) -> String # showList :: [(a, b)] -> ShowS #
(Ix ix, Show ix, Show e, IArray UArray e) => Show (UArray ix e)
Methods showsPrec :: Int -> UArray ix e -> ShowS # show :: UArray ix e -> String # showList :: [UArray ix e] -> ShowS #
(Ix a, Show a, Show b) => Show (Array a b)
Methods showsPrec :: Int -> Array a b -> ShowS # show :: Array a b -> String # showList :: [Array a b] -> ShowS #
(Show b, Show a) => Show (Arg a b)
Methods showsPrec :: Int -> Arg a b -> ShowS # show :: Arg a b -> String # showList :: [Arg a b] -> ShowS #
Show (Proxy k s)
Methods showsPrec :: Int -> Proxy k s -> ShowS # show :: Proxy k s -> String # showList :: [Proxy k s] -> ShowS #
(Show k, Show a) => Show (Map k a)
Methods showsPrec :: Int -> Map k a -> ShowS # show :: Map k a -> String # showList :: [Map k a] -> ShowS #
(Show k, Show v) => Show (HashMap k v)
Methods showsPrec :: Int -> HashMap k v -> ShowS # show :: HashMap k v -> String # showList :: [HashMap k v] -> ShowS #
Show c => Show (K1 i c p)
Methods showsPrec :: Int -> K1 i c p -> ShowS # show :: K1 i c p -> String # showList :: [K1 i c p] -> ShowS #
(Show (g p), Show (f p)) => Show ((:+:) f g p)
Methods showsPrec :: Int -> (f :+: g) p -> ShowS # show :: (f :+: g) p -> String # showList :: [(f :+: g) p] -> ShowS #
(Show (g p), Show (f p)) => Show ((:*:) f g p)
Methods showsPrec :: Int -> (f :: g) p -> ShowS # show :: (f :: g) p -> String # showList :: [(f :*: g) p] -> ShowS #
Show (f (g p)) => Show ((:.:) f g p)
Methods showsPrec :: Int -> (f :.: g) p -> ShowS # show :: (f :.: g) p -> String # showList :: [(f :.: g) p] -> ShowS #
(Show a, Show b, Show c) => Show (a, b, c)
Methods showsPrec :: Int -> (a, b, c) -> ShowS # show :: (a, b, c) -> String # showList :: [(a, b, c)] -> ShowS #
Show a => Show (Const k a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `runConst` field were removed
Methods showsPrec :: Int -> Const k a b -> ShowS # show :: Const k a b -> String # showList :: [Const k a b] -> ShowS #
Show (f a) => Show (Alt k f a)
Methods showsPrec :: Int -> Alt k f a -> ShowS # show :: Alt k f a -> String # showList :: [Alt k f a] -> ShowS #
Show ((:~:) k a b)
Methods showsPrec :: Int -> (k :~: a) b -> ShowS # show :: (k :~: a) b -> String # showList :: [(k :~: a) b] -> ShowS #
(Show w, Show1 m, Show a) => Show (WriterT w m a)
Methods showsPrec :: Int -> WriterT w m a -> ShowS # show :: WriterT w m a -> String # showList :: [WriterT w m a] -> ShowS #
Show (f p) => Show (M1 i c f p)
Methods showsPrec :: Int -> M1 i c f p -> ShowS # show :: M1 i c f p -> String # showList :: [M1 i c f p] -> ShowS #
(Show a, Show b, Show c, Show d) => Show (a, b, c, d)
Methods showsPrec :: Int -> (a, b, c, d) -> ShowS # show :: (a, b, c, d) -> String # showList :: [(a, b, c, d)] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Sum * f g a)
Methods showsPrec :: Int -> Sum * f g a -> ShowS # show :: Sum * f g a -> String # showList :: [Sum * f g a] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Product * f g a)
Methods showsPrec :: Int -> Product * f g a -> ShowS # show :: Product * f g a -> String # showList :: [Product * f g a] -> ShowS #
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)
Methods showsPrec :: Int -> (a, b, c, d, e) -> ShowS # show :: (a, b, c, d, e) -> String # showList :: [(a, b, c, d, e)] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Compose * * f g a)
Methods showsPrec :: Int -> Compose * * f g a -> ShowS # show :: Compose * * f g a -> String # showList :: [Compose * * f g a] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f)
Methods showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS # show :: (a, b, c, d, e, f) -> String # showList :: [(a, b, c, d, e, f)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS # show :: (a, b, c, d, e, f, g) -> String # showList :: [(a, b, c, d, e, f, g)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS # show :: (a, b, c, d, e, f, g, h) -> String # showList :: [(a, b, c, d, e, f, g, h)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS # show :: (a, b, c, d, e, f, g, h, i) -> String # showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS #
(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)
Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS #

class Typeable k a #

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

class Eq a where #

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4 #

(/=) :: a -> a -> Bool infix 4 #

Instances

Eq Bool
Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char
Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double
Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float
Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int
Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Int8
Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq Int16
Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Integer
Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Ordering
Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq Word
Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq Word8
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Word16
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq TypeRep
Methods (==) :: TypeRep -> TypeRep -> Bool # (/=) :: TypeRep -> TypeRep -> Bool #
Eq ()
Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq TyCon
Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq Handle
Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #
Eq BigNat
Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq SpecConstrAnnotation
Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Natural
Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Eq Void
Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq Constr	Equality of constructors
Methods (==) :: Constr -> Constr -> Bool # (/=) :: Constr -> Constr -> Bool #
Eq DataRep
Methods (==) :: DataRep -> DataRep -> Bool # (/=) :: DataRep -> DataRep -> Bool #
Eq ConstrRep
Methods (==) :: ConstrRep -> ConstrRep -> Bool # (/=) :: ConstrRep -> ConstrRep -> Bool #
Eq Fixity
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Version
Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq Unique
Methods (==) :: Unique -> Unique -> Bool # (/=) :: Unique -> Unique -> Bool #
Eq HandlePosn
Methods (==) :: HandlePosn -> HandlePosn -> Bool # (/=) :: HandlePosn -> HandlePosn -> Bool #
Eq CDev
Methods (==) :: CDev -> CDev -> Bool # (/=) :: CDev -> CDev -> Bool #
Eq CIno
Methods (==) :: CIno -> CIno -> Bool # (/=) :: CIno -> CIno -> Bool #
Eq CMode
Methods (==) :: CMode -> CMode -> Bool # (/=) :: CMode -> CMode -> Bool #
Eq COff
Methods (==) :: COff -> COff -> Bool # (/=) :: COff -> COff -> Bool #
Eq CPid
Methods (==) :: CPid -> CPid -> Bool # (/=) :: CPid -> CPid -> Bool #
Eq CSsize
Methods (==) :: CSsize -> CSsize -> Bool # (/=) :: CSsize -> CSsize -> Bool #
Eq CGid
Methods (==) :: CGid -> CGid -> Bool # (/=) :: CGid -> CGid -> Bool #
Eq CNlink
Methods (==) :: CNlink -> CNlink -> Bool # (/=) :: CNlink -> CNlink -> Bool #
Eq CUid
Methods (==) :: CUid -> CUid -> Bool # (/=) :: CUid -> CUid -> Bool #
Eq CCc
Methods (==) :: CCc -> CCc -> Bool # (/=) :: CCc -> CCc -> Bool #
Eq CSpeed
Methods (==) :: CSpeed -> CSpeed -> Bool # (/=) :: CSpeed -> CSpeed -> Bool #
Eq CTcflag
Methods (==) :: CTcflag -> CTcflag -> Bool # (/=) :: CTcflag -> CTcflag -> Bool #
Eq CRLim
Methods (==) :: CRLim -> CRLim -> Bool # (/=) :: CRLim -> CRLim -> Bool #
Eq Fd
Methods (==) :: Fd -> Fd -> Bool # (/=) :: Fd -> Fd -> Bool #
Eq ThreadId
Methods (==) :: ThreadId -> ThreadId -> Bool # (/=) :: ThreadId -> ThreadId -> Bool #
Eq BlockReason
Methods (==) :: BlockReason -> BlockReason -> Bool # (/=) :: BlockReason -> BlockReason -> Bool #
Eq ThreadStatus
Methods (==) :: ThreadStatus -> ThreadStatus -> Bool # (/=) :: ThreadStatus -> ThreadStatus -> Bool #
Eq Errno
Methods (==) :: Errno -> Errno -> Bool # (/=) :: Errno -> Errno -> Bool #
Eq AsyncException
Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Eq ArrayException
Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Eq ExitCode
Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Eq IOErrorType
Methods (==) :: IOErrorType -> IOErrorType -> Bool # (/=) :: IOErrorType -> IOErrorType -> Bool #
Eq BufferMode
Methods (==) :: BufferMode -> BufferMode -> Bool # (/=) :: BufferMode -> BufferMode -> Bool #
Eq Newline
Methods (==) :: Newline -> Newline -> Bool # (/=) :: Newline -> Newline -> Bool #
Eq NewlineMode
Methods (==) :: NewlineMode -> NewlineMode -> Bool # (/=) :: NewlineMode -> NewlineMode -> Bool #
Eq WordPtr
Methods (==) :: WordPtr -> WordPtr -> Bool # (/=) :: WordPtr -> WordPtr -> Bool #
Eq IntPtr
Methods (==) :: IntPtr -> IntPtr -> Bool # (/=) :: IntPtr -> IntPtr -> Bool #
Eq CChar
Methods (==) :: CChar -> CChar -> Bool # (/=) :: CChar -> CChar -> Bool #
Eq CSChar
Methods (==) :: CSChar -> CSChar -> Bool # (/=) :: CSChar -> CSChar -> Bool #
Eq CUChar
Methods (==) :: CUChar -> CUChar -> Bool # (/=) :: CUChar -> CUChar -> Bool #
Eq CShort
Methods (==) :: CShort -> CShort -> Bool # (/=) :: CShort -> CShort -> Bool #
Eq CUShort
Methods (==) :: CUShort -> CUShort -> Bool # (/=) :: CUShort -> CUShort -> Bool #
Eq CInt
Methods (==) :: CInt -> CInt -> Bool # (/=) :: CInt -> CInt -> Bool #
Eq CUInt
Methods (==) :: CUInt -> CUInt -> Bool # (/=) :: CUInt -> CUInt -> Bool #
Eq CLong
Methods (==) :: CLong -> CLong -> Bool # (/=) :: CLong -> CLong -> Bool #
Eq CULong
Methods (==) :: CULong -> CULong -> Bool # (/=) :: CULong -> CULong -> Bool #
Eq CLLong
Methods (==) :: CLLong -> CLLong -> Bool # (/=) :: CLLong -> CLLong -> Bool #
Eq CULLong
Methods (==) :: CULLong -> CULLong -> Bool # (/=) :: CULLong -> CULLong -> Bool #
Eq CFloat
Methods (==) :: CFloat -> CFloat -> Bool # (/=) :: CFloat -> CFloat -> Bool #
Eq CDouble
Methods (==) :: CDouble -> CDouble -> Bool # (/=) :: CDouble -> CDouble -> Bool #
Eq CPtrdiff
Methods (==) :: CPtrdiff -> CPtrdiff -> Bool # (/=) :: CPtrdiff -> CPtrdiff -> Bool #
Eq CSize
Methods (==) :: CSize -> CSize -> Bool # (/=) :: CSize -> CSize -> Bool #
Eq CWchar
Methods (==) :: CWchar -> CWchar -> Bool # (/=) :: CWchar -> CWchar -> Bool #
Eq CSigAtomic
Methods (==) :: CSigAtomic -> CSigAtomic -> Bool # (/=) :: CSigAtomic -> CSigAtomic -> Bool #
Eq CClock
Methods (==) :: CClock -> CClock -> Bool # (/=) :: CClock -> CClock -> Bool #
Eq CTime
Methods (==) :: CTime -> CTime -> Bool # (/=) :: CTime -> CTime -> Bool #
Eq CUSeconds
Methods (==) :: CUSeconds -> CUSeconds -> Bool # (/=) :: CUSeconds -> CUSeconds -> Bool #
Eq CSUSeconds
Methods (==) :: CSUSeconds -> CSUSeconds -> Bool # (/=) :: CSUSeconds -> CSUSeconds -> Bool #
Eq CIntPtr
Methods (==) :: CIntPtr -> CIntPtr -> Bool # (/=) :: CIntPtr -> CIntPtr -> Bool #
Eq CUIntPtr
Methods (==) :: CUIntPtr -> CUIntPtr -> Bool # (/=) :: CUIntPtr -> CUIntPtr -> Bool #
Eq CIntMax
Methods (==) :: CIntMax -> CIntMax -> Bool # (/=) :: CIntMax -> CIntMax -> Bool #
Eq CUIntMax
Methods (==) :: CUIntMax -> CUIntMax -> Bool # (/=) :: CUIntMax -> CUIntMax -> Bool #
Eq IODeviceType
Methods (==) :: IODeviceType -> IODeviceType -> Bool # (/=) :: IODeviceType -> IODeviceType -> Bool #
Eq SeekMode
Methods (==) :: SeekMode -> SeekMode -> Bool # (/=) :: SeekMode -> SeekMode -> Bool #
Eq All
Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any
Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq Fixity
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Associativity
Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq SourceUnpackedness
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq MaskingState
Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq IOException
Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Eq ErrorCall
Methods (==) :: ErrorCall -> ErrorCall -> Bool # (/=) :: ErrorCall -> ErrorCall -> Bool #
Eq ArithException
Methods (==) :: ArithException -> ArithException -> Bool # (/=) :: ArithException -> ArithException -> Bool #
Eq Fingerprint
Methods (==) :: Fingerprint -> Fingerprint -> Bool # (/=) :: Fingerprint -> Fingerprint -> Bool #
Eq SomeNat
Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Eq SomeSymbol
Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Eq IOMode
Methods (==) :: IOMode -> IOMode -> Bool # (/=) :: IOMode -> IOMode -> Bool #
Eq Lexeme
Methods (==) :: Lexeme -> Lexeme -> Bool # (/=) :: Lexeme -> Lexeme -> Bool #
Eq Number
Methods (==) :: Number -> Number -> Bool # (/=) :: Number -> Number -> Bool #
Eq GeneralCategory
Methods (==) :: GeneralCategory -> GeneralCategory -> Bool # (/=) :: GeneralCategory -> GeneralCategory -> Bool #
Eq SrcLoc
Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq ShortByteString
Methods (==) :: ShortByteString -> ShortByteString -> Bool # (/=) :: ShortByteString -> ShortByteString -> Bool #
Eq ByteString
Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq ByteString
Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq IntSet
Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Eq DirectoryType
Methods (==) :: DirectoryType -> DirectoryType -> Bool # (/=) :: DirectoryType -> DirectoryType -> Bool #
Eq Permissions
Methods (==) :: Permissions -> Permissions -> Bool # (/=) :: Permissions -> Permissions -> Bool #
Eq XdgDirectory
Methods (==) :: XdgDirectory -> XdgDirectory -> Bool # (/=) :: XdgDirectory -> XdgDirectory -> Bool #
Eq Flot
Methods (==) :: Flot -> Flot -> Bool # (/=) :: Flot -> Flot -> Bool #
Eq CreateProcess
Methods (==) :: CreateProcess -> CreateProcess -> Bool # (/=) :: CreateProcess -> CreateProcess -> Bool #
Eq CmdSpec
Methods (==) :: CmdSpec -> CmdSpec -> Bool # (/=) :: CmdSpec -> CmdSpec -> Bool #
Eq StdStream
Methods (==) :: StdStream -> StdStream -> Bool # (/=) :: StdStream -> StdStream -> Bool #
Eq LocalTime
Methods (==) :: LocalTime -> LocalTime -> Bool # (/=) :: LocalTime -> LocalTime -> Bool #
Eq TimeOfDay
Methods (==) :: TimeOfDay -> TimeOfDay -> Bool # (/=) :: TimeOfDay -> TimeOfDay -> Bool #
Eq TimeZone
Methods (==) :: TimeZone -> TimeZone -> Bool # (/=) :: TimeZone -> TimeZone -> Bool #
Eq UTCTime
Methods (==) :: UTCTime -> UTCTime -> Bool # (/=) :: UTCTime -> UTCTime -> Bool #
Eq NominalDiffTime
Methods (==) :: NominalDiffTime -> NominalDiffTime -> Bool # (/=) :: NominalDiffTime -> NominalDiffTime -> Bool #
Eq Day
Methods (==) :: Day -> Day -> Bool # (/=) :: Day -> Day -> Bool #
Eq UniversalTime
Methods (==) :: UniversalTime -> UniversalTime -> Bool # (/=) :: UniversalTime -> UniversalTime -> Bool #
Eq DiffTime
Methods (==) :: DiffTime -> DiffTime -> Bool # (/=) :: DiffTime -> DiffTime -> Bool #
Eq Timeout
Methods (==) :: Timeout -> Timeout -> Bool # (/=) :: Timeout -> Timeout -> Bool #
Eq Progress #
Methods (==) :: Progress -> Progress -> Bool # (/=) :: Progress -> Progress -> Bool #
Eq TimeSpec
Methods (==) :: TimeSpec -> TimeSpec -> Bool # (/=) :: TimeSpec -> TimeSpec -> Bool #
Eq Clock
Methods (==) :: Clock -> Clock -> Bool # (/=) :: Clock -> Clock -> Bool #
Eq Resource #
Methods (==) :: Resource -> Resource -> Bool # (/=) :: Resource -> Resource -> Bool #
Eq CmdOption #
Methods (==) :: CmdOption -> CmdOption -> Bool # (/=) :: CmdOption -> CmdOption -> Bool #
Eq EqualCost #
Methods (==) :: EqualCost -> EqualCost -> Bool # (/=) :: EqualCost -> EqualCost -> Bool #
Eq Verbosity #
Methods (==) :: Verbosity -> Verbosity -> Bool # (/=) :: Verbosity -> Verbosity -> Bool #
Eq Change #
Methods (==) :: Change -> Change -> Bool # (/=) :: Change -> Change -> Bool #
Eq Lint #
Methods (==) :: Lint -> Lint -> Bool # (/=) :: Lint -> Lint -> Bool #
Eq Assume #
Methods (==) :: Assume -> Assume -> Bool # (/=) :: Assume -> Assume -> Bool #
Eq a => Eq [a]
Methods (==) :: [a] -> [a] -> Bool # (/=) :: [a] -> [a] -> Bool #
Eq a => Eq (Maybe a)
Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq a => Eq (Ratio a)
Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Eq (Ptr a)
Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Eq (FunPtr a)
Methods (==) :: FunPtr a -> FunPtr a -> Bool # (/=) :: FunPtr a -> FunPtr a -> Bool #
Eq (V1 p)
Methods (==) :: V1 p -> V1 p -> Bool # (/=) :: V1 p -> V1 p -> Bool #
Eq (U1 p)
Methods (==) :: U1 p -> U1 p -> Bool # (/=) :: U1 p -> U1 p -> Bool #
Eq p => Eq (Par1 p)
Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq a => Eq (Identity a)
Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq a => Eq (Min a)
Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Eq a => Eq (Max a)
Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Eq a => Eq (First a)
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq m => Eq (WrappedMonoid m)
Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Eq a => Eq (Option a)
Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Eq a => Eq (NonEmpty a)
Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq (Fixed a)
Methods (==) :: Fixed a -> Fixed a -> Bool # (/=) :: Fixed a -> Fixed a -> Bool #
Eq a => Eq (Complex a)
Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
Eq (StableName a)
Methods (==) :: StableName a -> StableName a -> Bool # (/=) :: StableName a -> StableName a -> Bool #
Eq (Chan a)
Methods (==) :: Chan a -> Chan a -> Bool # (/=) :: Chan a -> Chan a -> Bool #
Eq a => Eq (ZipList a)
Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq (TVar a)
Methods (==) :: TVar a -> TVar a -> Bool # (/=) :: TVar a -> TVar a -> Bool #
Eq a => Eq (Dual a)
Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Eq a => Eq (Sum a)
Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Eq a => Eq (Product a)
Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Eq a => Eq (First a)
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq (IORef a)
Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef a -> Bool #
Eq a => Eq (Down a)
Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Eq (MVar a)
Methods (==) :: MVar a -> MVar a -> Bool # (/=) :: MVar a -> MVar a -> Bool #
Eq a => Eq (IntMap a)
Methods (==) :: IntMap a -> IntMap a -> Bool # (/=) :: IntMap a -> IntMap a -> Bool #
Eq a => Eq (Tree a)
Methods (==) :: Tree a -> Tree a -> Bool # (/=) :: Tree a -> Tree a -> Bool #
Eq a => Eq (Seq a)
Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Eq a => Eq (ViewL a)
Methods (==) :: ViewL a -> ViewL a -> Bool # (/=) :: ViewL a -> ViewL a -> Bool #
Eq a => Eq (ViewR a)
Methods (==) :: ViewR a -> ViewR a -> Bool # (/=) :: ViewR a -> ViewR a -> Bool #
Eq a => Eq (Set a)
Methods (==) :: Set a -> Set a -> Bool # (/=) :: Set a -> Set a -> Bool #
Eq a => Eq (Hashed a)
Methods (==) :: Hashed a -> Hashed a -> Bool # (/=) :: Hashed a -> Hashed a -> Bool #
(Hashable a, Eq a) => Eq (HashSet a)
Methods (==) :: HashSet a -> HashSet a -> Bool # (/=) :: HashSet a -> HashSet a -> Bool #
(Eq b, Eq a) => Eq (Either a b)
Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
Eq (f p) => Eq (Rec1 f p)
Methods (==) :: Rec1 f p -> Rec1 f p -> Bool # (/=) :: Rec1 f p -> Rec1 f p -> Bool #
Eq (URec Char p)
Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Eq (URec Double p)
Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Eq (URec Float p)
Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Eq (URec Int p)
Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Eq (URec Word p)
Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Eq (URec (Ptr ()) p)
Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
(Eq a, Eq b) => Eq (a, b)
Methods (==) :: (a, b) -> (a, b) -> Bool # (/=) :: (a, b) -> (a, b) -> Bool #
(Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e)
Methods (==) :: UArray ix e -> UArray ix e -> Bool # (/=) :: UArray ix e -> UArray ix e -> Bool #
(Ix i, Eq e) => Eq (Array i e)
Methods (==) :: Array i e -> Array i e -> Bool # (/=) :: Array i e -> Array i e -> Bool #
Eq a => Eq (Arg a b)
Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (Proxy k s)
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
Eq (STRef s a)
Methods (==) :: STRef s a -> STRef s a -> Bool # (/=) :: STRef s a -> STRef s a -> Bool #
(Eq k, Eq a) => Eq (Map k a)
Methods (==) :: Map k a -> Map k a -> Bool # (/=) :: Map k a -> Map k a -> Bool #
(Eq v, Eq k) => Eq (Leaf k v)
Methods (==) :: Leaf k v -> Leaf k v -> Bool # (/=) :: Leaf k v -> Leaf k v -> Bool #
(Eq k, Eq v) => Eq (HashMap k v)
Methods (==) :: HashMap k v -> HashMap k v -> Bool # (/=) :: HashMap k v -> HashMap k v -> Bool #
Eq c => Eq (K1 i c p)
Methods (==) :: K1 i c p -> K1 i c p -> Bool # (/=) :: K1 i c p -> K1 i c p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:+:) f g p)
Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:*:) f g p)
Methods (==) :: (f :: g) p -> (f :: g) p -> Bool # (/=) :: (f :: g) p -> (f :: g) p -> Bool #
Eq (f (g p)) => Eq ((:.:) f g p)
Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool #
(Eq a, Eq b, Eq c) => Eq (a, b, c)
Methods (==) :: (a, b, c) -> (a, b, c) -> Bool # (/=) :: (a, b, c) -> (a, b, c) -> Bool #
Eq (STUArray s i e)
Methods (==) :: STUArray s i e -> STUArray s i e -> Bool # (/=) :: STUArray s i e -> STUArray s i e -> Bool #
Eq (STArray s i e)
Methods (==) :: STArray s i e -> STArray s i e -> Bool # (/=) :: STArray s i e -> STArray s i e -> Bool #
Eq a => Eq (Const k a b)
Methods (==) :: Const k a b -> Const k a b -> Bool # (/=) :: Const k a b -> Const k a b -> Bool #
Eq (f a) => Eq (Alt k f a)
Methods (==) :: Alt k f a -> Alt k f a -> Bool # (/=) :: Alt k f a -> Alt k f a -> Bool #
Eq ((:~:) k a b)
Methods (==) :: (k :~: a) b -> (k :~: a) b -> Bool # (/=) :: (k :~: a) b -> (k :~: a) b -> Bool #
(Eq w, Eq1 m, Eq a) => Eq (WriterT w m a)
Methods (==) :: WriterT w m a -> WriterT w m a -> Bool # (/=) :: WriterT w m a -> WriterT w m a -> Bool #
Eq (f p) => Eq (M1 i c f p)
Methods (==) :: M1 i c f p -> M1 i c f p -> Bool # (/=) :: M1 i c f p -> M1 i c f p -> Bool #
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
Methods (==) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a)
Methods (==) :: Sum * f g a -> Sum * f g a -> Bool # (/=) :: Sum * f g a -> Sum * f g a -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Product * f g a)
Methods (==) :: Product * f g a -> Product * f g a -> Bool # (/=) :: Product * f g a -> Product * f g a -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
Methods (==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose * * f g a)
Methods (==) :: Compose * * f g a -> Compose * * f g a -> Bool # (/=) :: Compose * * f g a -> Compose * * f g a -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)
Methods (==) :: (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 #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #
(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)
Methods (==) :: (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 #

class Hashable a where #

Methods

hashWithSalt :: Int -> a -> Int #

hash :: a -> Int #

Instances

Hashable Bool
Methods hashWithSalt :: Int -> Bool -> Int # hash :: Bool -> Int #
Hashable Char
Methods hashWithSalt :: Int -> Char -> Int # hash :: Char -> Int #
Hashable Double
Methods hashWithSalt :: Int -> Double -> Int # hash :: Double -> Int #
Hashable Float
Methods hashWithSalt :: Int -> Float -> Int # hash :: Float -> Int #
Hashable Int
Methods hashWithSalt :: Int -> Int -> Int # hash :: Int -> Int #
Hashable Int8
Methods hashWithSalt :: Int -> Int8 -> Int # hash :: Int8 -> Int #
Hashable Int16
Methods hashWithSalt :: Int -> Int16 -> Int # hash :: Int16 -> Int #
Hashable Int32
Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
Hashable Int64
Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
Hashable Integer
Methods hashWithSalt :: Int -> Integer -> Int # hash :: Integer -> Int #
Hashable Ordering
Methods hashWithSalt :: Int -> Ordering -> Int # hash :: Ordering -> Int #
Hashable Word
Methods hashWithSalt :: Int -> Word -> Int # hash :: Word -> Int #
Hashable Word8
Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Hashable Word16
Methods hashWithSalt :: Int -> Word16 -> Int # hash :: Word16 -> Int #
Hashable Word32
Methods hashWithSalt :: Int -> Word32 -> Int # hash :: Word32 -> Int #
Hashable Word64
Methods hashWithSalt :: Int -> Word64 -> Int # hash :: Word64 -> Int #
Hashable TypeRep
Methods hashWithSalt :: Int -> TypeRep -> Int # hash :: TypeRep -> Int #
Hashable ()
Methods hashWithSalt :: Int -> () -> Int # hash :: () -> Int #
Hashable BigNat
Methods hashWithSalt :: Int -> BigNat -> Int # hash :: BigNat -> Int #
Hashable Natural
Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> Int #
Hashable Void
Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
Hashable Version
Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
Hashable Unique
Methods hashWithSalt :: Int -> Unique -> Int # hash :: Unique -> Int #
Hashable ThreadId
Methods hashWithSalt :: Int -> ThreadId -> Int # hash :: ThreadId -> Int #
Hashable WordPtr
Methods hashWithSalt :: Int -> WordPtr -> Int # hash :: WordPtr -> Int #
Hashable IntPtr
Methods hashWithSalt :: Int -> IntPtr -> Int # hash :: IntPtr -> Int #
Hashable ShortByteString
Methods hashWithSalt :: Int -> ShortByteString -> Int # hash :: ShortByteString -> Int #
Hashable ByteString
Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable ByteString
Methods hashWithSalt :: Int -> ByteString -> Int # hash :: ByteString -> Int #
Hashable Text
Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable Text
Methods hashWithSalt :: Int -> Text -> Int # hash :: Text -> Int #
Hashable a => Hashable [a]
Methods hashWithSalt :: Int -> [a] -> Int # hash :: [a] -> Int #
Hashable a => Hashable (Maybe a)
Methods hashWithSalt :: Int -> Maybe a -> Int # hash :: Maybe a -> Int #
Hashable a => Hashable (Ratio a)
Methods hashWithSalt :: Int -> Ratio a -> Int # hash :: Ratio a -> Int #
Hashable (Ptr a)
Methods hashWithSalt :: Int -> Ptr a -> Int # hash :: Ptr a -> Int #
Hashable (FunPtr a)
Methods hashWithSalt :: Int -> FunPtr a -> Int # hash :: FunPtr a -> Int #
Hashable a => Hashable (Identity a)
Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Hashable a => Hashable (Min a)
Methods hashWithSalt :: Int -> Min a -> Int # hash :: Min a -> Int #
Hashable a => Hashable (Max a)
Methods hashWithSalt :: Int -> Max a -> Int # hash :: Max a -> Int #
Hashable a => Hashable (First a)
Methods hashWithSalt :: Int -> First a -> Int # hash :: First a -> Int #
Hashable a => Hashable (Last a)
Methods hashWithSalt :: Int -> Last a -> Int # hash :: Last a -> Int #
Hashable a => Hashable (WrappedMonoid a)
Methods hashWithSalt :: Int -> WrappedMonoid a -> Int # hash :: WrappedMonoid a -> Int #
Hashable a => Hashable (Option a)
Methods hashWithSalt :: Int -> Option a -> Int # hash :: Option a -> Int #
Hashable a => Hashable (NonEmpty a)
Methods hashWithSalt :: Int -> NonEmpty a -> Int # hash :: NonEmpty a -> Int #
Hashable (Fixed a)
Methods hashWithSalt :: Int -> Fixed a -> Int # hash :: Fixed a -> Int #
Hashable (StableName a)
Methods hashWithSalt :: Int -> StableName a -> Int # hash :: StableName a -> Int #
Hashable (Hashed a)
Methods hashWithSalt :: Int -> Hashed a -> Int # hash :: Hashed a -> Int #
Hashable a => Hashable (HashSet a)
Methods hashWithSalt :: Int -> HashSet a -> Int # hash :: HashSet a -> Int #
(Hashable a, Hashable b) => Hashable (Either a b)
Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
(Hashable a1, Hashable a2) => Hashable (a1, a2)
Methods hashWithSalt :: Int -> (a1, a2) -> Int # hash :: (a1, a2) -> Int #
(Hashable a, Hashable b) => Hashable (Arg a b)
Methods hashWithSalt :: Int -> Arg a b -> Int # hash :: Arg a b -> Int #
Hashable (Proxy * a)
Methods hashWithSalt :: Int -> Proxy * a -> Int # hash :: Proxy * a -> Int #
(Hashable k, Hashable v) => Hashable (HashMap k v)
Methods hashWithSalt :: Int -> HashMap k v -> Int # hash :: HashMap k v -> Int #
(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3)
Methods hashWithSalt :: Int -> (a1, a2, a3) -> Int # hash :: (a1, a2, a3) -> Int #
Hashable a => Hashable (Const * a b)
Methods hashWithSalt :: Int -> Const * a b -> Int # hash :: Const * a b -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4)
Methods hashWithSalt :: Int -> (a1, a2, a3, a4) -> Int # hash :: (a1, a2, a3, a4) -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Sum * f g a)
Methods hashWithSalt :: Int -> Sum * f g a -> Int # hash :: Sum * f g a -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Product * f g a)
Methods hashWithSalt :: Int -> Product * f g a -> Int # hash :: Product * f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5)
Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5) -> Int # hash :: (a1, a2, a3, a4, a5) -> Int #
(Hashable1 f, Hashable1 g, Hashable a) => Hashable (Compose * * f g a)
Methods hashWithSalt :: Int -> Compose * * f g a -> Int # hash :: Compose * * f g a -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6)
Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6) -> Int # hash :: (a1, a2, a3, a4, a5, a6) -> Int #
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7)
Methods hashWithSalt :: Int -> (a1, a2, a3, a4, a5, a6, a7) -> Int # hash :: (a1, a2, a3, a4, a5, a6, a7) -> Int #

class Binary t where #

The Binary class provides put and get, methods to encode and decode a Haskell value to a lazy ByteString. It mirrors the Read and Show classes for textual representation of Haskell types, and is suitable for serialising Haskell values to disk, over the network.

For decoding and generating simple external binary formats (e.g. C structures), Binary may be used, but in general is not suitable for complex protocols. Instead use the Put and Get primitives directly.

Instances of Binary should satisfy the following property:

decode . encode == id

That is, the get and put methods should be the inverse of each other. A range of instances are provided for basic Haskell types.

Methods

put :: t -> Put #

Encode a value in the Put monad.

get :: Get t #

Decode a value in the Get monad

putList :: [t] -> Put #

Encode a list of values in the Put monad. The default implementation may be overridden to be more efficient but must still have the same encoding format.

Instances

Binary Bool
Methods put :: Bool -> Put # get :: Get Bool # putList :: [Bool] -> Put #
Binary Char
Methods put :: Char -> Put # get :: Get Char # putList :: [Char] -> Put #
Binary Double
Methods put :: Double -> Put # get :: Get Double # putList :: [Double] -> Put #
Binary Float
Methods put :: Float -> Put # get :: Get Float # putList :: [Float] -> Put #
Binary Int
Methods put :: Int -> Put # get :: Get Int # putList :: [Int] -> Put #
Binary Int8
Methods put :: Int8 -> Put # get :: Get Int8 # putList :: [Int8] -> Put #
Binary Int16
Methods put :: Int16 -> Put # get :: Get Int16 # putList :: [Int16] -> Put #
Binary Int32
Methods put :: Int32 -> Put # get :: Get Int32 # putList :: [Int32] -> Put #
Binary Int64
Methods put :: Int64 -> Put # get :: Get Int64 # putList :: [Int64] -> Put #
Binary Integer
Methods put :: Integer -> Put # get :: Get Integer # putList :: [Integer] -> Put #
Binary Ordering
Methods put :: Ordering -> Put # get :: Get Ordering # putList :: [Ordering] -> Put #
Binary Word
Methods put :: Word -> Put # get :: Get Word # putList :: [Word] -> Put #
Binary Word8
Methods put :: Word8 -> Put # get :: Get Word8 # putList :: [Word8] -> Put #
Binary Word16
Methods put :: Word16 -> Put # get :: Get Word16 # putList :: [Word16] -> Put #
Binary Word32
Methods put :: Word32 -> Put # get :: Get Word32 # putList :: [Word32] -> Put #
Binary Word64
Methods put :: Word64 -> Put # get :: Get Word64 # putList :: [Word64] -> Put #
Binary ()
Methods put :: () -> Put # get :: Get () # putList :: [()] -> Put #
Binary Natural	Since: 0.7.3.0
Methods put :: Natural -> Put # get :: Get Natural # putList :: [Natural] -> Put #
Binary Void	Since: 0.8.0.0
Methods put :: Void -> Put # get :: Get Void # putList :: [Void] -> Put #
Binary Version	Since: 0.8.0.0
Methods put :: Version -> Put # get :: Get Version # putList :: [Version] -> Put #
Binary Fingerprint	Since: 0.7.6.0
Methods put :: Fingerprint -> Put # get :: Get Fingerprint # putList :: [Fingerprint] -> Put #
Binary ShortByteString
Methods put :: ShortByteString -> Put # get :: Get ShortByteString # putList :: [ShortByteString] -> Put #
Binary ByteString
Methods put :: ByteString -> Put # get :: Get ByteString # putList :: [ByteString] -> Put #
Binary ByteString
Methods put :: ByteString -> Put # get :: Get ByteString # putList :: [ByteString] -> Put #
Binary IntSet
Methods put :: IntSet -> Put # get :: Get IntSet # putList :: [IntSet] -> Put #
Binary a => Binary [a]
Methods put :: [a] -> Put # get :: Get [a] # putList :: [[a]] -> Put #
Binary a => Binary (Maybe a)
Methods put :: Maybe a -> Put # get :: Get (Maybe a) # putList :: [Maybe a] -> Put #
(Binary a, Integral a) => Binary (Ratio a)
Methods put :: Ratio a -> Put # get :: Get (Ratio a) # putList :: [Ratio a] -> Put #
Binary (Fixed a)	Since: 0.8.0.0
Methods put :: Fixed a -> Put # get :: Get (Fixed a) # putList :: [Fixed a] -> Put #
Binary a => Binary (Complex a)
Methods put :: Complex a -> Put # get :: Get (Complex a) # putList :: [Complex a] -> Put #
Binary e => Binary (IntMap e)
Methods put :: IntMap e -> Put # get :: Get (IntMap e) # putList :: [IntMap e] -> Put #
Binary e => Binary (Tree e)
Methods put :: Tree e -> Put # get :: Get (Tree e) # putList :: [Tree e] -> Put #
Binary e => Binary (Seq e)
Methods put :: Seq e -> Put # get :: Get (Seq e) # putList :: [Seq e] -> Put #
Binary a => Binary (Set a)
Methods put :: Set a -> Put # get :: Get (Set a) # putList :: [Set a] -> Put #
(Binary a, Binary b) => Binary (Either a b)
Methods put :: Either a b -> Put # get :: Get (Either a b) # putList :: [Either a b] -> Put #
(Binary a, Binary b) => Binary (a, b)
Methods put :: (a, b) -> Put # get :: Get (a, b) # putList :: [(a, b)] -> Put #
(Binary i, Ix i, Binary e, IArray UArray e) => Binary (UArray i e)
Methods put :: UArray i e -> Put # get :: Get (UArray i e) # putList :: [UArray i e] -> Put #
(Binary i, Ix i, Binary e) => Binary (Array i e)
Methods put :: Array i e -> Put # get :: Get (Array i e) # putList :: [Array i e] -> Put #
(Binary k, Binary e) => Binary (Map k e)
Methods put :: Map k e -> Put # get :: Get (Map k e) # putList :: [Map k e] -> Put #
(Binary a, Binary b, Binary c) => Binary (a, b, c)
Methods put :: (a, b, c) -> Put # get :: Get (a, b, c) # putList :: [(a, b, c)] -> Put #
(Binary a, Binary b, Binary c, Binary d) => Binary (a, b, c, d)
Methods put :: (a, b, c, d) -> Put # get :: Get (a, b, c, d) # putList :: [(a, b, c, d)] -> Put #
(Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a, b, c, d, e)
Methods put :: (a, b, c, d, e) -> Put # get :: Get (a, b, c, d, e) # putList :: [(a, b, c, d, e)] -> Put #
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a, b, c, d, e, f)
Methods put :: (a, b, c, d, e, f) -> Put # get :: Get (a, b, c, d, e, f) # putList :: [(a, b, c, d, e, f)] -> Put #
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a, b, c, d, e, f, g)
Methods put :: (a, b, c, d, e, f, g) -> Put # get :: Get (a, b, c, d, e, f, g) # putList :: [(a, b, c, d, e, f, g)] -> Put #
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h) => Binary (a, b, c, d, e, f, g, h)
Methods put :: (a, b, c, d, e, f, g, h) -> Put # get :: Get (a, b, c, d, e, f, g, h) # putList :: [(a, b, c, d, e, f, g, h)] -> Put #
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i) => Binary (a, b, c, d, e, f, g, h, i)
Methods put :: (a, b, c, d, e, f, g, h, i) -> Put # get :: Get (a, b, c, d, e, f, g, h, i) # putList :: [(a, b, c, d, e, f, g, h, i)] -> Put #
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i, Binary j) => Binary (a, b, c, d, e, f, g, h, i, j)
Methods put :: (a, b, c, d, e, f, g, h, i, j) -> Put # get :: Get (a, b, c, d, e, f, g, h, i, j) # putList :: [(a, b, c, d, e, f, g, h, i, j)] -> Put #

class NFData a where #

A class of types that can be fully evaluated.

Since: 1.1.0.0

Methods

rnf :: a -> () #

rnf should reduce its argument to normal form (that is, fully evaluate all sub-components), and then return '()'.

`Generic` `NFData` deriving

Starting with GHC 7.2, you can automatically derive instances for types possessing a Generic instance.

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic)

instance NFData a => NFData (Foo a)

data Colour = Red | Green | Blue
              deriving Generic

instance NFData Colour

Starting with GHC 7.10, the example above can be written more concisely by enabling the new DeriveAnyClass extension:

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

import GHC.Generics (Generic)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, NFData)

data Colour = Red | Green | Blue
              deriving (Generic, NFData)

Compatibility with previous `deepseq` versions

Prior to version 1.4.0.0, the default implementation of the rnf method was defined as

rnf a = seq a ()

However, starting with deepseq-1.4.0.0, the default implementation is based on DefaultSignatures allowing for more accurate auto-derived NFData instances. If you need the previously used exact default rnf method implementation semantics, use

instance NFData Colour where rnf x = seq x ()

or alternatively

{-# LANGUAGE BangPatterns #-}
instance NFData Colour where rnf !_ = ()

Instances

NFData Bool
Methods rnf :: Bool -> () #
NFData Char
Methods rnf :: Char -> () #
NFData Double
Methods rnf :: Double -> () #
NFData Float
Methods rnf :: Float -> () #
NFData Int
Methods rnf :: Int -> () #
NFData Int8
Methods rnf :: Int8 -> () #
NFData Int16
Methods rnf :: Int16 -> () #
NFData Int32
Methods rnf :: Int32 -> () #
NFData Int64
Methods rnf :: Int64 -> () #
NFData Integer
Methods rnf :: Integer -> () #
NFData Word
Methods rnf :: Word -> () #
NFData Word8
Methods rnf :: Word8 -> () #
NFData Word16
Methods rnf :: Word16 -> () #
NFData Word32
Methods rnf :: Word32 -> () #
NFData Word64
Methods rnf :: Word64 -> () #
NFData CallStack	Since: 1.4.2.0
Methods rnf :: CallStack -> () #
NFData TypeRep	NOTE: Only defined for `base-4.8.0.0` and later Since: 1.4.0.0
Methods rnf :: TypeRep -> () #
NFData ()
Methods rnf :: () -> () #
NFData TyCon	NOTE: Only defined for `base-4.8.0.0` and later Since: 1.4.0.0
Methods rnf :: TyCon -> () #
NFData Natural	Since: 1.4.0.0
Methods rnf :: Natural -> () #
NFData Void	Defined as `rnf = absurd`. Since: 1.4.0.0
Methods rnf :: Void -> () #
NFData Version	Since: 1.3.0.0
Methods rnf :: Version -> () #
NFData Unique	Since: 1.4.0.0
Methods rnf :: Unique -> () #
NFData ThreadId	Since: 1.4.0.0
Methods rnf :: ThreadId -> () #
NFData ExitCode	Since: 1.4.2.0
Methods rnf :: ExitCode -> () #
NFData CChar	Since: 1.4.0.0
Methods rnf :: CChar -> () #
NFData CSChar	Since: 1.4.0.0
Methods rnf :: CSChar -> () #
NFData CUChar	Since: 1.4.0.0
Methods rnf :: CUChar -> () #
NFData CShort	Since: 1.4.0.0
Methods rnf :: CShort -> () #
NFData CUShort	Since: 1.4.0.0
Methods rnf :: CUShort -> () #
NFData CInt	Since: 1.4.0.0
Methods rnf :: CInt -> () #
NFData CUInt	Since: 1.4.0.0
Methods rnf :: CUInt -> () #
NFData CLong	Since: 1.4.0.0
Methods rnf :: CLong -> () #
NFData CULong	Since: 1.4.0.0
Methods rnf :: CULong -> () #
NFData CLLong	Since: 1.4.0.0
Methods rnf :: CLLong -> () #
NFData CULLong	Since: 1.4.0.0
Methods rnf :: CULLong -> () #
NFData CFloat	Since: 1.4.0.0
Methods rnf :: CFloat -> () #
NFData CDouble	Since: 1.4.0.0
Methods rnf :: CDouble -> () #
NFData CPtrdiff	Since: 1.4.0.0
Methods rnf :: CPtrdiff -> () #
NFData CSize	Since: 1.4.0.0
Methods rnf :: CSize -> () #
NFData CWchar	Since: 1.4.0.0
Methods rnf :: CWchar -> () #
NFData CSigAtomic	Since: 1.4.0.0
Methods rnf :: CSigAtomic -> () #
NFData CClock	Since: 1.4.0.0
Methods rnf :: CClock -> () #
NFData CTime	Since: 1.4.0.0
Methods rnf :: CTime -> () #
NFData CUSeconds	Since: 1.4.0.0
Methods rnf :: CUSeconds -> () #
NFData CSUSeconds	Since: 1.4.0.0
Methods rnf :: CSUSeconds -> () #
NFData CFile	Since: 1.4.0.0
Methods rnf :: CFile -> () #
NFData CFpos	Since: 1.4.0.0
Methods rnf :: CFpos -> () #
NFData CJmpBuf	Since: 1.4.0.0
Methods rnf :: CJmpBuf -> () #
NFData CIntPtr	Since: 1.4.0.0
Methods rnf :: CIntPtr -> () #
NFData CUIntPtr	Since: 1.4.0.0
Methods rnf :: CUIntPtr -> () #
NFData CIntMax	Since: 1.4.0.0
Methods rnf :: CIntMax -> () #
NFData CUIntMax	Since: 1.4.0.0
Methods rnf :: CUIntMax -> () #
NFData All	Since: 1.4.0.0
Methods rnf :: All -> () #
NFData Any	Since: 1.4.0.0
Methods rnf :: Any -> () #
NFData Fingerprint	Since: 1.4.0.0
Methods rnf :: Fingerprint -> () #
NFData SrcLoc	Since: 1.4.2.0
Methods rnf :: SrcLoc -> () #
NFData ShortByteString
Methods rnf :: ShortByteString -> () #
NFData ByteString
Methods rnf :: ByteString -> () #
NFData ByteString
Methods rnf :: ByteString -> () #
NFData IntSet
Methods rnf :: IntSet -> () #
NFData LocalTime
Methods rnf :: LocalTime -> () #
NFData ZonedTime
Methods rnf :: ZonedTime -> () #
NFData TimeOfDay
Methods rnf :: TimeOfDay -> () #
NFData TimeZone
Methods rnf :: TimeZone -> () #
NFData UTCTime
Methods rnf :: UTCTime -> () #
NFData NominalDiffTime
Methods rnf :: NominalDiffTime -> () #
NFData Day
Methods rnf :: Day -> () #
NFData UniversalTime
Methods rnf :: UniversalTime -> () #
NFData DiffTime
Methods rnf :: DiffTime -> () #
NFData a => NFData [a]
Methods rnf :: [a] -> () #
NFData a => NFData (Maybe a)
Methods rnf :: Maybe a -> () #
NFData a => NFData (Ratio a)
Methods rnf :: Ratio a -> () #
NFData (Ptr a)	Since: 1.4.2.0
Methods rnf :: Ptr a -> () #
NFData (FunPtr a)	Since: 1.4.2.0
Methods rnf :: FunPtr a -> () #
NFData a => NFData (Identity a)	Since: 1.4.0.0
Methods rnf :: Identity a -> () #
NFData a => NFData (Min a)	Since: 1.4.2.0
Methods rnf :: Min a -> () #
NFData a => NFData (Max a)	Since: 1.4.2.0
Methods rnf :: Max a -> () #
NFData a => NFData (First a)	Since: 1.4.2.0
Methods rnf :: First a -> () #
NFData a => NFData (Last a)	Since: 1.4.2.0
Methods rnf :: Last a -> () #
NFData m => NFData (WrappedMonoid m)	Since: 1.4.2.0
Methods rnf :: WrappedMonoid m -> () #
NFData a => NFData (Option a)	Since: 1.4.2.0
Methods rnf :: Option a -> () #
NFData a => NFData (NonEmpty a)	Since: 1.4.2.0
Methods rnf :: NonEmpty a -> () #
NFData (Fixed a)	Since: 1.3.0.0
Methods rnf :: Fixed a -> () #
NFData a => NFData (Complex a)
Methods rnf :: Complex a -> () #
NFData (StableName a)	Since: 1.4.0.0
Methods rnf :: StableName a -> () #
NFData a => NFData (ZipList a)	Since: 1.4.0.0
Methods rnf :: ZipList a -> () #
NFData a => NFData (Dual a)	Since: 1.4.0.0
Methods rnf :: Dual a -> () #
NFData a => NFData (Sum a)	Since: 1.4.0.0
Methods rnf :: Sum a -> () #
NFData a => NFData (Product a)	Since: 1.4.0.0
Methods rnf :: Product a -> () #
NFData a => NFData (First a)	Since: 1.4.0.0
Methods rnf :: First a -> () #
NFData a => NFData (Last a)	Since: 1.4.0.0
Methods rnf :: Last a -> () #
NFData (IORef a)	NOTE: Only strict in the reference and not the referenced value. Since: 1.4.2.0
Methods rnf :: IORef a -> () #
NFData a => NFData (Down a)	Since: 1.4.0.0
Methods rnf :: Down a -> () #
NFData (MVar a)	NOTE: Only strict in the reference and not the referenced value. Since: 1.4.2.0
Methods rnf :: MVar a -> () #
NFData a => NFData (Digit a)
Methods rnf :: Digit a -> () #
NFData a => NFData (Node a)
Methods rnf :: Node a -> () #
NFData a => NFData (Elem a)
Methods rnf :: Elem a -> () #
NFData a => NFData (FingerTree a)
Methods rnf :: FingerTree a -> () #
NFData a => NFData (IntMap a)
Methods rnf :: IntMap a -> () #
NFData a => NFData (Tree a)
Methods rnf :: Tree a -> () #
NFData a => NFData (Seq a)
Methods rnf :: Seq a -> () #
NFData a => NFData (Set a)
Methods rnf :: Set a -> () #
NFData a => NFData (HashSet a)
Methods rnf :: HashSet a -> () #
NFData (a -> b)	This instance is for convenience and consistency with `seq`. This assumes that WHNF is equivalent to NF for functions. Since: 1.3.0.0
Methods rnf :: (a -> b) -> () #
(NFData a, NFData b) => NFData (Either a b)
Methods rnf :: Either a b -> () #
(NFData a, NFData b) => NFData (a, b)
Methods rnf :: (a, b) -> () #
(NFData a, NFData b) => NFData (Array a b)
Methods rnf :: Array a b -> () #
(NFData a, NFData b) => NFData (Arg a b)	Since: 1.4.2.0
Methods rnf :: Arg a b -> () #
NFData (Proxy k a)	Since: 1.4.0.0
Methods rnf :: Proxy k a -> () #
NFData (STRef s a)	NOTE: Only strict in the reference and not the referenced value. Since: 1.4.2.0
Methods rnf :: STRef s a -> () #
(NFData k, NFData a) => NFData (Map k a)
Methods rnf :: Map k a -> () #
(NFData k, NFData v) => NFData (Leaf k v)
Methods rnf :: Leaf k v -> () #
(NFData k, NFData v) => NFData (HashMap k v)
Methods rnf :: HashMap k v -> () #
(NFData a, NFData b, NFData c) => NFData (a, b, c)
Methods rnf :: (a, b, c) -> () #
NFData a => NFData (Const k a b)	Since: 1.4.0.0
Methods rnf :: Const k a b -> () #
(NFData a, NFData b, NFData c, NFData d) => NFData (a, b, c, d)
Methods rnf :: (a, b, c, d) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5)
Methods rnf :: (a1, a2, a3, a4, a5) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6) => NFData (a1, a2, a3, a4, a5, a6)
Methods rnf :: (a1, a2, a3, a4, a5, a6) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7) => NFData (a1, a2, a3, a4, a5, a6, a7)
Methods rnf :: (a1, a2, a3, a4, a5, a6, a7) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8) => NFData (a1, a2, a3, a4, a5, a6, a7, a8)
Methods rnf :: (a1, a2, a3, a4, a5, a6, a7, a8) -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8, NFData a9) => NFData (a1, a2, a3, a4, a5, a6, a7, a8, a9)
Methods rnf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> () #

Documentation

Generic NFData deriving

Compatibility with previous deepseq versions

`Generic` `NFData` deriving

Compatibility with previous `deepseq` versions