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
class Show a where
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 toplevel 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 recordsyntax 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 rightassociativity of :^:
is ignored. For example,

produces the stringshow
(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"
.
:: 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.
class Typeable a where
The class Typeable
allows a concrete representation of a type to
be calculated.
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
.
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 Progress  
Eq BS  
Eq Verbosity  
Eq Assume  
Eq StepKey  
Eq Step  
Eq GetDirectoryA  
Eq GetDirectoryQ  
Eq DoesDirectoryExistA  
Eq DoesDirectoryExistQ  
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.
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 thehashWithSalt
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 thehashWithSalt
method 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 hashingbased 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.
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.
class NFData a where
A class of types that can be fully evaluated.
rnf :: a > ()
rnf should reduce its argument to normal form (that is, fully evaluate all subcomponents), 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).
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 BS  
NFData StepKey  
NFData Depends  
NFData Step  
NFData GetDirectoryA  
NFData GetDirectoryQ  
NFData DoesDirectoryExistA  
NFData DoesDirectoryExistQ  
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) 