seq package:parallel

Sequential strategies provide ways to compositionally specify the degree of evaluation of a data type between the extremes of no evaluation and full evaluation. Sequential strategies may be viewed as complimentary to the parallel ones (see module Control.Parallel.Strategies).
Deprecated: renamed to evalList
Deprecated: renamed to evalTuple2
Deprecated: renamed to evalTraversable
Deprecated: renamed to evalTuple3
Evaluate the elements of an array according to the given strategy. Evaluation of the array bounds may be triggered as a side effect.
Evaluate the bounds of an array according to the given strategy.
Evaluate the elements of a foldable data structure according to the given strategy.
Evaluate each element of a list according to the given strategy. This function is a specialisation of seqFoldable to lists.
Evaluate the first n elements of a list according to the given strategy.
Evaluate the nth element of a list (if there is such) according to the given strategy. The spine of the list up to the nth element is evaluated as a side effect.
Evaluate the keys and values of a map according to the given strategies.
A name for Control.Seq.Strategy, for documentation only.
Semantically identical to seq, but with a subtle operational difference: seq is strict in both its arguments, so the compiler may, for example, rearrange a `seq` b into b `seq` a `seq` b. This is normally no problem when using seq to express strictness, but it can be a problem when annotating code for parallelism, because we need more control over the order of evaluation; we may want to evaluate a before b, because we know that b has already been sparked in parallel with par. This is why we have pseq. In contrast to seq, pseq is only strict in its first argument (as far as the compiler is concerned), which restricts the transformations that the compiler can do, and ensures that the user can retain control of the evaluation order.
Inject a sequential strategy (ie. coerce a sequential strategy to a general strategy). Thanks to evalSeq, the type Control.Seq.Strategy a is a subtype of Strategy a.
rdeepseq fully evaluates its argument.
rdeepseq == evalSeq Control.Seq.rdeepseq
rseq evaluates its argument to weak head normal form.
rseq == evalSeq Control.Seq.rseq