dph-base-0.5.1.1: Common utilities and config for Data Parallel Haskell

Data.Array.Parallel.Base

Contents

Description

Basic functionality, imported by most modules.

Synopsis

Debugging infrastructure

check :: String -> Int -> Int -> a -> aSource

Bounds check, enabled when debug = True.

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.

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.

checkLen :: String -> Int -> Int -> a -> aSource

Length check, enabled when debug = True.

Check that the second integer is greater or equal to `0' and less or equal than the first integer. If the not then error with the String.

checkEq :: (Eq a, Show a) => String -> String -> a -> a -> b -> bSource

Equality check, enabled when debug = True.

The two a values must be equal, else error.

The first String gives the location of the error, and the second some helpful message.

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

type Tag = IntSource

Given a value of an algebraic type, the tag tells us what data constructor was used to create it.

fromBool :: Bool -> TagSource

Get the Tag of a Bool value. False is 0, True is 1.

toBool :: Tag -> BoolSource

Convert a Tag to a Bool value.

tagToInt :: Tag -> IntSource

Convert a Tag to an Int. This is identity at the value level.

intToTag :: Int -> TagSource

Convert an Int to a Tag. This is identity at the value level.

Utils for defining Read/Show instances.

showsApp :: Show a => Int -> String -> a -> ShowSSource

class Read a where

Parsing of Strings, 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

Methods

readsPrec

Arguments

:: Int

the operator precedence of the enclosing context (a number from 0 to 11). Function application has precedence 10.

-> 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.

readList :: ReadS [a]

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.

readPrec :: ReadPrec a

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.

Instances

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 ST s a transforms an internal state indexed by s, and returns a value of type a. The s parameter is either

  • an uninstantiated type variable (inside invocations of runST), or
  • RealWorld (inside invocations of Control.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) = _|_

Constructors

ST (STRep s a) 

Instances

Monad (ST s) 
Functor (ST s) 
Show (ST s a) 

runST :: (forall s. ST s a) -> a

Return the value computed by a state transformer computation. The forall ensures that the internal state used by the ST computation is inaccessible to the rest of the program.