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 #

Arguments

:: Int	the operator precedence of the enclosing context (a number from `0` to `11`). Function application has precedence `10`.
-> a	the value to be converted to a `String`
-> 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	Since: 2.1
Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Show Int	Since: 2.1
Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Show Int8	Since: 2.1
Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Show Int16	Since: 2.1
Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Show Int32	Since: 2.1
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Show Int64	Since: 2.1
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Show Integer	Since: 2.1
Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Show Natural	Since: 4.8.0.0
Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Show Ordering
Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Show Word	Since: 2.1
Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Show Word8	Since: 2.1
Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Show Word16	Since: 2.1
Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Show Word32	Since: 2.1
Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Show Word64	Since: 2.1
Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Show CallStack	Since: 4.9.0.0
Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
Show SomeTypeRep	Since: 4.10.0.0
Methods showsPrec :: Int -> SomeTypeRep -> ShowS # show :: SomeTypeRep -> String # showList :: [SomeTypeRep] -> ShowS #
Show ()
Methods showsPrec :: Int -> () -> ShowS # show :: () -> String # showList :: [()] -> ShowS #
Show TyCon	Since: 2.1
Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Show Module	Since: 4.9.0.0
Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show TrName	Since: 4.9.0.0
Methods showsPrec :: Int -> TrName -> ShowS # show :: TrName -> String # showList :: [TrName] -> ShowS #
Show Handle	Since: 4.1.0.0
Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #
Show HandleType	Since: 4.1.0.0
Methods showsPrec :: Int -> HandleType -> ShowS # show :: HandleType -> String # showList :: [HandleType] -> ShowS #
Show Void	Since: 4.8.0.0
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	Since: 4.0.0.0
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	Since: 4.1.0.0
Methods showsPrec :: Int -> HandlePosn -> ShowS # show :: HandlePosn -> String # showList :: [HandlePosn] -> ShowS #
Show PatternMatchFail	Since: 4.0
Methods showsPrec :: Int -> PatternMatchFail -> ShowS # show :: PatternMatchFail -> String # showList :: [PatternMatchFail] -> ShowS #
Show RecSelError	Since: 4.0
Methods showsPrec :: Int -> RecSelError -> ShowS # show :: RecSelError -> String # showList :: [RecSelError] -> ShowS #
Show RecConError	Since: 4.0
Methods showsPrec :: Int -> RecConError -> ShowS # show :: RecConError -> String # showList :: [RecConError] -> ShowS #
Show RecUpdError	Since: 4.0
Methods showsPrec :: Int -> RecUpdError -> ShowS # show :: RecUpdError -> String # showList :: [RecUpdError] -> ShowS #
Show NoMethodError	Since: 4.0
Methods showsPrec :: Int -> NoMethodError -> ShowS # show :: NoMethodError -> String # showList :: [NoMethodError] -> ShowS #
Show TypeError	Since: 4.9.0.0
Methods showsPrec :: Int -> TypeError -> ShowS # show :: TypeError -> String # showList :: [TypeError] -> ShowS #
Show NonTermination	Since: 4.0
Methods showsPrec :: Int -> NonTermination -> ShowS # show :: NonTermination -> String # showList :: [NonTermination] -> ShowS #
Show NestedAtomically	Since: 4.0
Methods showsPrec :: Int -> NestedAtomically -> ShowS # show :: NestedAtomically -> String # showList :: [NestedAtomically] -> ShowS #
Show ThreadId	Since: 4.2.0.0
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 Dynamic	Since: 2.1
Methods showsPrec :: Int -> Dynamic -> ShowS # show :: Dynamic -> String # showList :: [Dynamic] -> 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 CBlkSize
Methods showsPrec :: Int -> CBlkSize -> ShowS # show :: CBlkSize -> String # showList :: [CBlkSize] -> ShowS #
Show CBlkCnt
Methods showsPrec :: Int -> CBlkCnt -> ShowS # show :: CBlkCnt -> String # showList :: [CBlkCnt] -> ShowS #
Show CClockId
Methods showsPrec :: Int -> CClockId -> ShowS # show :: CClockId -> String # showList :: [CClockId] -> ShowS #
Show CFsBlkCnt
Methods showsPrec :: Int -> CFsBlkCnt -> ShowS # show :: CFsBlkCnt -> String # showList :: [CFsBlkCnt] -> ShowS #
Show CFsFilCnt
Methods showsPrec :: Int -> CFsFilCnt -> ShowS # show :: CFsFilCnt -> String # showList :: [CFsFilCnt] -> ShowS #
Show CId
Methods showsPrec :: Int -> CId -> ShowS # show :: CId -> String # showList :: [CId] -> ShowS #
Show CKey
Methods showsPrec :: Int -> CKey -> ShowS # show :: CKey -> String # showList :: [CKey] -> ShowS #
Show CTimer
Methods showsPrec :: Int -> CTimer -> ShowS # show :: CTimer -> String # showList :: [CTimer] -> ShowS #
Show Fd
Methods showsPrec :: Int -> Fd -> ShowS # show :: Fd -> String # showList :: [Fd] -> ShowS #
Show BlockedIndefinitelyOnMVar	Since: 4.1.0.0
Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> ShowS #
Show BlockedIndefinitelyOnSTM	Since: 4.1.0.0
Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #
Show Deadlock	Since: 4.1.0.0
Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #
Show AllocationLimitExceeded	Since: 4.7.1.0
Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> ShowS #
Show CompactionFailed	Since: 4.10.0.0
Methods showsPrec :: Int -> CompactionFailed -> ShowS # show :: CompactionFailed -> String # showList :: [CompactionFailed] -> ShowS #
Show AssertionFailed	Since: 4.1.0.0
Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> ShowS #
Show SomeAsyncException	Since: 4.7.0.0
Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS #
Show AsyncException	Since: 4.1.0.0
Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Show ArrayException	Since: 4.1.0.0
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	Since: 4.1.0.0
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 SeekMode
Methods showsPrec :: Int -> SeekMode -> ShowS # show :: SeekMode -> String # showList :: [SeekMode] -> ShowS #
Show MaskingState
Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Show IOException	Since: 4.1.0.0
Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Show ErrorCall	Since: 4.0.0.0
Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Show ArithException	Since: 4.0.0.0
Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> 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 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 CBool
Methods showsPrec :: Int -> CBool -> ShowS # show :: CBool -> String # showList :: [CBool] -> 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 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 IOMode
Methods showsPrec :: Int -> IOMode -> ShowS # show :: IOMode -> String # showList :: [IOMode] -> ShowS #
Show Fingerprint	Since: 4.7.0.0
Methods showsPrec :: Int -> Fingerprint -> ShowS # show :: Fingerprint -> String # showList :: [Fingerprint] -> 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	Since: 3.0
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 Clock
Methods showsPrec :: Int -> Clock -> ShowS # show :: Clock -> String # showList :: [Clock] -> ShowS #
Show TimeSpec
Methods showsPrec :: Int -> TimeSpec -> ShowS # show :: TimeSpec -> String # showList :: [TimeSpec] -> 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 Timeout
Methods showsPrec :: Int -> Timeout -> ShowS # show :: Timeout -> String # showList :: [Timeout] -> ShowS #
Show StdStream
Methods showsPrec :: Int -> StdStream -> ShowS # show :: StdStream -> String # showList :: [StdStream] -> ShowS #
Show CmdSpec
Methods showsPrec :: Int -> CmdSpec -> ShowS # show :: CmdSpec -> String # showList :: [CmdSpec] -> ShowS #
Show CreateProcess
Methods showsPrec :: Int -> CreateProcess -> ShowS # show :: CreateProcess -> String # showList :: [CreateProcess] -> ShowS #
Show Color
Methods showsPrec :: Int -> Color -> ShowS # show :: Color -> String # showList :: [Color] -> ShowS #
Show Flot
Methods showsPrec :: Int -> Flot -> ShowS # show :: Flot -> String # showList :: [Flot] -> ShowS #
Show StdGen
Methods showsPrec :: Int -> StdGen -> ShowS # show :: StdGen -> String # showList :: [StdGen] -> 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 ZonedTime
Methods showsPrec :: Int -> ZonedTime -> ShowS # show :: ZonedTime -> String # showList :: [ZonedTime] -> ShowS #
Show LocalTime
Methods showsPrec :: Int -> LocalTime -> ShowS # show :: LocalTime -> String # showList :: [LocalTime] -> 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 CmdOption #
Methods showsPrec :: Int -> CmdOption -> ShowS # show :: CmdOption -> String # showList :: [CmdOption] -> ShowS #
Show ShakeException #
Methods showsPrec :: Int -> ShakeException -> ShowS # show :: ShakeException -> String # showList :: [ShakeException] -> ShowS #
Show Resource #
Methods showsPrec :: Int -> Resource -> ShowS # show :: Resource -> String # showList :: [Resource] -> ShowS #
Show Progress #
Methods showsPrec :: Int -> Progress -> ShowS # show :: Progress -> String # showList :: [Progress] -> 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 Rebuild #
Methods showsPrec :: Int -> Rebuild -> ShowS # show :: Rebuild -> String # showList :: [Rebuild] -> ShowS #
Show RunChanged #
Methods showsPrec :: Int -> RunChanged -> ShowS # show :: RunChanged -> String # showList :: [RunChanged] -> ShowS #
Show CmdArgument #
Methods showsPrec :: Int -> CmdArgument -> ShowS # show :: CmdArgument -> String # showList :: [CmdArgument] -> ShowS #
Show a => Show [a]	Since: 2.1
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)	Since: 2.0.1
Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Show (Ptr a)	Since: 2.1
Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
Show (FunPtr a)	Since: 2.1
Methods showsPrec :: Int -> FunPtr a -> ShowS # show :: FunPtr a -> String # showList :: [FunPtr a] -> ShowS #
Show p => Show (Par1 p)
Methods showsPrec :: Int -> Par1 p -> ShowS # show :: Par1 p -> String # showList :: [Par1 p] -> ShowS #
Show a => Show (Complex a)
Methods showsPrec :: Int -> Complex a -> ShowS # show :: Complex a -> String # showList :: [Complex a] -> ShowS #
HasResolution a => Show (Fixed a)	Since: 2.1
Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed 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 #
Show a => Show (ZipList a)
Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> 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 Since: 4.8.0.0
Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity 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 (Array a)
Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
Show a => Show (HashSet a)
Methods showsPrec :: Int -> HashSet a -> ShowS # show :: HashSet a -> String # showList :: [HashSet a] -> ShowS #
Show a => Show (UserRule a) #
Methods showsPrec :: Int -> UserRule a -> ShowS # show :: UserRule a -> String # showList :: [UserRule 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 (V1 k p)
Methods showsPrec :: Int -> V1 k p -> ShowS # show :: V1 k p -> String # showList :: [V1 k p] -> ShowS #
Show (U1 k p)	Since: 4.9.0.0
Methods showsPrec :: Int -> U1 k p -> ShowS # show :: U1 k p -> String # showList :: [U1 k p] -> ShowS #
Show (TypeRep k a)
Methods showsPrec :: Int -> TypeRep k a -> ShowS # show :: TypeRep k a -> String # showList :: [TypeRep k a] -> ShowS #
(Show a, Show b) => Show (a, b)	Since: 2.1
Methods showsPrec :: Int -> (a, b) -> ShowS # show :: (a, b) -> String # showList :: [(a, b)] -> ShowS #
Show (ST s a)	Since: 2.1
Methods showsPrec :: Int -> ST s a -> ShowS # show :: ST s a -> String # showList :: [ST s a] -> 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)	Since: 2.1
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)	Since: 4.7.0.0
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 #
(Show1 m, Show a) => Show (MaybeT m a)
Methods showsPrec :: Int -> MaybeT m a -> ShowS # show :: MaybeT m a -> String # showList :: [MaybeT m a] -> ShowS #
(Show1 m, Show a) => Show (ListT m a)
Methods showsPrec :: Int -> ListT m a -> ShowS # show :: ListT m a -> String # showList :: [ListT m 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 (f p) => Show (Rec1 k f p)
Methods showsPrec :: Int -> Rec1 k f p -> ShowS # show :: Rec1 k f p -> String # showList :: [Rec1 k f p] -> ShowS #
Show (URec k Char p)
Methods showsPrec :: Int -> URec k Char p -> ShowS # show :: URec k Char p -> String # showList :: [URec k Char p] -> ShowS #
Show (URec k Double p)
Methods showsPrec :: Int -> URec k Double p -> ShowS # show :: URec k Double p -> String # showList :: [URec k Double p] -> ShowS #
Show (URec k Float p)
Methods showsPrec :: Int -> URec k Float p -> ShowS # show :: URec k Float p -> String # showList :: [URec k Float p] -> ShowS #
Show (URec k Int p)
Methods showsPrec :: Int -> URec k Int p -> ShowS # show :: URec k Int p -> String # showList :: [URec k Int p] -> ShowS #
Show (URec k Word p)
Methods showsPrec :: Int -> URec k Word p -> ShowS # show :: URec k Word p -> String # showList :: [URec k Word p] -> ShowS #
(Show a, Show b, Show c) => Show (a, b, c)	Since: 2.1
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 Since: 4.8.0.0
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 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 #
(Show1 f, Show a) => Show (IdentityT * f a)
Methods showsPrec :: Int -> IdentityT * f a -> ShowS # show :: IdentityT * f a -> String # showList :: [IdentityT * f a] -> ShowS #
(Show e, Show1 m, Show a) => Show (ExceptT e m a)
Methods showsPrec :: Int -> ExceptT e m a -> ShowS # show :: ExceptT e m a -> String # showList :: [ExceptT e m a] -> ShowS #
(Show e, Show1 m, Show a) => Show (ErrorT e m a)
Methods showsPrec :: Int -> ErrorT e m a -> ShowS # show :: ErrorT e m a -> String # showList :: [ErrorT e m a] -> ShowS #
Show c => Show (K1 k i c p)
Methods showsPrec :: Int -> K1 k i c p -> ShowS # show :: K1 k i c p -> String # showList :: [K1 k i c p] -> ShowS #
(Show (g p), Show (f p)) => Show ((:+:) k f g p)
Methods showsPrec :: Int -> (k :+: f) g p -> ShowS # show :: (k :+: f) g p -> String # showList :: [(k :+: f) g p] -> ShowS #
(Show (g p), Show (f p)) => Show ((:*:) k f g p)
Methods showsPrec :: Int -> (k :: f) g p -> ShowS # show :: (k :: f) g p -> String # showList :: [(k :*: f) g p] -> ShowS #
(Show a, Show b, Show c, Show d) => Show (a, b, c, d)	Since: 2.1
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 (Product * f g a)	Since: 4.9.0.0
Methods showsPrec :: Int -> Product * f g a -> ShowS # show :: Product * f g a -> String # showList :: [Product * f g a] -> ShowS #
(Show1 f, Show1 g, Show a) => Show (Sum * f g a)	Since: 4.9.0.0
Methods showsPrec :: Int -> Sum * f g a -> ShowS # show :: Sum * f g a -> String # showList :: [Sum * f g a] -> ShowS #
Show ((:~~:) k1 k2 a b)	Since: 4.10.0.0
Methods showsPrec :: Int -> (k1 :~~: k2) a b -> ShowS # show :: (k1 :~~: k2) a b -> String # showList :: [(k1 :~~: k2) a b] -> ShowS #
Show (f p) => Show (M1 k i c f p)
Methods showsPrec :: Int -> M1 k i c f p -> ShowS # show :: M1 k i c f p -> String # showList :: [M1 k i c f p] -> ShowS #
Show (f (g p)) => Show ((:.:) k2 k1 f g p)
Methods showsPrec :: Int -> (k2 :.: k1) f g p -> ShowS # show :: (k2 :.: k1) f g p -> String # showList :: [(k2 :.: k1) f g p] -> ShowS #
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)	Since: 2.1
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)	Since: 4.9.0.0
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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)	Since: 2.1
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 :: k) #

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	Since: 2.1
Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq Int16	Since: 2.1
Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32	Since: 2.1
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64	Since: 2.1
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Integer
Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Natural
Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Eq Ordering
Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq Word
Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq Word8	Since: 2.1
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Word16	Since: 2.1
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32	Since: 2.1
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64	Since: 2.1
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq SomeTypeRep
Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool #
Eq ()
Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq TyCon
Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq Module
Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq TrName
Methods (==) :: TrName -> TrName -> Bool # (/=) :: TrName -> TrName -> Bool #
Eq Handle	Since: 4.1.0.0
Methods (==) :: Handle -> Handle -> Bool # (/=) :: Handle -> Handle -> Bool #
Eq BigNat
Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq Void	Since: 4.8.0.0
Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq SpecConstrAnnotation
Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Constr	Equality of constructors Since: 4.0.0.0
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 Unique
Methods (==) :: Unique -> Unique -> Bool # (/=) :: Unique -> Unique -> Bool #
Eq Version	Since: 2.1
Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq HandlePosn	Since: 4.1.0.0
Methods (==) :: HandlePosn -> HandlePosn -> Bool # (/=) :: HandlePosn -> HandlePosn -> Bool #
Eq ThreadId	Since: 4.2.0.0
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 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 CBlkSize
Methods (==) :: CBlkSize -> CBlkSize -> Bool # (/=) :: CBlkSize -> CBlkSize -> Bool #
Eq CBlkCnt
Methods (==) :: CBlkCnt -> CBlkCnt -> Bool # (/=) :: CBlkCnt -> CBlkCnt -> Bool #
Eq CClockId
Methods (==) :: CClockId -> CClockId -> Bool # (/=) :: CClockId -> CClockId -> Bool #
Eq CFsBlkCnt
Methods (==) :: CFsBlkCnt -> CFsBlkCnt -> Bool # (/=) :: CFsBlkCnt -> CFsBlkCnt -> Bool #
Eq CFsFilCnt
Methods (==) :: CFsFilCnt -> CFsFilCnt -> Bool # (/=) :: CFsFilCnt -> CFsFilCnt -> Bool #
Eq CId
Methods (==) :: CId -> CId -> Bool # (/=) :: CId -> CId -> Bool #
Eq CKey
Methods (==) :: CKey -> CKey -> Bool # (/=) :: CKey -> CKey -> Bool #
Eq CTimer
Methods (==) :: CTimer -> CTimer -> Bool # (/=) :: CTimer -> CTimer -> Bool #
Eq Fd
Methods (==) :: Fd -> Fd -> Bool # (/=) :: Fd -> Fd -> Bool #
Eq Errno	Since: 2.1
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	Since: 4.1.0.0
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 IODeviceType
Methods (==) :: IODeviceType -> IODeviceType -> Bool # (/=) :: IODeviceType -> IODeviceType -> Bool #
Eq SeekMode
Methods (==) :: SeekMode -> SeekMode -> Bool # (/=) :: SeekMode -> SeekMode -> Bool #
Eq MaskingState
Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq IOException	Since: 4.1.0.0
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 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 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 CBool
Methods (==) :: CBool -> CBool -> Bool # (/=) :: CBool -> CBool -> 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 WordPtr
Methods (==) :: WordPtr -> WordPtr -> Bool # (/=) :: WordPtr -> WordPtr -> Bool #
Eq IntPtr
Methods (==) :: IntPtr -> IntPtr -> Bool # (/=) :: IntPtr -> IntPtr -> Bool #
Eq IOMode
Methods (==) :: IOMode -> IOMode -> Bool # (/=) :: IOMode -> IOMode -> Bool #
Eq Fingerprint
Methods (==) :: Fingerprint -> Fingerprint -> Bool # (/=) :: Fingerprint -> Fingerprint -> 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 Clock
Methods (==) :: Clock -> Clock -> Bool # (/=) :: Clock -> Clock -> Bool #
Eq TimeSpec
Methods (==) :: TimeSpec -> TimeSpec -> Bool # (/=) :: TimeSpec -> TimeSpec -> 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 Timeout
Methods (==) :: Timeout -> Timeout -> Bool # (/=) :: Timeout -> Timeout -> Bool #
Eq StdStream
Methods (==) :: StdStream -> StdStream -> Bool # (/=) :: StdStream -> StdStream -> Bool #
Eq CmdSpec
Methods (==) :: CmdSpec -> CmdSpec -> Bool # (/=) :: CmdSpec -> CmdSpec -> Bool #
Eq CreateProcess
Methods (==) :: CreateProcess -> CreateProcess -> Bool # (/=) :: CreateProcess -> CreateProcess -> Bool #
Eq Flot
Methods (==) :: Flot -> Flot -> Bool # (/=) :: Flot -> Flot -> 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 UniversalTime
Methods (==) :: UniversalTime -> UniversalTime -> Bool # (/=) :: UniversalTime -> UniversalTime -> 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 CmdOption #
Methods (==) :: CmdOption -> CmdOption -> Bool # (/=) :: CmdOption -> CmdOption -> Bool #
Eq Resource #
Methods (==) :: Resource -> Resource -> Bool # (/=) :: Resource -> Resource -> Bool #
Eq Progress #
Methods (==) :: Progress -> Progress -> Bool # (/=) :: Progress -> Progress -> 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 Rebuild #
Methods (==) :: Rebuild -> Rebuild -> Bool # (/=) :: Rebuild -> Rebuild -> Bool #
Eq RunChanged #
Methods (==) :: RunChanged -> RunChanged -> Bool # (/=) :: RunChanged -> RunChanged -> Bool #
Eq CmdArgument #
Methods (==) :: CmdArgument -> CmdArgument -> Bool # (/=) :: CmdArgument -> CmdArgument -> 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 (StablePtr a)	Since: 2.1
Methods (==) :: StablePtr a -> StablePtr a -> Bool # (/=) :: StablePtr a -> StablePtr 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 p => Eq (Par1 p)
Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq a => Eq (Complex a)
Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
Eq (Fixed a)
Methods (==) :: Fixed a -> Fixed a -> Bool # (/=) :: Fixed a -> Fixed 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 (Chan a)
Methods (==) :: Chan a -> Chan a -> Bool # (/=) :: Chan a -> Chan a -> Bool #
Eq (StableName a)	Since: 2.1
Methods (==) :: StableName a -> StableName a -> Bool # (/=) :: StableName a -> StableName a -> Bool #
Eq a => Eq (ZipList a)
Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq a => Eq (Identity a)
Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq (TVar a)	Since: 4.8.0.0
Methods (==) :: TVar a -> TVar a -> Bool # (/=) :: TVar a -> TVar a -> Bool #
Eq (IORef a)	Since: 4.1.0.0
Methods (==) :: IORef a -> IORef a -> Bool # (/=) :: IORef a -> IORef 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 a => Eq (Down a)
Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Eq (MVar a)	Since: 4.1.0.0
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)	Uses precomputed hash to detect inequality faster
Methods (==) :: Hashed a -> Hashed a -> Bool # (/=) :: Hashed a -> Hashed a -> Bool #
Eq a => Eq (Array a)
Methods (==) :: Array a -> Array a -> Bool # (/=) :: Array a -> Array a -> Bool #
Eq a => Eq (HashSet a)
Methods (==) :: HashSet a -> HashSet a -> Bool # (/=) :: HashSet a -> HashSet a -> Bool #
Eq a => Eq (UserRule a) #
Methods (==) :: UserRule a -> UserRule a -> Bool # (/=) :: UserRule a -> UserRule 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 (V1 k p)
Methods (==) :: V1 k p -> V1 k p -> Bool # (/=) :: V1 k p -> V1 k p -> Bool #
Eq (U1 k p)	Since: 4.9.0.0
Methods (==) :: U1 k p -> U1 k p -> Bool # (/=) :: U1 k p -> U1 k p -> Bool #
Eq (TypeRep k a)	Since: 2.1
Methods (==) :: TypeRep k a -> TypeRep k a -> Bool # (/=) :: TypeRep k a -> TypeRep k a -> 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)	Since: 2.1
Methods (==) :: Array i e -> Array i e -> Bool # (/=) :: Array i e -> Array i e -> Bool #
Eq a => Eq (Arg a b)	Since: 4.9.0.0
Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (Proxy k s)	Since: 4.7.0.0
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
Eq (STRef s a)	Since: 2.1
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 (MutableArray s a)
Methods (==) :: MutableArray s a -> MutableArray s a -> Bool # (/=) :: MutableArray s a -> MutableArray s a -> Bool #
(Eq1 m, Eq a) => Eq (MaybeT m a)
Methods (==) :: MaybeT m a -> MaybeT m a -> Bool # (/=) :: MaybeT m a -> MaybeT m a -> Bool #
(Eq1 m, Eq a) => Eq (ListT m a)
Methods (==) :: ListT m a -> ListT m a -> Bool # (/=) :: ListT m a -> ListT m 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 (f p) => Eq (Rec1 k f p)
Methods (==) :: Rec1 k f p -> Rec1 k f p -> Bool # (/=) :: Rec1 k f p -> Rec1 k f p -> Bool #
Eq (URec k (Ptr ()) p)
Methods (==) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool # (/=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool #
Eq (URec k Char p)
Methods (==) :: URec k Char p -> URec k Char p -> Bool # (/=) :: URec k Char p -> URec k Char p -> Bool #
Eq (URec k Double p)
Methods (==) :: URec k Double p -> URec k Double p -> Bool # (/=) :: URec k Double p -> URec k Double p -> Bool #
Eq (URec k Float p)
Methods (==) :: URec k Float p -> URec k Float p -> Bool # (/=) :: URec k Float p -> URec k Float p -> Bool #
Eq (URec k Int p)
Methods (==) :: URec k Int p -> URec k Int p -> Bool # (/=) :: URec k Int p -> URec k Int p -> Bool #
Eq (URec k Word p)
Methods (==) :: URec k Word p -> URec k Word p -> Bool # (/=) :: URec k Word p -> URec k Word 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)	Since: 2.1
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 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 #
(Eq1 f, Eq a) => Eq (IdentityT * f a)
Methods (==) :: IdentityT * f a -> IdentityT * f a -> Bool # (/=) :: IdentityT * f a -> IdentityT * f a -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)
Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a)
Methods (==) :: ErrorT e m a -> ErrorT e m a -> Bool # (/=) :: ErrorT e m a -> ErrorT e m a -> Bool #
Eq c => Eq (K1 k i c p)
Methods (==) :: K1 k i c p -> K1 k i c p -> Bool # (/=) :: K1 k i c p -> K1 k i c p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:+:) k f g p)
Methods (==) :: (k :+: f) g p -> (k :+: f) g p -> Bool # (/=) :: (k :+: f) g p -> (k :+: f) g p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:*:) k f g p)
Methods (==) :: (k :: f) g p -> (k :: f) g p -> Bool # (/=) :: (k :: f) g p -> (k :: f) g 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 (Product * f g a)	Since: 4.9.0.0
Methods (==) :: Product * f g a -> Product * f g a -> Bool # (/=) :: Product * f g a -> Product * f g a -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a)	Since: 4.9.0.0
Methods (==) :: Sum * f g a -> Sum * f g a -> Bool # (/=) :: Sum * f g a -> Sum * f g a -> Bool #
Eq ((:~~:) k1 k2 a b)	Since: 4.10.0.0
Methods (==) :: (k1 :~~: k2) a b -> (k1 :~~: k2) a b -> Bool # (/=) :: (k1 :~~: k2) a b -> (k1 :~~: k2) a b -> Bool #
Eq (f p) => Eq (M1 k i c f p)
Methods (==) :: M1 k i c f p -> M1 k i c f p -> Bool # (/=) :: M1 k i c f p -> M1 k i c f p -> Bool #
Eq (f (g p)) => Eq ((:.:) k2 k1 f g p)
Methods (==) :: (k2 :.: k1) f g p -> (k2 :.: k1) f g p -> Bool # (/=) :: (k2 :.: k1) f g p -> (k2 :.: k1) f g p -> 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)	Since: 4.9.0.0
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 #

