úÎ?=¸    WInspect the dynamic pointer tagging bits of a closure. This is an impure function that s relies on GHC internals and will falsely return 0, but (hopefully) never give the wrong tag number if it returns  a non-0 value. \Returns a guess as to whether or not a value has been evaluated. This is an impure function c that relies on GHC internals and will return false negatives, but (hopefully) no false positives.  g f a evaluates f g while forcing a, if g == a then f g is returned. Otherwise f a is evaluated. lFurthermore, if the argument has already been evaluated, we avoid sparking the parallel computation at all.  If a good guess at the value of aW is available, this is one way to induce parallelism in an otherwise sequential task. However, if the guess isn']t available more cheaply than the actual answer, then this saves no work and if the guess is 0 wrong, you risk evaluating the function twice.   spec a f a = f $! a #The best-case timeline looks like:   [---- f g ----]  [----- a -----]  [-- spec g f a --] $The worst-case timeline looks like:   [---- f g ----]  [----- a -----] " [---- f a ----] " [------- spec g f a -----------] !Compare these to the timeline of f $! a:  [---- a -----]  [---- f a ----] Unlike _, this version does not check to see if the argument has already been evaluated. This can save T a small amount of work when you know the argument will always require computation. Given a valid estimator g,  g f z xs yields the same answer as  f z xs. g nL should supply an estimate of the value returned from folding over the last n elements of the container. If g nd is accurate a reasonable percentage of the time and faster to compute than the fold, then this can 2 provide increased opportunities for parallelism.  specFoldr = specFoldrN 0 Given a valid estimator g,  g f z xs yields the same answer as  f z xs. g nM should supply an estimate of the value returned from folding over the first n elements of the container. If g nd is accurate a reasonable percentage of the time and faster to compute than the fold, then this can 2 provide increased opportunities for parallelism.  specFoldl = specFoldlN 0  is to foldr1' as  is to  Given a valid estimator g,  n g f z xs yields the same answer as  f z xs. g mL should supply an estimate of the value returned from folding over the last m - n elements of the container.  is to foldl1' as  is to  Given a valid estimator g,  n g f z xs yields the same answer as  f z xs. g mM should supply an estimate of the value returned from folding over the first m - n elements of the container.       g f a evaluates f g while forcing a, if g == a then f g* is returned. Otherwise the side-effects 4 of the current STM transaction are rolled back and f a is evaluated. If the argument a is already evaluated, we don't bother to perform f g at all.  If a good guess at the value of aW is available, this is one way to induce parallelism in an otherwise sequential task. However, if the guess isn']t available more cheaply than the actual answer then this saves no work, and if the guess is 0 wrong, you risk evaluating the function twice.   specSTM a f a = f $! a #The best-case timeline looks like:   [------ f g ------]  [------- a -------]  [--- specSTM g f a ---] $The worst-case timeline looks like:   [------ f g ------]  [------- a -------] ( [-- rollback --] ? [------ f a ------] : [------------------ spec g f a ------------------------] !Compare these to the timeline of f $! a:  [------- a -------] ' [------ f a ------] Unlike specSTM, specSTM' doesn'4t check if the argument has already been evaluated.         speculation-0.2.0Control.Concurrent.Speculation"Control.Concurrent.STM.Speculation evaluatedspecspec' specFoldr specFoldl specFoldr1 specFoldrN specFoldl1 specFoldlNspecSTMspecSTM'Boxtagbase Data.Foldablefoldr'foldl'specFoldr1ListfoldrspecFoldl1ListfoldlerrorEmptyStructure SpeculationspeculationSupplyfreshSpeculation