| dph-base-0.4.0: Basic Definitions for Data-Parallel Haskell. | Contents | Index

Data.Array.Parallel.Base

Portability | non-portable (unboxed values and GHC libraries)
Stability | internal
Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au>

Contents

Strict pairs
Strict sums
Strict Maybe
Lazy wrapper
Class of hyperstrict types

Description
Interface to the Base modules
Synopsis

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
data a :*: b = !a :*: !b
fstS :: (a :*: b) -> a
sndS :: (a :*: b) -> b
pairS :: (a, b) -> a :*: b
unpairS :: (a :*: b) -> (a, b)
curryS :: ((a :*: b) -> c) -> a -> b -> c
uncurryS :: (a -> b -> c) -> (a :*: b) -> c
unsafe_pairS :: (a, b) -> a :*: b
unsafe_unpairS :: (a :*: b) -> (a, b)

data EitherS a b

= LeftS !a
| RightS !b

data MaybeS a

= NothingS
| JustS !a

maybeS :: b -> (a -> b) -> MaybeS a -> b
fromMaybeS :: a -> MaybeS a -> a
data Lazy a = Lazy a
class HS a
fromBool :: Num a => Bool -> a
toBool :: Num a => a -> Bool
showsApp :: Show a => Int -> String -> a -> ShowS
readApp :: Read a => String -> ReadPrec a
readsApp :: Read a => Int -> String -> ReadS a
class Read a where

readsPrec :: Int -> ReadS a
readList :: ReadS [a]
readPrec :: ReadPrec a
readListPrec :: ReadPrec [a]

class Rebox a where

rebox :: a -> a
dseq :: a -> b -> b

data Box a = Box a
newtype ST s a = ST (STRep s a)
runST :: (forall s. ST s a) -> a

Documentation
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
Strict pairs
data a :*: b

Strict pair
Constructors

!a :*: !b |

Instances

(Eq a, Eq b) => Eq (:*: a b)
(Ord a, Ord b) => Ord (:*: a b)
(Read a, Read b) => Read (:*: a b)
(Show a, Show b) => Show (:*: a b)
(HS a, HS b) => HS (:*: a b)
(Rebox a, Rebox b) => Rebox (:*: a b)

fstS :: (a :*: b) -> a
sndS :: (a :*: b) -> b
pairS :: (a, b) -> a :*: b
unpairS :: (a :*: b) -> (a, b)
curryS :: ((a :*: b) -> c) -> a -> b -> c
uncurryS :: (a -> b -> c) -> (a :*: b) -> c
unsafe_pairS :: (a, b) -> a :*: b

Same as `pairS` but comes with the unsafe rule

     unsafe_unpairS . unsafe_pairS = id

unsafe_unpairS :: (a :*: b) -> (a, b)

Same as `unpairS` but comes with the unsafe rule

     unsafe_unpairS . unsafe_pairS = id

Strict sums
data EitherS a b

Strict sum
Constructors

LeftS !a |
RightS !b |

Instances

(HS a, HS b) => HS (EitherS a b)
(Rebox a, Rebox b) => Rebox (EitherS a b)

Strict Maybe
data MaybeS a

Strict Maybe
Constructors

NothingS |
JustS !a |

Instances

Functor MaybeS
HS a => HS (MaybeS a)
Rebox a => Rebox (MaybeS a)

maybeS :: b -> (a -> b) -> MaybeS a -> b
fromMaybeS :: a -> MaybeS a -> a
Lazy wrapper
data Lazy a

Constructors

Lazy a |

Instances

Functor Lazy
Eq a => Eq (Lazy a)
Ord a => Ord (Lazy a)
Read a => Read (Lazy a)
Show a => Show (Lazy a)
Rebox (Lazy a)

Class of hyperstrict types
class HS a

The class of hyperstrict types. These are those types for which weak head-normal form and normal form are the same. That is, once they are evaluated to WHNF, they are guaranteed to contain no thunks
Instances

HS Bool
HS Char
HS Double
HS Float
HS Int
HS Word8
HS ()
HS a => HS (MaybeS a)
HS e => HS (BBArr e)
HS e => HS (BUArr e)
(HS a, HS b) => HS (EitherS a b)
(HS a, HS b) => HS (:*: a b)
HS e => HS (MBUArr s e)

fromBool :: Num a => Bool -> a
toBool :: Num a => a -> Bool
showsApp :: Show a => Int -> String -> a -> ShowS
readApp :: Read a => String -> ReadPrec a
readsApp :: Read a => Int -> String -> ReadS a
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`

Methods

readsPrec

:: 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 Int8
Read Int16
Read Int32
Read Int64
Read Integer
Read Ordering
Read Word
Read Word8
Read Word16
Read Word32
Read Word64
Read ()
Read BufferMode
Read CChar
Read CSChar
Read CUChar
Read CShort
Read CUShort
Read CInt
Read CUInt
Read CLong
Read CULong
Read CLLong
Read CULLong
Read CFloat
Read CDouble
Read CPtrdiff
Read CSize
Read CWchar
Read CSigAtomic
Read CClock
Read CTime
Read CIntPtr
Read CUIntPtr
Read CIntMax
Read CUIntMax
Read Lexeme
Read StdGen
Read LocalTime
Read ZonedTime
Read TimeOfDay
Read TimeZone
Read UTCTime
Read Day
Read a => Read [a]
(Integral a, Read a) => Read (Ratio a)
Read a => Read (Maybe a)
Read a => Read (Lazy a)
(Read a, Read b) => Read (a, b)
(Ix a, Read a, Read b) => Read (Array a b)
(Read a, Read b) => Read (:*: 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)

class Rebox a where

Methods

rebox :: a -> a
dseq :: a -> b -> b

Instances

Rebox Bool
Rebox Char
Rebox Double
Rebox Float
Rebox Int
Rebox ()
Rebox (Lazy a)
Rebox a => Rebox (MaybeS a)
Rebox (Box a)
(Rebox a, Rebox b) => Rebox (EitherS a b)
(Rebox a, Rebox b) => Rebox (:*: a b)

data Box a

Constructors

Box a |

Instances

Rebox (Box a)

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)
MonadFix (ST s)
MArray (STUArray s) Word (ST s)
MArray (STUArray s) Word8 (ST s)
MArray (STUArray s) Word64 (ST s)
MArray (STUArray s) Word32 (ST s)
MArray (STUArray s) Word16 (ST s)
MArray (STUArray s) Int (ST s)
MArray (STUArray s) Int8 (ST s)
MArray (STUArray s) Int64 (ST s)
MArray (STUArray s) Int32 (ST s)
MArray (STUArray s) Int16 (ST s)
MArray (STUArray s) Float (ST s)
MArray (STUArray s) Double (ST s)
MArray (STUArray s) Char (ST s)
MArray (STUArray s) Bool (ST s)
MArray (STArray s) e (ST s)
MArray (STUArray s) (StablePtr a) (ST s)
MArray (STUArray s) (Ptr a) (ST s)
MArray (STUArray s) (FunPtr a) (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.
Produced by Haddock version 2.6.1