The class of types that can be converted to a hash value.

Minimal implementation: hashWithSalt.

Methods

hashWithSalt :: Int -> a -> Int infixl 0 #

Return a hash value for the argument, using the given salt.

The general contract of hashWithSalt is:

If two values are equal according to the == method, then applying the hashWithSalt method on each of the two values must produce the same integer result if the same salt is used in each case.
It is not required that if two values are unequal according to the == method, then applying the hashWithSalt method on each of the two values must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal values may improve the performance of hashing-based data structures.
This method can be used to compute different hash values for the same input by providing a different salt in each application of the method. This implies that any instance that defines hashWithSalt must make use of the salt in its implementation.

hash :: a -> Int #

Like hashWithSalt, but no salt is used. The default implementation uses hashWithSalt with some default salt. Instances might want to implement this method to provide a more efficient implementation than the default implementation.

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 Natural
Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> 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 SomeTypeRep
Methods hashWithSalt :: Int -> SomeTypeRep -> Int # hash :: SomeTypeRep -> Int #
Hashable ()
Methods hashWithSalt :: Int -> () -> Int # hash :: () -> Int #
Hashable BigNat
Methods hashWithSalt :: Int -> BigNat -> Int # hash :: BigNat -> Int #
Hashable Void
Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
Hashable Unique
Methods hashWithSalt :: Int -> Unique -> Int # hash :: Unique -> Int #
Hashable Version
Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> 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 (Fixed a)
Methods hashWithSalt :: Int -> Fixed a -> Int # hash :: Fixed 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 (StableName a)
Methods hashWithSalt :: Int -> StableName a -> Int # hash :: StableName a -> Int #
Hashable a => Hashable (Identity a)
Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity 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 (TypeRep k a)
Methods hashWithSalt :: Int -> TypeRep k a -> Int # hash :: TypeRep k a -> 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 k a)
Methods hashWithSalt :: Int -> Proxy k a -> Int # hash :: Proxy k 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 k a b)
Methods hashWithSalt :: Int -> Const k a b -> Int # hash :: Const k 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 (Product * f g a)
Methods hashWithSalt :: Int -> Product * f g a -> Int # hash :: Product * f g a -> 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 #
(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)	In general, `hash (Compose x) ≠ hash x`. However, `hashWithSalt` satisfies its variant of this equivalence.
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 Natural	Since: 0.7.3.0
Methods put :: Natural -> Put # get :: Get Natural # putList :: [Natural] -> 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 RuntimeRep	@since 0.8.5.0. See
Methods put :: RuntimeRep -> Put # get :: Get RuntimeRep # putList :: [RuntimeRep] -> Put #
Binary VecCount	@since 0.8.5.0. See
Methods put :: VecCount -> Put # get :: Get VecCount # putList :: [VecCount] -> Put #
Binary VecElem	@since 0.8.5.0. See
Methods put :: VecElem -> Put # get :: Get VecElem # putList :: [VecElem] -> Put #
Binary SomeTypeRep
Methods put :: SomeTypeRep -> Put # get :: Get SomeTypeRep # putList :: [SomeTypeRep] -> Put #
Binary ()
Methods put :: () -> Put # get :: Get () # putList :: [()] -> Put #
Binary TyCon	@since 0.8.5.0. See
Methods put :: TyCon -> Put # get :: Get TyCon # putList :: [TyCon] -> Put #
Binary KindRep	@since 0.8.5.0. See
Methods put :: KindRep -> Put # get :: Get KindRep # putList :: [KindRep] -> Put #
Binary TypeLitSort	@since 0.8.5.0. See
Methods put :: TypeLitSort -> Put # get :: Get TypeLitSort # putList :: [TypeLitSort] -> 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 All	Since: 0.8.4.0
Methods put :: All -> Put # get :: Get All # putList :: [All] -> Put #
Binary Any	Since: 0.8.4.0
Methods put :: Any -> Put # get :: Get Any # putList :: [Any] -> 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 a => Binary (Complex a)
Methods put :: Complex a -> Put # get :: Get (Complex a) # putList :: [Complex 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 (Min a)	Since: 0.8.4.0
Methods put :: Min a -> Put # get :: Get (Min a) # putList :: [Min a] -> Put #
Binary a => Binary (Max a)	Since: 0.8.4.0
Methods put :: Max a -> Put # get :: Get (Max a) # putList :: [Max a] -> Put #
Binary a => Binary (First a)	Since: 0.8.4.0
Methods put :: First a -> Put # get :: Get (First a) # putList :: [First a] -> Put #
Binary a => Binary (Last a)	Since: 0.8.4.0
Methods put :: Last a -> Put # get :: Get (Last a) # putList :: [Last a] -> Put #
Binary m => Binary (WrappedMonoid m)	Since: 0.8.4.0
Methods put :: WrappedMonoid m -> Put # get :: Get (WrappedMonoid m) # putList :: [WrappedMonoid m] -> Put #
Binary a => Binary (Option a)	Since: 0.8.4.0
Methods put :: Option a -> Put # get :: Get (Option a) # putList :: [Option a] -> Put #
Binary a => Binary (NonEmpty a)	Since: 0.8.4.0
Methods put :: NonEmpty a -> Put # get :: Get (NonEmpty a) # putList :: [NonEmpty a] -> Put #
Binary a => Binary (Dual a)	Since: 0.8.4.0
Methods put :: Dual a -> Put # get :: Get (Dual a) # putList :: [Dual a] -> Put #
Binary a => Binary (Sum a)	Since: 0.8.4.0
Methods put :: Sum a -> Put # get :: Get (Sum a) # putList :: [Sum a] -> Put #
Binary a => Binary (Product a)	Since: 0.8.4.0
Methods put :: Product a -> Put # get :: Get (Product a) # putList :: [Product a] -> Put #
Binary a => Binary (First a)	Since: 0.8.4.0
Methods put :: First a -> Put # get :: Get (First a) # putList :: [First a] -> Put #
Binary a => Binary (Last a)	Since: 0.8.4.0
Methods put :: Last a -> Put # get :: Get (Last a) # putList :: [Last 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 #
Typeable k a => Binary (TypeRep k a)
Methods put :: TypeRep k a -> Put # get :: Get (TypeRep k a) # putList :: [TypeRep k a] -> 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 a, Binary b) => Binary (Arg a b)	Since: 0.8.4.0
Methods put :: Arg a b -> Put # get :: Get (Arg a b) # putList :: [Arg a b] -> 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 (f a) => Binary (Alt k f a)	Since: 0.8.4.0
Methods put :: Alt k f a -> Put # get :: Get (Alt k f a) # putList :: [Alt k f a] -> 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.

