| dph-base-0.3: Basic Definitions for Data-Parallel Haskell. | Source code | 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
Read (readsPrec, readList, readPrec, readListPrec)
class Rebox a where

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

newtype Box a = Box a
ST (ST)
runST

Documentation

check :: String -> Int -> Int -> a -> a | Source

checkCritical :: String -> Int -> Int -> a -> a | Source

checkLen :: String -> Int -> Int -> a -> a | Source

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

checkNotEmpty :: String -> Int -> a -> a | Source

uninitialised :: String -> a | Source

Strict pairs

data a :*: b | Source

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

sndS :: (a :*: b) -> b | Source

pairS :: (a, b) -> a :*: b | Source

unpairS :: (a :*: b) -> (a, b) | Source

curryS :: ((a :*: b) -> c) -> a -> b -> c | Source

uncurryS :: (a -> b -> c) -> (a :*: b) -> c | Source

unsafe_pairS :: (a, b) -> a :*: b | Source

Same as `pairS` but comes with the unsafe rule

     unsafe_unpairS . unsafe_pairS = id

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

Same as `unpairS` but comes with the unsafe rule

     unsafe_unpairS . unsafe_pairS = id

Strict sums

data EitherS a b | Source

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

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

fromMaybeS :: a -> MaybeS a -> a | Source

Lazy wrapper

data Lazy a | Source

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

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 (BUArr e)
HS e => HS (BBArr 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 | Source

toBool :: Num a => a -> Bool | Source

showsApp :: Show a => Int -> String -> a -> ShowS | Source

readApp :: Read a => String -> ReadPrec a | Source

readsApp :: Read a => Int -> String -> ReadS a | Source

Read (readsPrec, readList, readPrec, readListPrec)

class Rebox a where | Source

Methods

rebox :: a -> a | Source

dseq :: a -> b -> b | Source

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)

newtype Box a | Source

Constructors

Box a |

Instances

Rebox (Box a)

ST (ST)
runST
Produced by Haddock version 2.4.2