| 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.
Documentation
class Show a where
Conversion of values to readable Strings.
Derived instances of Show have the following properties, which
are compatible with derived instances of Read:
- The result of
showis 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
showsPrecwill produce infix applications of the constructor. - the representation will be enclosed in parentheses if the
precedence of the top-level constructor in
xis less thand(associativity is ignored). Thus, ifdis0then the result is never surrounded in parentheses; ifdis11it is always surrounded in parentheses, unless it is an atomic expression. - If the constructor is defined using record syntax, then
showwill 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 = 5Note that right-associativity of :^: is ignored. For example,
show(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
Methods
Arguments
| :: Int | the operator precedence of the enclosing
context (a number from |
| -> a | the value to be converted to a |
| -> ShowS |
Convert a value to a readable String.
showsPrec should satisfy the law
showsPrec d x r ++ s == showsPrec d x (r ++ s)
Derived instances of Read and Show satisfy the following:
That is, readsPrec parses the string produced by
showsPrec, and delivers the value that showsPrec started with.
Instances
class Typeable a
The class Typeable allows a concrete representation of a type to
be calculated.
Minimal complete definition
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.
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 Errno | |
| Eq AsyncException | |
| Eq ArrayException | |
| Eq ExitCode | |
| Eq IOErrorType | |
| Eq BufferMode | |
| Eq Newline | |
| Eq NewlineMode | |
| Eq IODeviceType | |
| Eq SeekMode | |
| 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 Clock | |
| Eq TimeSpec | |
| 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 CmdOption | |
| Eq Progress | |
| Eq EqualCost | |
| Eq Verbosity | |
| Eq Change | |
| Eq Lint | |
| Eq Assume | |
| 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 thehashWithSaltmethod 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 thehashWithSaltmethod 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
hashWithSaltmust make use of the salt in its implementation.
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
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
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 ColourStarting 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
rnfa =seqa ()
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 Since: 1.4.0.0 |
| NFData () | |
| NFData Void | 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 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 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) |