ú΋n†­V      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUportablestablelibraries@haskell.org:Indicates that it may be beneficial to evaluate the first A argument in parallel with the second. Returns the value of the  second argument. a `` b' is exactly equivalent semantically to b. par% is generally used when the value of a is likely to be A required later, but not immediately. Also it is a good idea to  ensure that a5 is not a trivial computation, otherwise the cost of > spawning it in parallel overshadows the benefits obtained by  running it in parallel. :Note that actual parallelism is only supported by certain  implementations (GHC with the  -threaded option, and GPH, for " now). On other implementations,  par a b = b. Semantically identical to V , but with a subtle operational  difference: V2 is strict in both its arguments, so the compiler  may, for example, rearrange a `V` b into b `V` a `V` b. ( This is normally no problem when using V to express strictness, ? but it can be a problem when annotating code for parallelism, C 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 . This is why we have . In contrast to V,  is only E strict in its first argument (as far as the compiler is concerned), C which restricts the transformations that the compiler can do, and C ensures that the user can retain control of the evaluation order. portable experimentallibraries@haskell.org The type  a is a -> (). E Thus, a strategy is a function whose sole purpose it is to evaluate + its argument (either in full or in part). +Evaluate a value using the given strategy. ,Evaluate a value using the given strategy.  This is simply  with arguments reversed.  performs *no* evaluation. 2 evaluates its argument to weak head normal form.  fully evaluates its argument.  Relies on class W from module Control.DeepSeq. AEvaluate each element of a list according to the given strategy. & This function is a specialisation of   to lists. IEvaluate the first n elements of a list according to the given strategy. CEvaluate the nth element of a list (if there is such) according to  the given strategy. L The spine of the list up to the nth element is evaluated as a side effect. @Evaluate the elements of a foldable data structure according to  the given strategy. CEvaluate the elements of an array according to the given strategy. C Evaluation of the array bounds may be triggered as a side effect. AEvaluate the bounds of an array according to the given strategy. IEvaluate the keys and values of a map according to the given strategies.     portable experimentallibraries@haskell.orgCDEPRECCATED: replaced by the  monad  a name for Control.Seq.Strategy, for documetnation only. A = is a function that embodies a parallel evaluation strategy. K The function traverses (parts of) its argument, evaluating subexpressions  in parallel or in sequence. A 1 may do an arbitrary amount of evaluation of its C argument, but should not return a value different from the one it  was passed. DParallel computations may be discarded by the runtime system if the 9 program no longer requires their result, which is why a  @ function returns a new value equivalent to the old value. The + intention is that the program applies the  to a A structure, and then uses the returned value, discarding the old ( value. This idiom is expressed by the  function. 4 is a Monad that makes it easier to define parallel : strategies. It is a strict identity monad: that is, in   m >>= f m- is evaluated before the result is passed to f.   instance Monad Eval where  return = Done  m >>= k = case m of  Done x -> k x If you wanted to construct a  for a pair that sparked the ; first component in parallel and then evaluated the second  component, you could write   myStrat :: Strategy (a,b) C myStrat (a,b) = do { a' <- rpar a; b' <- rseq b; return (a',b') } =Alternatively, you could write this more compactly using the  Applicative style as + myStrat (a,b) = (,) <$> rpar a <*> rseq b "Pull the result out of the monad. !Evaluate a value using the given .  x `using` s = runEval (s x) !evaluate a value using the given . This is simply   with the arguments reversed. &Compose two strategies sequentially. = This is the analogue to function composition on strategies. 5 strat2 `dot` strat1 == strat2 . withStrategy strat1 ?Inject a sequential strategy (ie. coerce a sequential strategy  to a general strategy).  Thanks to   , the type Control.Seq.Strategy a is a subtype  of  a. !! performs *no* evaluation.  r0 == evalSeq Control.Seq.r0 ""2 evaluates its argument to weak head normal form. " rseq == evalSeq Control.Seq.rseq ## fully evaluates its argument. * rdeepseq == evalSeq Control.Seq.rdeepseq $$3 sparks its argument (for evaluation in parallel). %7Evaluate the elements of a traversable data structure " according to the given strategy. &Like %) but evaluates all elements in parallel. 'AEvaluate each element of a list according to the given strategy.  Equivalent to % at the list type. (IEvaluate each element of a list in parallel according to given strategy.  Equivalent to & at the list type. )evaListSplitAt n stratPref stratSuff evaluates the prefix  (of length n) of a list according to  stratPref and its the suffix  according to  stratSuff. *Like )* but evaluates both sublists in parallel. +IEvaluate the first n elements of a list according to the given strategy. ,Like +1 but evaluates the first n elements in parallel. -CEvaluate the nth element of a list (if there is such) according to  the given strategy. L The spine of the list up to the nth element is evaluated as a side effect. .Like +, but evaluates the nth element in parallel. /5Divides a list into chunks, and applies the strategy  ' strat to each chunk in parallel. =It is expected that this function will be replaced by a more 2 generic clustering infrastructure in the future. XYDEPRECATED: use ( " instead 0A combination of ( and Z", encapsulating a common pattern: - parMap strat f = withStrategy strat . map f [11; is a rolling buffer strategy combinator for (lazy) lists. 18 is not as compositional as the type suggests. In fact, ? it evaluates list elements at least to weak head normal form, " disregarding a strategy argument !. & evalBuffer n r0 == evalBuffer n rseq \2Like 12 but evaluates the list elements in parallel when  pushing them into the buffer. 3456789:;<=>?@ABCASequential function application. The argument is evaluated using : the given strategy before it is given to the function. D?Parallel function application. The argument is evaluated using @ the given strategy, in parallel with the function application. E/Sequential function composition. The result of = the second function is evaluated using the given strategy, ' and then given to the first function. F8Parallel function composition. The result of the second 1 function is evaluated using the given strategy, 9 in parallel with the application of the first function. G*Sequential inverse function composition, 7 for those who read their programs from left to right. : The result of the first function is evaluated using the 8 given strategy, and then given to the second function. H'Parallel inverse function composition, 7 for those who read their programs from left to right. : The result of the first function is evaluated using the : given strategy, in parallel with the application of the  second function. IDEPRECATED: Use  or C instead JDEPRECATED: Use  or D instead KDEPRECATED: Use  or C instead LDEPRECATED: Use  or D instead MDEPRECATED: renamed to " NDEPRECATED: renamed to % ODEPRECATED: renamed to & PDEPRECATED: renamed to ' QDEPRECATED: renamed to 3 RDEPRECATED: renamed to ; SDEPRECATED: renamed to 4 TDEPRECATED: renamed to < UDEPRECATED: renamed to  ? !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU?!"#$ %&'(+,-.)*/0123456789:;<=>?@ABCDEFGHIJKLMUNOPQRST? !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU]         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL MNOPQRSTUVWXYZ[\]^_parallel-3.1.0.1Control.Parallel Control.SeqControl.Parallel.StrategiesparpseqStrategyusing withStrategyr0rseqrdeepseqseqListseqListN seqListNth seqFoldableseqArrayseqArrayBoundsseqMap seqTuple2 seqTuple3 seqTuple4 seqTuple5 seqTuple6 seqTuple7 seqTuple8 seqTuple9Done SeqStrategyEvalrunEvaldotevalSeqrparevalTraversableparTraversableevalListparListevalListSplitAtparListSplitAt evalListNparListN evalListNth parListNth parListChunkparMap evalBuffer parBuffer evalTuple2 evalTuple3 evalTuple4 evalTuple5 evalTuple6 evalTuple7 evalTuple8 evalTuple9 parTuple2 parTuple3 parTuple4 parTuple5 parTuple6 parTuple7 parTuple8 parTuple9$|$||.|.||-|-|| demandingsparking>|>||rwhnf seqTraverse parTraverseseqPairparPair seqTriple parTripleunEvalghc-primGHC.Primseqdeepseq-1.1.0.2Control.DeepSeqNFDatachunk parListWHNFbaseGHC.BasemapevalBufferWHNF parBufferWHNF