dph-base-0.4.0: Basic Definitions for Data-Parallel Haskell.Source codeContentsIndex
Data.Array.Parallel.Base
Portabilitynon-portable (unboxed values and GHC libraries)
Stabilityinternal
MaintainerRoman 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 -> aSource
checkCritical :: String -> Int -> Int -> a -> aSource
checkLen :: String -> Int -> Int -> a -> aSource
checkEq :: (Eq a, Show a) => String -> String -> a -> a -> b -> bSource
checkNotEmpty :: String -> Int -> a -> aSource
uninitialised :: String -> aSource
Strict pairs
data a :*: b Source
Strict pair
Constructors
!a :*: !b
show/hide 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) -> aSource
sndS :: (a :*: b) -> bSource
pairS :: (a, b) -> a :*: bSource
unpairS :: (a :*: b) -> (a, b)Source
curryS :: ((a :*: b) -> c) -> a -> b -> cSource
uncurryS :: (a -> b -> c) -> (a :*: b) -> cSource
unsafe_pairS :: (a, b) -> a :*: bSource

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
show/hide 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
show/hide Instances
maybeS :: b -> (a -> b) -> MaybeS a -> bSource
fromMaybeS :: a -> MaybeS a -> aSource
Lazy wrapper
data Lazy a Source
Constructors
Lazy a
show/hide 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
show/hide 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 -> aSource
toBool :: Num a => a -> BoolSource
showsApp :: Show a => Int -> String -> a -> ShowSSource
readApp :: Read a => String -> ReadPrec aSource
readsApp :: Read a => Int -> String -> ReadS aSource
class Read a whereSource

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
readsPrecSource
:: Intthe 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]Source
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 aSource
Proposed replacement for readsPrec using new-style parsers (GHC only).
readListPrec :: ReadPrec [a]Source
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.
show/hide 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 whereSource
Methods
rebox :: a -> aSource
dseq :: a -> b -> bSource
show/hide Instances
data Box a Source
Constructors
Box a
show/hide Instances
newtype ST s a Source

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)
show/hide Instances
runST :: (forall s. ST s a) -> aSource
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