Note: Generic1 can be auto-derived starting with GHC 7.4

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic, Generic1)
import Control.DeepSeq

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

instance NFData a => NFData (Foo a)
instance NFData1 Foo

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, Generic1, NFData, NFData1)

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

instance NFData Colour where rnf = rwhnf

or

{-# 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 Natural	Since: 1.4.0.0
Methods rnf :: Natural -> () #
NFData Ordering
Methods rnf :: Ordering -> () #
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 ()
Methods rnf :: () -> () #
NFData TyCon	NOTE: Only defined for `base-4.8.0.0` and later Since: 1.4.0.0
Methods rnf :: TyCon -> () #
NFData Void	Defined as `rnf = absurd`. Since: 1.4.0.0
Methods rnf :: Void -> () #
NFData Unique	Since: 1.4.0.0
Methods rnf :: Unique -> () #
NFData Version	Since: 1.3.0.0
Methods rnf :: Version -> () #
NFData ThreadId	Since: 1.4.0.0
Methods rnf :: ThreadId -> () #
NFData ExitCode	Since: 1.4.2.0
Methods rnf :: ExitCode -> () #
NFData TypeRep	NOTE: Only defined for `base-4.8.0.0` and later Since: 1.4.0.0
Methods rnf :: TypeRep -> () #
NFData All	Since: 1.4.0.0
Methods rnf :: All -> () #
NFData Any	Since: 1.4.0.0
Methods rnf :: Any -> () #
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 CBool	Since: 1.4.3.0
Methods rnf :: CBool -> () #
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 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 ZonedTime
Methods rnf :: ZonedTime -> () #
NFData LocalTime
Methods rnf :: LocalTime -> () #
NFData TimeOfDay
Methods rnf :: TimeOfDay -> () #
NFData TimeZone
Methods rnf :: TimeZone -> () #
NFData UniversalTime
Methods rnf :: UniversalTime -> () #
NFData UTCTime
Methods rnf :: UTCTime -> () #
NFData NominalDiffTime
Methods rnf :: NominalDiffTime -> () #
NFData Day
Methods rnf :: Day -> () #
NFData RunChanged #
Methods rnf :: RunChanged -> () #
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 (Complex a)
Methods rnf :: Complex a -> () #
NFData (Fixed a)	Since: 1.3.0.0
Methods rnf :: Fixed 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 (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 (Identity a)	Since: 1.4.0.0
Methods rnf :: Identity 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 (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 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 (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 (FingerTree a)
Methods rnf :: FingerTree 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 (Set a)
Methods rnf :: Set a -> () #
NFData a => NFData (Hashed a)
Methods rnf :: Hashed a -> () #
NFData a => NFData (HashSet a)
Methods rnf :: HashSet a -> () #
NFData value => NFData (RunResult value) #
Methods rnf :: RunResult value -> () #
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 a1, NFData a2, NFData a3) => NFData (a1, a2, a3)
Methods rnf :: (a1, a2, a3) -> () #
NFData a => NFData (Const k a b)	Since: 1.4.0.0
Methods rnf :: Const k a b -> () #
NFData ((:~:) k a b)	Since: 1.4.3.0
Methods rnf :: (k :~: a) b -> () #
(NFData a1, NFData a2, NFData a3, NFData a4) => NFData (a1, a2, a3, a4)
Methods rnf :: (a1, a2, a3, a4) -> () #
(NFData1 f, NFData1 g, NFData a) => NFData (Product * f g a)	Since: 1.4.3.0
Methods rnf :: Product * f g a -> () #
(NFData1 f, NFData1 g, NFData a) => NFData (Sum * f g a)	Since: 1.4.3.0
Methods rnf :: Sum * f g a -> () #
NFData ((:~~:) k1 k2 a b)	Since: 1.4.3.0
Methods rnf :: (k1 :~~: k2) a b -> () #
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5)
Methods rnf :: (a1, a2, a3, a4, a5) -> () #
(NFData1 f, NFData1 g, NFData a) => NFData (Compose * * f g a)	Since: 1.4.3.0
Methods rnf :: Compose * * f g a -> () #
(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