| Safe Haskell | None |
|---|
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.
Minimal complete definition: showsPrec or show.
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 = 5
Note 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 where
The class Typeable allows a concrete representation of a type to
be calculated.
Methods
Instances
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 () | |
| Eq Handle | |
| Eq Version | |
| Eq Constr | Equality of constructors |
| Eq DataRep | |
| Eq ConstrRep | |
| Eq Fixity | |
| Eq HandlePosn | |
| 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 ThreadId | |
| Eq BlockReason | |
| Eq ThreadStatus | |
| Eq AsyncException | |
| Eq ArrayException | |
| Eq ExitCode | |
| Eq IOErrorType | |
| Eq BufferMode | |
| Eq Newline | |
| Eq NewlineMode | |
| Eq All | |
| Eq Any | |
| Eq TypeRepKey | |
| Eq GeneralCategory | |
| 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 IODeviceType | |
| Eq SeekMode | |
| Eq IOMode | |
| Eq MaskingState | |
| Eq IOException | |
| Eq ArithException | |
| Eq TypeRep | |
| Eq TyCon | |
| Eq ByteString | |
| Eq ByteString | |
| Eq IntSet | |
| Eq Permissions | |
| Eq Text | |
| Eq Text | |
| Eq LocalTime | |
| Eq UTCTime | |
| Eq NominalDiffTime | |
| Eq Day | |
| Eq Witness | |
| Eq Value | |
| Eq Key | |
| Eq Id | |
| Eq FileTime | |
| Eq Lexeme | |
| Eq Verbosity | |
| Eq Assume | |
| Eq Progress | |
| Eq StepKey | |
| Eq Step | |
| Eq GetDirectoryA | |
| Eq GetDirectoryQ | |
| Eq DoesFileExistA | |
| Eq DoesFileExistQ | |
| Eq FileA | |
| Eq FileQ | |
| Eq AlwaysRerunA | |
| Eq AlwaysRerunQ | |
| Eq FilesA | |
| Eq FilesQ | |
| Eq a => Eq [a] | |
| Eq a => Eq (Ratio a) | |
| Eq (StableName a) | |
| Eq (Fixed a) | |
| Eq a => Eq (Complex a) | |
| Eq (TVar 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 (IORef a) | |
| Eq (MVar a) | |
| Eq a => Eq (Maybe a) | |
| Eq a => Eq (Tree a) | |
| Eq a => Eq (Seq a) | |
| Eq a => Eq (ViewL a) | |
| Eq a => Eq (ViewR a) | |
| Eq a => Eq (IntMap a) | |
| Eq a => Eq (Set a) | |
| (Hashable a, Eq a) => Eq (HashSet a) | |
| Eq answer => Eq (OracleA answer) | |
| Eq question => Eq (OracleQ question) | |
| (Eq a, Eq b) => Eq (Either a b) | |
| (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 k, Eq a) => Eq (Map k a) | |
| (Eq k, Eq v) => Eq (Leaf k v) | |
| (Eq k, Eq v) => Eq (HashMap k v) | |
| (Eq a, Eq b, Eq c) => Eq (a, b, c) | |
| Eq (STUArray s i e) | |
| Eq (STArray s i e) | |
| (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.
Methods
hashWithSalt :: Int -> a -> Int
Return a hash value for the argument, using the given salt.
The general contract of hashWithSalt is:
- If a value is hashed using the same salt during distinct runs of an application, the result must remain the same. (This is necessary to make it possible to store hashes on persistent media.)
- 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. (Every programmer will be aware that producing distinct integer results for unequal values will 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.
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 parsing 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.
Instances
class NFData a where
A class of types that can be fully evaluated.
Methods
rnf :: a -> ()
rnf should reduce its argument to normal form (that is, fully evaluate all sub-components), and then return '()'.
The default implementation of rnf is
rnf a = a `seq` ()
which may be convenient when defining instances for data types with no unevaluated fields (e.g. enumerations).
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 () | |
| NFData Version | |
| NFData ByteString | |
| NFData ByteString | |
| NFData IntSet | |
| NFData Text | |
| NFData Text | |
| NFData LocalTime | |
| NFData ZonedTime | |
| NFData UTCTime | |
| NFData NominalDiffTime | |
| NFData Day | |
| NFData Value | |
| NFData Key | |
| NFData Id | |
| NFData FileTime | |
| NFData StepKey | |
| NFData Depends | |
| NFData Step | |
| NFData GetDirectoryA | |
| NFData GetDirectoryQ | |
| NFData DoesFileExistA | |
| NFData DoesFileExistQ | |
| NFData FileA | |
| NFData FileQ | |
| NFData AlwaysRerunA | |
| NFData AlwaysRerunQ | |
| NFData FilesA | |
| NFData FilesQ | |
| NFData a => NFData [a] | |
| (Integral a, NFData a) => NFData (Ratio a) | |
| NFData (Fixed a) | |
| (RealFloat a, NFData a) => NFData (Complex a) | |
| 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 (Tree a) | |
| NFData a => NFData (Seq a) | |
| NFData a => NFData (IntMap a) | |
| NFData a => NFData (Set a) | |
| NFData a => NFData (HashSet a) | |
| NFData answer => NFData (OracleA answer) | |
| NFData question => NFData (OracleQ question) | |
| NFData (a -> b) | This instance is for convenience and consistency with |
| (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 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) |