shake-0.15.10: Build system library, like Make, but more accurate dependencies.

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

- class Show a where
  - showsPrec :: Int -> a -> ShowS
  - show :: a -> String
  - showList :: [a] -> ShowS
- class Typeable k a
- class Eq a where
  - (==) :: a -> a -> Bool
  - (/=) :: a -> a -> Bool
- class Hashable a where
  - hashWithSalt :: Int -> a -> Int
  - hash :: a -> Int
- class Binary t where
  - put :: t -> Put
  - get :: Get t
  - putList :: [t] -> Put
- class NFData a where
  - rnf :: a -> ()

# Documentation

class Show a where #

Conversion of values to readable `String`s.

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

Instances

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

class Typeable k a #

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

Minimal complete definition

typeRep#

class Eq a where #

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

Minimal complete definition: either `==` or `/=`.

Minimal complete definition

(==) | (/=)

Instances

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

Minimal complete definition

Nothing

Instances

Hashable Bool |
Methods hashWithSalt :: Int -> Bool -> Int # hash :: Bool -> Int #
Hashable Char |
Methods hashWithSalt :: Int -> Char -> Int # hash :: Char -> Int #
Hashable Double |
Methods hashWithSalt :: Int -> Double -> Int # hash :: Double -> Int #
Hashable Float |
Methods hashWithSalt :: Int -> Float -> Int # hash :: Float -> Int #
Hashable Int |
Methods hashWithSalt :: Int -> Int -> Int # hash :: Int -> Int #
Hashable Int8 |
Methods hashWithSalt :: Int -> Int8 -> Int # hash :: Int8 -> Int #
Hashable Int16 |
Methods hashWithSalt :: Int -> Int16 -> Int # hash :: Int16 -> Int #
Hashable Int32 |
Methods hashWithSalt :: Int -> Int32 -> Int # hash :: Int32 -> Int #
Hashable Int64 |
Methods hashWithSalt :: Int -> Int64 -> Int # hash :: Int64 -> Int #
Hashable Integer |
Methods hashWithSalt :: Int -> Integer -> Int # hash :: Integer -> Int #
Hashable Ordering |
Methods hashWithSalt :: Int -> Ordering -> Int # hash :: Ordering -> Int #
Hashable Word |
Methods hashWithSalt :: Int -> Word -> Int # hash :: Word -> Int #
Hashable Word8 |
Methods hashWithSalt :: Int -> Word8 -> Int # hash :: Word8 -> Int #
Hashable Word16 |
Methods hashWithSalt :: Int -> Word16 -> Int # hash :: Word16 -> Int #
Hashable Word32 |
Methods hashWithSalt :: Int -> Word32 -> Int # hash :: Word32 -> Int #
Hashable Word64 |
Methods hashWithSalt :: Int -> Word64 -> Int # hash :: Word64 -> Int #
Hashable TypeRep |
Methods hashWithSalt :: Int -> TypeRep -> Int # hash :: TypeRep -> Int #
Hashable () |
Methods hashWithSalt :: Int -> () -> Int # hash :: () -> Int #
Hashable BigNat |
Methods hashWithSalt :: Int -> BigNat -> Int # hash :: BigNat -> Int #
Hashable Natural |
Methods hashWithSalt :: Int -> Natural -> Int # hash :: Natural -> Int #
Hashable Void |
Methods hashWithSalt :: Int -> Void -> Int # hash :: Void -> Int #
Hashable Version |
Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
Hashable Unique |
Methods hashWithSalt :: Int -> Unique -> Int # hash :: Unique -> Int #
Hashable ThreadId |
Methods hashWithSalt :: Int -> ThreadId -> Int # hash :: ThreadId -> Int #
Hashable 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 a => Hashable (Min a) |
Methods hashWithSalt :: Int -> Min a -> Int # hash :: Min a -> Int #
Hashable a => Hashable (Max a) |
Methods hashWithSalt :: Int -> Max a -> Int # hash :: Max a -> Int #
Hashable a => Hashable (First a) |
Methods hashWithSalt :: Int -> First a -> Int # hash :: First a -> Int #
Hashable a => Hashable (Last a) |
Methods hashWithSalt :: Int -> Last a -> Int # hash :: Last a -> Int #
Hashable a => Hashable (WrappedMonoid a) |
Methods hashWithSalt :: Int -> WrappedMonoid a -> Int # hash :: WrappedMonoid a -> Int #
Hashable a => Hashable (Option a) |
Methods hashWithSalt :: Int -> Option a -> Int # hash :: Option a -> Int #
Hashable a => Hashable (NonEmpty a) |
Methods hashWithSalt :: Int -> NonEmpty a -> Int # hash :: NonEmpty a -> Int #
Hashable (Fixed a) |
Methods hashWithSalt :: Int -> Fixed a -> Int # hash :: Fixed a -> Int #
Hashable (StableName a) |
Methods hashWithSalt :: Int -> StableName a -> Int # hash :: StableName a -> Int #
Hashable a => Hashable (HashSet a) |
Methods hashWithSalt :: Int -> HashSet a -> Int # hash :: HashSet a -> Int #
(Hashable a, Hashable b) => Hashable (Either a b) |
Methods hashWithSalt :: Int -> Either a b -> Int # hash :: Either a b -> Int #
(Hashable a1, Hashable a2) => Hashable (a1, a2) |
Methods hashWithSalt :: Int -> (a1, a2) -> Int # hash :: (a1, a2) -> Int #
(Hashable a, Hashable b) => Hashable (Arg a b) |
Methods hashWithSalt :: Int -> Arg a b -> Int # hash :: Arg a b -> Int #
(Hashable 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 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 #
(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 #
(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.

Minimal complete definition

Nothing

Instances

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

class NFData a where #

A class of types that can be fully evaluated.

Since: 1.1.0.0

Minimal complete definition

Nothing

Instances

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