shake-0.15.5: 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 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
- 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

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

class Typeable a

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

Minimal complete definition

typeRep#

class Eq a where

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

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

Minimal complete definition

(==) | (/=)

Methods

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

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

Instances

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

class Hashable a where

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

Minimal implementation: `hashWithSalt`.

Minimal complete definition

Nothing

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 |
Hashable Char |
Hashable Double |
Hashable Float |
Hashable Int |
Hashable Int8 |
Hashable Int16 |
Hashable Int32 |
Hashable Int64 |
Hashable Integer |
Hashable Ordering |
Hashable Word |
Hashable Word8 |
Hashable Word16 |
Hashable Word32 |
Hashable Word64 |
Hashable TypeRep |
Hashable () |
Hashable BigNat |
Hashable Void |
Hashable Natural |
Hashable ThreadId |
Hashable ByteString |
Hashable ByteString |
Hashable ShortByteString |
Hashable Text |
Hashable Text |
Hashable a => Hashable [a] |
(Integral a, Hashable a) => Hashable (Ratio a) |
Hashable (StableName a) |
Hashable a => Hashable (Maybe a) |
(Hashable a, Hashable b) => Hashable (Either a b) |
(Hashable a1, Hashable a2) => Hashable (a1, a2) |
(Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3) |
(Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4) |
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5) |
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6) |
(Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7) |

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

Methods

put :: t -> Put

Encode a value in the Put monad.

get :: Get t

Decode a value in the Get monad

Instances

Binary Bool |
Binary Char |
Binary Double |
Binary Float |
Binary Int |
Binary Int8 |
Binary Int16 |
Binary Int32 |
Binary Int64 |
Binary Integer |
Binary Ordering |
Binary Word |
Binary Word8 |
Binary Word16 |
Binary Word32 |
Binary Word64 |
Binary () |
Binary Natural |
Binary ByteString |
Binary ByteString |
Binary IntSet |
Binary a => Binary [a] |
(Binary a, Integral a) => Binary (Ratio a) |
Binary a => Binary (Maybe a) |
Binary e => Binary (IntMap e) |
Binary a => Binary (Set a) |
Binary e => Binary (Tree e) |
Binary e => Binary (Seq e) |
(Binary a, Binary b) => Binary (Either a b) |
(Binary a, Binary b) => Binary (a, b) |
(Binary i, Ix i, Binary e, IArray UArray e) => Binary (UArray i e) |
(Binary i, Ix i, Binary e) => Binary (Array i e) |
(Binary k, Binary e) => Binary (Map k e) |
(Binary a, Binary b, Binary c) => Binary (a, b, c) |
(Binary a, Binary b, Binary c, Binary d) => Binary (a, b, c, d) |
(Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a, b, c, d, e) |
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a, b, c, d, e, f) |
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a, b, c, d, e, f, g) |
(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) |
(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) |
(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) |

class NFData a where

A class of types that can be fully evaluated.

Since: 1.1.0.0

Minimal complete definition

Nothing

Methods

rnf :: a -> ()

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

