|
Data.Array.Parallel.Base | Portability | non-portable (unboxed values and GHC libraries) | Stability | internal | Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |
|
|
|
|
|
Description |
Interface to the Base modules
|
|
Synopsis |
|
|
|
Documentation |
|
|
|
|
|
|
|
|
|
|
|
|
|
Strict pairs
|
|
|
|
|
|
|
|
|
|
|
|
|
curryS :: ((a :*: b) -> c) -> a -> b -> c | Source |
|
|
uncurryS :: (a -> b -> c) -> (a :*: b) -> c | Source |
|
|
|
Same as pairS but comes with the unsafe rule
unsafe_unpairS . unsafe_pairS = id
|
|
|
Same as unpairS but comes with the unsafe rule
unsafe_unpairS . unsafe_pairS = id
|
|
Strict sums
|
|
|
|
|
Strict Maybe
|
|
|
Strict Maybe
| Constructors | |
|
|
|
|
|
|
Lazy wrapper
|
|
|
|
|
Class of hyperstrict types
|
|
|
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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 | | :: 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.
|
| | | 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).
| | | 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.
|
|
|
|
|
|
|
|
|
|
|
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 | |
|
|
|
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.0 |