Basic functionality, imported by most modules.
- check :: String -> Int -> Int -> a -> a
- checkCritical :: String -> Int -> Int -> a -> a
- checkLen :: String -> Int -> Int -> a -> a
- checkEq :: (Eq a, Show a) => String -> String -> a -> a -> b -> b
- checkNotEmpty :: String -> Int -> a -> a
- uninitialised :: String -> a
- type Tag = Int
- fromBool :: Bool -> Tag
- toBool :: Tag -> Bool
- tagToInt :: Tag -> Int
- intToTag :: Int -> Tag
- showsApp :: Show a => Int -> String -> a -> ShowS
- readApp :: Read a => String -> ReadPrec a
- readsApp :: Read a => Int -> String -> ReadS a
- class Read a where
- module Data.Array.Parallel.Base.DTrace
- module Data.Array.Parallel.Base.TracePrim
- newtype ST s a = ST (STRep s a)
- runST :: (forall s. ST s a) -> a
Debugging infrastructure
checkCritical :: String -> Int -> Int -> a -> aSource
Bounds check, enabled when debugCritical
= True
.
This version is used to check operations that could corrupt the heap.
The first integer is the length of the array, and the second
is the index. The second must be greater or equal to '0' and less than the
first integer. If the not then error
with the String
.
checkNotEmpty :: String -> Int -> a -> aSource
Given an array length, check it is not zero.
uninitialised :: String -> aSource
Throw an error saying something was not intitialised.
The String
must contain a helpful message saying what module the error occured in,
and the possible reasons for it. If not then a puppy dies at compile time.
Data constructor tags
Given a value of an algebraic type, the tag tells us what data constructor was used to create it.
Utils for defining Read/Show instances.
class Read a where
Parsing of String
s, producing values.
Minimal complete definition: readsPrec
(or, for GHC only, readPrec
)
Derived instances of Read
make the following assumptions, which
derived instances of Text.Show.Show
obey:
- If the constructor is defined to be an infix operator, then the
derived
Read
instance will parse only infix applications of the constructor (not the prefix form). - Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
- If the constructor is defined using record syntax, the derived
Read
will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration. - The derived
Read
instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Read
in Haskell 98 is equivalent to
instance (Read a) => Read (Tree a) where readsPrec d r = readParen (d > app_prec) (\r -> [(Leaf m,t) | ("Leaf",s) <- lex r, (m,t) <- readsPrec (app_prec+1) s]) r ++ readParen (d > up_prec) (\r -> [(u:^:v,w) | (u,s) <- readsPrec (up_prec+1) r, (":^:",t) <- lex s, (v,w) <- readsPrec (up_prec+1) t]) r where app_prec = 10 up_prec = 5
Note that right-associativity of :^:
is unused.
The derived instance in GHC is equivalent to
instance (Read a) => Read (Tree a) where readPrec = parens $ (prec app_prec $ do Ident "Leaf" <- lexP m <- step readPrec return (Leaf m)) +++ (prec up_prec $ do u <- step readPrec Symbol ":^:" <- lexP v <- step readPrec return (u :^: v)) where app_prec = 10 up_prec = 5 readListPrec = readListPrecDefault
:: Int | the operator precedence of the enclosing
context (a number from |
-> ReadS a |
attempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.
Derived instances of Read
and Text.Show.Show
satisfy the following:
-
(x,"")
is an element of(
.readsPrec
d (Text.Show.showsPrec
d x ""))
That is, readsPrec
parses the string produced by
Text.Show.showsPrec
, and delivers the value that
Text.Show.showsPrec
started with.
The method readList
is provided to allow the programmer to
give a specialised way of parsing lists of values.
For example, this is used by the predefined Read
instance of
the Char
type, where values of type String
should be are
expected to use double quotes, rather than square brackets.
Proposed replacement for readsPrec
using new-style parsers (GHC only).
readListPrec :: ReadPrec [a]
Proposed replacement for readList
using new-style parsers (GHC only).
The default definition uses readList
. Instances that define readPrec
should also define readListPrec
as readListPrecDefault
.
Read Bool | |
Read Char | |
Read Double | |
Read Float | |
Read Int | |
Read Integer | |
Read Ordering | |
Read () | |
Read Lexeme | |
Read Arity | |
Read Fixity | |
Read Associativity | |
Read a => Read [a] | |
(Integral a, Read a) => Read (Ratio a) | |
Read a => Read (Maybe a) | |
(Read a, Read b) => Read (a, b) | |
(Ix a, Read a, Read b) => Read (Array a b) | |
(Read a, Read b, Read c) => Read (a, b, c) | |
(Read a, Read b, Read c, Read d) => Read (a, b, c, d) | |
(Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) | |
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
Tracing infrastructure
ST monad re-exported from GHC
newtype ST s a
The strict state-transformer monad.
A computation of type
transforms an internal state indexed
by ST
s as
, and returns a value of type a
.
The s
parameter is either
- an uninstantiated type variable (inside invocations of
runST
), or -
RealWorld
(inside invocations ofControl.Monad.ST.stToIO
).
It serves to keep the internal states of different invocations
of runST
separate from each other and from invocations of
Control.Monad.ST.stToIO
.
The >>=
and >>
operations are strict in the state (though not in
values stored in the state). For example,
runST
(writeSTRef _|_ v >>= f) = _|_
ST (STRep s a) |