Safe Haskell | None |
---|
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
type ShakeValue a = (Show a, Typeable a, Eq a, Hashable a, Binary a, NFData a)Source
Define an alias for the six type classes required for things involved in Shake Rule
s.
This alias is only available in GHC 7.4 and above, and requires the ConstraintKinds
extension.
To define your own values meeting the necessary constraints it is convenient to use the extensions
GeneralizedNewtypeDeriving
and DeriveDataTypeable
to write:
newtype MyType = MyType (String, Bool) deriving (Show,Typeable,Eq,Hashable,Binary,NFData)
class Show a
Conversion of values to readable String
s.
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
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 thand
(associativity is ignored). Thus, ifd
is0
then the result is never surrounded in parentheses; ifd
is11
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,
-
produces the stringshow
(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"
.
class Typeable a
The class Typeable
allows a concrete representation of a type to
be calculated.
class Eq a
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
.
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 FileTime | |
Eq Witness | |
Eq Value | |
Eq Key | |
Eq Id | |
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
The class of types that can be converted to a hash value.
class Binary t
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.
class NFData a
A class of types that can be fully evaluated.
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 FileTime | |
NFData Value | |
NFData Key | |
NFData Id | |
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) |