### `Generic` `NFData` deriving

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

    {-# LANGUAGE DeriveGeneric #-}

    import GHC.Generics (Generic)
    import Control.DeepSeq

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

    instance NFData a => NFData (Foo a)

    data Colour = Red | Green | Blue
                  deriving Generic

    instance NFData Colour

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

    {-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

    import GHC.Generics (Generic)
    import Control.DeepSeq

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

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

### Compatibility with previous `deepseq` versions

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

    rnf a = seq a ()

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

    instance NFData Colour where rnf x = seq x ()

or alternatively

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

Instances

NFData Bool |
NFData Char |
NFData Double |
NFData Float |
NFData Int |
NFData Int8 |
NFData Int16 |
NFData Int32 |
NFData Int64 |
NFData Integer |
NFData Word |
NFData Word8 |
NFData Word16 |
NFData Word32 |
NFData Word64 |
NFData TypeRep | NOTE: Only defined for `base-4.8.0.0` and later Since: 1.4.0.0
NFData () |
NFData Void | Defined as ``rnf` = `absurd``. Since: 1.4.0.0
NFData Unique | Since: 1.4.0.0
NFData Natural | Since: 1.4.0.0
NFData Version | Since: 1.3.0.0
NFData ThreadId | Since: 1.4.0.0
NFData CChar | Since: 1.4.0.0
NFData CSChar | Since: 1.4.0.0
NFData CUChar | Since: 1.4.0.0
NFData CShort | Since: 1.4.0.0
NFData CUShort | Since: 1.4.0.0
NFData CInt | Since: 1.4.0.0
NFData CUInt | Since: 1.4.0.0
NFData CLong | Since: 1.4.0.0
NFData CULong | Since: 1.4.0.0
NFData CLLong | Since: 1.4.0.0
NFData CULLong | Since: 1.4.0.0
NFData CFloat | Since: 1.4.0.0
NFData CDouble | Since: 1.4.0.0
NFData CPtrdiff | Since: 1.4.0.0
NFData CSize | Since: 1.4.0.0
NFData CWchar | Since: 1.4.0.0
NFData CSigAtomic | Since: 1.4.0.0
NFData CClock | Since: 1.4.0.0
NFData CTime | Since: 1.4.0.0
NFData CUSeconds | Since: 1.4.0.0
NFData CSUSeconds | Since: 1.4.0.0
NFData CFile | Since: 1.4.0.0
NFData CFpos | Since: 1.4.0.0
NFData CJmpBuf | Since: 1.4.0.0
NFData CIntPtr | Since: 1.4.0.0
NFData CUIntPtr | Since: 1.4.0.0
NFData CIntMax | Since: 1.4.0.0
NFData CUIntMax | Since: 1.4.0.0
NFData All | Since: 1.4.0.0
NFData Any | Since: 1.4.0.0
NFData TyCon | NOTE: Only defined for `base-4.8.0.0` and later Since: 1.4.0.0
NFData Fingerprint | Since: 1.4.0.0
NFData ByteString |
NFData ByteString |
NFData ShortByteString |
NFData IntSet |
NFData LocalTime |
NFData ZonedTime |
NFData TimeOfDay |
NFData TimeZone |
NFData UTCTime |
NFData NominalDiffTime |
NFData Day |
NFData a => NFData [a] |
(Integral a, NFData a) => NFData (Ratio a) |
NFData (StableName a) | Since: 1.4.0.0
NFData a => NFData (Identity a) | Since: 1.4.0.0
NFData (Fixed a) | Since: 1.3.0.0
NFData a => NFData (Complex a) |
NFData a => NFData (ZipList a) | Since: 1.4.0.0
NFData a => NFData (Dual a) | Since: 1.4.0.0
NFData a => NFData (Sum a) | Since: 1.4.0.0
NFData a => NFData (Product a) | Since: 1.4.0.0
NFData a => NFData (First a) | Since: 1.4.0.0
NFData a => NFData (Last a) | Since: 1.4.0.0
NFData a => NFData (Down a) | Since: 1.4.0.0
NFData a => NFData (Maybe a) |
NFData a => NFData (Digit a) |
NFData a => NFData (Node a) |
NFData a => NFData (Elem a) |
NFData a => NFData (FingerTree a) |
NFData a => NFData (IntMap a) |
NFData a => NFData (Set a) |
NFData a => NFData (Tree a) |
NFData a => NFData (Seq a) |
NFData a => NFData (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
(NFData a, NFData b) => NFData (Either a b) |
(NFData a, NFData b) => NFData (a, b) |
(Ix a, NFData a, NFData b) => NFData (Array a b) |
NFData a => NFData (Const a b) | Since: 1.4.0.0
NFData (Proxy * a) | Since: 1.4.0.0
(NFData k, NFData a) => NFData (Map k a) |
(NFData k, NFData v) => NFData (Leaf k v) |
(NFData k, NFData v) => NFData (HashMap k v) |
(NFData a, NFData b, NFData c) => NFData (a, b, c) |
(NFData a, NFData b, NFData c, NFData d) => NFData (a, b, c, d) |
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5) |
(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6) => NFData (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) |
(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) |
(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) |