úÎbÒ`g,      !"#$%&'()*+ non-portable experimentallibraries@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  , but with a subtle operational  difference: 2 is strict in both its arguments, so the compiler  may, for example, rearrange a  b into b  a  b. ( This is normally no problem when using  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 ,  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.  non-portable experimentallibraries@haskell.org+,-,Reduces its argument to (head) normal form. 'A strategy takes a value and returns a  value to indicate that / the specifed evaluation has been performed.  0Evaluates the first argument before the second. :Evaluates the first argument in parallel with the second. >Takes a value and a strategy, and applies the strategy to the B value before returning the value. Used to express data-oriented  parallelism. x `using` s is a projection on x , i.e. both:  a retraction x `using` s "‘ x  idempotent (x `using` s) `using` s = x `using` s 0Evaluates the second argument before the first. : Used to express control-oriented parallelism. The second - argument is usually a strategy application. :Evaluates the second argument in parallel with the first. " Used to express control-oriented E parallelism. The second argument is usually a strategy application. A strategy corresponding to :  x `par` e = e `using` sPar x.  has been superceded by  .  Replace e `using` sPar x with e `sparking` rwhnf x. A strategy corresponding to .:  x `seq` e = e `using` sSeq x.  has been superceded by  .  Replace e `using` sSeq x with e ` demanding` rwhnf x.  Performs no evaluation of its argument. /Reduces its argument to weak head normal form. ASequential function application. The argument is evaluated using : the given strategy before it is given to the function. ?Parallel function application. The argument is evaluated using @ the given strategy, in parallel with the function application. /Sequential function composition. The result of = the second function is evaluated using the given strategy, ' and then given to the first function. 8Parallel 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. *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. '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. <Apply two strategies to the elements of a pair sequentially  from left to right. <Apply two strategies to the elements of a pair in parallel. CApply three strategies to the elements of a triple in sequentially  from left to right. @Apply three strategies to the elements of a triple in parallel. ;Applies a strategy to every element of a list in parallel.  Applies a strategy to the first n! elements of a list in parallel.  Evaluates n8 elements of the spine of the argument list and applies  the given strategy to the n.th element (if there is one) in parallel with  the result. E.g. parListNth 2 [e1, e2, e3] evaluates e3. 4Splits a list into chunks (sub-sequences) of length n, = and applies a strategy sequentially to the elements in each . chunk. The chunks are evaluated in parallel. / This is useful for increasing the grain size. 2Applies a function to each element of a list and , and evaluates the result list in parallel, , using the given strategy for each element. !Uses  ) to apply a list-valued function to each > element of a list in parallel, and concatenates the results. "*Zips together two lists using a function, , and evaluates the result list in parallel. #;Sequentially applies a strategy to each element of a list. $CSequentially applies a strategy to the first n elements of a list. %Applies a strategy to the nth element of a list 2 (if there is one) before returning the result.  E.g. seqListNth 2 [e1, e2, e3] evaluates e3. &IApplies a strategy to the nth element of list when the head is demanded.  More precisely:  semantics: parBuffer n s = id :: [a] -> [a] D dynamic behaviour: evalutates the nth element of the list when the  head is demanded. The idea is to provide a `rolling buffer' of length n. &: has been added for the revised version of the strategies  paper and supersedes the older  fringeList. ';Apply a strategy to all elements of an array sequentially. (:Apply a strategy to all elements of an array in parallel. )*+)  !"#$%&'()*+)  !"#$%&'()*+)  !"#$%&'()*+/      !"#$%&'()*+,-./0123parallel-1.1.0.1Control.ParallelControl.Parallel.Strategiesghc-primGHC.PrimseqparpseqAssoc:=NFDatarnfStrategyDone>|>||using demandingsparkingsParsSeqr0rwhnf$|$||.|.||-|-||seqPairparPair seqTriple parTripleparListparListN parListNth parListChunkparMap parFlatMap parZipWithseqListseqListN seqListNth parBufferseqArrparArrfstPairFstListforcesforce NFDataOrdNFDataIntegral