-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | This package provides a library for parallel programming.
--   
--   For documentation, start from the <a>Control.Parallel.Strategies</a>
--   module below.
--   
--   For more tutorial documentation, see the book <a>Parallel and
--   Concurrent Programming in Haskell</a>.
--   
--   To understand the principles behind the library, see <a>Seq no more:
--   Better Strategies for Parallel Haskell</a>.
@package parallel
@version 3.3.0.0


-- | Parallel constructs.
--   
--   A common pattern to evaluate two values in parallel is:
--   
--   <pre>
--   x `par` y `pseq` someFunc x y
--   </pre>
--   
--   The effect of this pattern is to cause <tt>x</tt> to be evaluated in
--   parallel with <tt>y</tt>. When the evaluation of <tt>y</tt> is
--   complete, computation proceeds by evaluating <tt>someFunc x y</tt>.
module Control.Parallel

-- | Indicates that it may be beneficial to evaluate the first argument in
--   parallel with the second. Returns the value of the second argument.
--   
--   The result of <tt>a <a>`par`</a> b</tt> is always <tt>b</tt>,
--   regardless of whether <tt>a</tt> evaluates to a bottom, so for example
--   <tt>par undefined x = x</tt>.
--   
--   <tt>par</tt> is generally used when the value of <tt>a</tt> is likely
--   to be required later, but not immediately. Also it is a good idea to
--   ensure that <tt>a</tt> 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 <tt>-threaded</tt> option, for now). On
--   other implementations, <tt>par a b = b</tt>.
par :: a -> b -> b
infixr 0 `par`

-- | Like <a>seq</a> but ensures that the first argument is evaluated
--   before returning.
--   
--   <tt>a <a>`pseq`</a> b</tt> evaluates <tt>a</tt> to weak head normal
--   form (WHNF) before returning <tt>b</tt>.
--   
--   This is similar to <a>seq</a>, but with a subtle difference:
--   <a>seq</a> is strict in both its arguments, so the compiler may, for
--   example, rearrange <tt>a <a>`seq`</a> b</tt> into <tt>b <a>`seq`</a> a
--   <a>`seq`</a> b</tt>. This is normally no problem when using <a>seq</a>
--   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 <tt>a</tt> before <tt>b</tt>,
--   because we know that <tt>b</tt> has already been sparked in parallel
--   with <a>par</a>.
--   
--   This is why we have <a>pseq</a>. In contrast to <a>seq</a>,
--   <a>pseq</a> 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.
pseq :: a -> b -> b
infixr 0 `pseq`


-- | 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
--   complementary to the parallel ones (see module
--   <a>Control.Parallel.Strategies</a>).
module Control.Seq

-- | The type <tt><a>Strategy</a> a</tt> is <tt>a -&gt; ()</tt>. Thus, a
--   strategy is a function whose sole purpose it is to evaluate its
--   argument (either in full or in part).
type Strategy a = a -> ()

-- | Evaluate a value using the given strategy.
using :: a -> Strategy a -> a
infixl 0 `using`

-- | Evaluate a value using the given strategy. This is simply <a>using</a>
--   with arguments reversed.
withStrategy :: Strategy a -> a -> a

-- | <a>r0</a> performs <i>no</i> evaluation.
r0 :: Strategy a

-- | <a>rseq</a> evaluates its argument to weak head normal form.
rseq :: Strategy a

-- | <a>rdeepseq</a> fully evaluates its argument. Relies on class
--   <a>NFData</a> from module <a>Control.DeepSeq</a>.
rdeepseq :: NFData a => Strategy a

-- | Evaluate each element of a list according to the given strategy. This
--   function is a specialisation of <a>seqFoldable</a> to lists.
seqList :: Strategy a -> Strategy [a]

-- | Evaluate the first n elements of a list according to the given
--   strategy.
seqListN :: Int -> Strategy a -> Strategy [a]

-- | 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.
seqListNth :: Int -> Strategy a -> Strategy [a]

-- | Evaluate the elements of a foldable data structure according to the
--   given strategy.
seqFoldable :: Foldable t => Strategy a -> Strategy (t a)

-- | Evaluate the keys and values of a map according to the given
--   strategies.
seqMap :: Strategy k -> Strategy v -> Strategy (Map k v)

-- | Evaluate the elements of an array according to the given strategy.
--   Evaluation of the array bounds may be triggered as a side effect.
seqArray :: Strategy a -> Strategy (Array i a)

-- | Evaluate the bounds of an array according to the given strategy.
seqArrayBounds :: Strategy i -> Strategy (Array i a)
seqTuple2 :: Strategy a -> Strategy b -> Strategy (a, b)
seqTuple3 :: Strategy a -> Strategy b -> Strategy c -> Strategy (a, b, c)
seqTuple4 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy (a, b, c, d)
seqTuple5 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy (a, b, c, d, e)
seqTuple6 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy (a, b, c, d, e, f)
seqTuple7 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy (a, b, c, d, e, f, g)
seqTuple8 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy (a, b, c, d, e, f, g, h)
seqTuple9 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy i -> Strategy (a, b, c, d, e, f, g, h, i)


-- | Parallel evaluation strategies, or strategies for short, provide ways
--   to express parallel computations. Strategies have the following key
--   features:
--   
--   <ul>
--   <li>Strategies express <i>deterministic parallelism</i>: the result of
--   the program is unaffected by evaluating in parallel. The parallel
--   tasks evaluated by a strategy may have no side effects. For
--   non-deterministic parallel programming, see
--   <a>Control.Concurrent</a>.</li>
--   <li>Strategies let you separate the description of the parallelism
--   from the logic of your program, enabling modular parallelism. The
--   basic idea is to build a lazy data structure representing the
--   computation, and then write a strategy that describes how to traverse
--   the data structure and evaluate components of it sequentially or in
--   parallel.</li>
--   <li>Strategies are <i>compositional</i>: larger strategies can be
--   built by gluing together smaller ones.</li>
--   <li>The <a>Eval</a> monad is provided, for quickly building strategies
--   that involve traversing structures in a regular way.</li>
--   </ul>
--   
--   For API history and changes in this release, see
--   <a>Control.Parallel.Strategies#history</a>.
module Control.Parallel.Strategies

-- | A <a>Strategy</a> is a function that embodies a parallel evaluation
--   strategy. The function traverses (parts of) its argument, evaluating
--   subexpressions in parallel or in sequence.
--   
--   A <a>Strategy</a> may do an arbitrary amount of evaluation of its
--   argument, but should not return a value different from the one it was
--   passed.
--   
--   Parallel computations may be discarded by the runtime system if the
--   program no longer requires their result, which is why a
--   <a>Strategy</a> function returns a new value equivalent to the old
--   value. The intention is that the program applies the <a>Strategy</a>
--   to a structure, and then uses the returned value, discarding the old
--   value. This idiom is expressed by the <a>using</a> function.
type Strategy a = a -> Eval a

-- | Evaluate a value using the given <a>Strategy</a>.
--   
--   <pre>
--   x `using` s = runEval (s x)
--   </pre>
using :: a -> Strategy a -> a
infixl 0 `using`

-- | Evaluate a value using the given <a>Strategy</a>. This is simply
--   <a>using</a> with the arguments reversed.
withStrategy :: Strategy a -> a -> a

-- | Evaluate a value using the given <a>Strategy</a> inside the <a>IO</a>
--   monad. See also <a>runEvalIO</a>.
--   
--   <pre>
--   x `usingIO` s = runEvalIO (s x)
--   </pre>
usingIO :: a -> Strategy a -> IO a
infixl 0 `usingIO`

-- | Evaluate a value using the given <a>Strategy</a> inside the <a>IO</a>
--   monad. This is simply <a>usingIO</a> with the arguments reversed.
withStrategyIO :: Strategy a -> a -> IO a

-- | Compose two strategies.
--   
--   <pre>
--   strat2 `dot` strat1 == strat2 . withStrategy strat1
--   </pre>
--   
--   <a>dot</a> is associative:
--   
--   <pre>
--   (strat1 `dot` strat2) `dot` strat3 == strat1 `dot` (strat2 `dot` strat3)
--   </pre>
--   
--   <a>r0</a> and <a>rseq</a> are one-sided identities of <a>dot</a>:
--   
--   <pre>
--   strat `dot` r0 == strat
--   strat `dot` rseq == strat
--   </pre>

-- | <i>Deprecated: <a>dot</a> is an unintuitive composition operator. Use
--   <a>&lt;=&lt;</a> instead.</i>
dot :: Strategy a -> Strategy a -> Strategy a
infixr 9 `dot`

-- | <a>r0</a> performs <i>no</i> evaluation.
--   
--   <pre>
--   r0 == evalSeq Control.Seq.r0
--   </pre>
r0 :: Strategy a

-- | <a>rseq</a> evaluates its argument to weak head normal form.
--   
--   <pre>
--   rseq == evalSeq Control.Seq.rseq
--   </pre>
rseq :: Strategy a

-- | <a>rdeepseq</a> fully evaluates its argument.
--   
--   <pre>
--   rdeepseq == evalSeq Control.Seq.rdeepseq
--   </pre>
rdeepseq :: NFData a => Strategy a

-- | <a>rpar</a> sparks its argument (for evaluation in parallel).
rpar :: Strategy a

-- | Perform a computation in parallel using a strategy.
--   
--   <pre>
--   rparWith strat x
--   </pre>
--   
--   will spark <tt>strat x</tt>. Note that <tt>rparWith strat</tt> is
--   <i>not</i> the same as <tt>rpar <a>`dot`</a> strat</tt>. Specifically,
--   <tt>rpar <a>`dot`</a> strat</tt> always sparks a computation to reduce
--   the result of the strategic computation to WHNF, while <tt>rparWith
--   strat</tt> need not.
--   
--   <pre>
--   rparWith r0 = r0
--   rparWith rpar = rpar
--   rparWith rseq = rpar
--   </pre>
--   
--   <tt>rparWith rpar x</tt> creates a spark that immediately creates
--   another spark to evaluate <tt>x</tt>. We consider this equivalent to
--   <tt>rpar</tt> because there isn't any real additional parallelism.
--   However, it is always less efficient because there's a bit of extra
--   work to create the first (useless) spark. Similarly, <tt>rparWith
--   r0</tt> creates a spark that does precisely nothing. No real
--   parallelism is added, but there is a bit of extra work to do nothing.
rparWith :: Strategy a -> Strategy a

-- | Inject a sequential strategy (i.e., coerce a sequential strategy to a
--   general strategy).
--   
--   Thanks to <a>evalSeq</a>, the type <tt><a>SeqStrategy</a> a</tt> is a
--   subtype of <tt><a>Strategy</a> a</tt>.
evalSeq :: SeqStrategy a -> Strategy a

-- | A name for <tt>Control.Seq.Strategy</tt>, for documentation only.
type SeqStrategy a = Strategy a

-- | Evaluate the elements of a traversable data structure according to the
--   given strategy.
evalTraversable :: Traversable t => Strategy a -> Strategy (t a)

-- | Like <a>evalTraversable</a>, but evaluates all elements in parallel.
parTraversable :: Traversable t => Strategy a -> Strategy (t a)

-- | A generalisation of <a>parMap</a> using <a>parTraversable</a> and
--   <a>fmap</a>:
--   
--   <pre>
--   parFmap strat g = withStrategy (parTraversable strat) . fmap f
--   </pre>
parFmap :: Traversable t => Strategy b -> (a -> b) -> t a -> t b

-- | Evaluate each element of a list according to the given strategy.
--   Equivalent to <a>evalTraversable</a> at the list type.
--   
--   <b>Warning:</b> This strategy evaluates the spine of the list and thus
--   does not work on infinite lists.
evalList :: Strategy a -> Strategy [a]

-- | Evaluate each element of a list in parallel according to given
--   strategy. Equivalent to <a>parTraversable</a> at the list type.
--   
--   <b>Warning:</b> This strategy evaluates the spine of the list and thus
--   does not work on infinite lists.
parList :: Strategy a -> Strategy [a]

-- | Evaluate the first n elements of a list according to the given
--   strategy.
evalListN :: Int -> Strategy a -> Strategy [a]

-- | Like <a>evalListN</a>, but evaluates the first n elements in parallel.
parListN :: Int -> Strategy a -> Strategy [a]

-- | Evaluate the nth element of a list (if there is such) according to the
--   given strategy. This nth is 0-based. For example, <tt>[1, 2, 3, 4, 5]
--   <a>`using`</a> evalListNth 4 rseq</tt> will eval <tt>5</tt>, not
--   <tt>4</tt>. The spine of the list up to the nth element is evaluated
--   as a side effect.
evalListNth :: Int -> Strategy a -> Strategy [a]

-- | Like <a>evalListNth</a>, but evaluates the nth element in parallel.
parListNth :: Int -> Strategy a -> Strategy [a]

-- | <tt><tt>evaListSplitAt</tt> n stratPref stratSuff</tt> evaluates the
--   prefix (of length <tt>n</tt>) of a list according to
--   <tt>stratPref</tt> and the suffix according to <tt>stratSuff</tt>.
evalListSplitAt :: Int -> Strategy [a] -> Strategy [a] -> Strategy [a]

-- | Like <a>evalListSplitAt</a>, but evaluates both sublists in parallel.
parListSplitAt :: Int -> Strategy [a] -> Strategy [a] -> Strategy [a]

-- | Divides a list into chunks, and applies the strategy
--   <tt><a>evalList</a> strat</tt> to each chunk in parallel.
--   
--   If the chunk size is 1 or less, <a>parListChunk</a> is equivalent to
--   <a>parList</a>
--   
--   This function may be replaced by a more generic clustering
--   infrastructure in the future.
--   
--   <b>Warning:</b> This strategy evaluates the spine of the list and thus
--   does not work on infinite lists.
parListChunk :: Int -> Strategy a -> Strategy [a]

-- | A combination of <a>parList</a> and <a>map</a>, encapsulating a common
--   pattern:
--   
--   <pre>
--   parMap strat f = withStrategy (parList strat) . map f
--   </pre>
--   
--   <b>Warning:</b> This function evaluates the spine of the list and thus
--   does not work on infinite lists.
parMap :: Strategy b -> (a -> b) -> [a] -> [b]

-- | <a>evalBuffer</a> is a rolling buffer strategy combinator for lazy
--   lists. Pattern matching on the result of <tt>evalBuffer n strat
--   xs</tt> will evaluate the first <tt>n+1</tt> elements of <tt>xs</tt>
--   using <tt>strat</tt>. Pattern matching on each additional list cons
--   will evaluate an additional element using <tt>strat</tt>.
evalBuffer :: Int -> Strategy a -> Strategy [a]

-- | <a>parBuffer</a> is a rolling buffer strategy combinator for lazy
--   lists. Pattern matching on the result of <tt>parBuffer n s xs</tt>
--   sparks computations to evaluate the first <tt>n+1</tt> elements of
--   <tt>xs</tt> using the strategy <tt>s</tt>. Pattern matching on each
--   additional list cons will spark an additional computation.
--   
--   <pre>
--   parBuffer n strat = <a>evalBuffer</a> n (<a>rparWith</a> strat)
--   </pre>
parBuffer :: Int -> Strategy a -> Strategy [a]
evalTuple2 :: Strategy a -> Strategy b -> Strategy (a, b)
evalTuple3 :: Strategy a -> Strategy b -> Strategy c -> Strategy (a, b, c)
evalTuple4 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy (a, b, c, d)
evalTuple5 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy (a, b, c, d, e)
evalTuple6 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy (a, b, c, d, e, f)
evalTuple7 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy (a, b, c, d, e, f, g)
evalTuple8 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy (a, b, c, d, e, f, g, h)
evalTuple9 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy i -> Strategy (a, b, c, d, e, f, g, h, i)
parTuple2 :: Strategy a -> Strategy b -> Strategy (a, b)
parTuple3 :: Strategy a -> Strategy b -> Strategy c -> Strategy (a, b, c)
parTuple4 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy (a, b, c, d)
parTuple5 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy (a, b, c, d, e)
parTuple6 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy (a, b, c, d, e, f)
parTuple7 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy (a, b, c, d, e, f, g)
parTuple8 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy (a, b, c, d, e, f, g, h)
parTuple9 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy i -> Strategy (a, b, c, d, e, f, g, h, i)

-- | Sequential function application. The argument is evaluated using the
--   given strategy before it is given to the function.
($|) :: (a -> b) -> Strategy a -> a -> b

-- | Parallel function application. The argument is evaluated using the
--   given strategy, in parallel with the function application.
($||) :: (a -> b) -> Strategy a -> a -> b

-- | Sequential function composition. The result of the second function is
--   evaluated using the given strategy, and then given to the first
--   function.
(.|) :: (b -> c) -> Strategy b -> (a -> b) -> a -> c

-- | Parallel function composition. The result of the second function is
--   evaluated using the given strategy, in parallel with the application
--   of the first function.
(.||) :: (b -> c) -> Strategy b -> (a -> b) -> a -> c

-- | Sequential inverse function composition, for those who read their
--   programs from left to right. The result of the first function is
--   evaluated using the given strategy, and then given to the second
--   function.
(-|) :: (a -> b) -> Strategy b -> (b -> c) -> a -> c

-- | Parallel inverse function composition, 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.
(-||) :: (a -> b) -> Strategy b -> (b -> c) -> a -> c

-- | <a>Eval</a> is a monad that makes it easier to define parallel
--   strategies. It is a strict identity monad, that is, in
--   
--   <pre>
--   m &gt;&gt;= f
--   </pre>
--   
--   <tt>m</tt> is evaluated before the result is passed to <tt>f</tt>.
--   
--   <pre>
--   instance Monad Eval where
--     return  = Done
--     m &gt;&gt;= k = case m of
--                 Done x -&gt; k x
--   </pre>
--   
--   If you wanted to construct a <a>Strategy</a> for a pair that sparked
--   the first component in parallel and then evaluated the second
--   component, you could write
--   
--   <pre>
--   myStrat :: Strategy (a,b)
--   myStrat (a,b) = do { a' &lt;- rpar a; b' &lt;- rseq b; return (a',b') }
--   </pre>
--   
--   Alternatively, you could write this more compactly using the
--   Applicative style as
--   
--   <pre>
--   myStrat (a,b) = (,) &lt;$&gt; rpar a &lt;*&gt; rseq b
--   </pre>
--   
--   More examples, using the Applicative instance:
--   
--   <pre>
--   parList :: Strategy a -&gt; Strategy [a]
--   parList strat = traverse (rpar `dot` strat))
--   </pre>
--   
--   <pre>
--   evalPair :: Strategy a -&gt; Strategy b -&gt; Strategy (a,b)
--   evalPair f g (a,b) = pure (,) &lt;$&gt; f a &lt;*&gt; g b
--   </pre>
data Eval a

-- | <a>parEval</a> sparks the computation of its argument for evaluation
--   in parallel. Unlike <tt><a>rpar</a> . <a>runEval</a></tt>,
--   <a>parEval</a>
--   
--   <ul>
--   <li>does not exit the <a>Eval</a> monad</li>
--   <li>does not have a built-in <a>rseq</a>, so for example
--   <tt><a>parEval</a> (<a>r0</a> x)</tt> behaves as you might expect (it
--   creates a spark that does no evaluation).</li>
--   </ul>
--   
--   It is related to <a>rparWith</a> by the following equality:
--   
--   <pre>
--   parEval . strat = rparWith strat
--   </pre>
parEval :: Eval a -> Eval a

-- | Run the evaluation.
runEval :: Eval a -> a

-- | Run the evaluation in the <a>IO</a> monad. This allows sequencing of
--   evaluations relative to <a>IO</a> actions.
runEvalIO :: Eval a -> IO a

-- | <i>Deprecated: The Strategy type is now a -&gt; Eval a, not a -&gt;
--   Done</i>
type Done = ()

-- | <i>Deprecated: Use <a>pseq</a> or <a>$|</a> instead</i>
demanding :: a -> Done -> a

-- | <i>Deprecated: Use <a>par</a> or <a>$||</a> instead</i>
sparking :: a -> Done -> a

-- | <i>Deprecated: Use <a>pseq</a> or <a>$|</a> instead</i>
(>|) :: Done -> Done -> Done

-- | <i>Deprecated: Use <a>par</a> or <a>$||</a> instead</i>
(>||) :: Done -> Done -> Done

-- | <i>Deprecated: renamed to <a>rseq</a></i>
rwhnf :: Strategy a

-- | <i>Deprecated: renamed to <a>runEval</a></i>
unEval :: Eval a -> a

-- | <i>Deprecated: renamed to <a>evalTraversable</a></i>
seqTraverse :: Traversable t => Strategy a -> Strategy (t a)

-- | <i>Deprecated: renamed to <a>parTraversable</a></i>
parTraverse :: Traversable t => Strategy a -> Strategy (t a)

-- | <i>Deprecated: renamed to <a>evalList</a></i>
seqList :: Strategy a -> Strategy [a]

-- | <i>Deprecated: renamed to <a>evalTuple2</a></i>
seqPair :: Strategy a -> Strategy b -> Strategy (a, b)

-- | <i>Deprecated: renamed to <a>parTuple2</a></i>
parPair :: Strategy a -> Strategy b -> Strategy (a, b)

-- | <i>Deprecated: renamed to <a>evalTuple3</a></i>
seqTriple :: Strategy a -> Strategy b -> Strategy c -> Strategy (a, b, c)

-- | <i>Deprecated: renamed to <a>parTuple3</a></i>
parTriple :: Strategy a -> Strategy b -> Strategy c -> Strategy (a, b, c)
class NFData a
instance GHC.Internal.Base.Applicative Control.Parallel.Strategies.Eval
instance GHC.Internal.Base.Functor Control.Parallel.Strategies.Eval
instance GHC.Internal.Base.Monad Control.Parallel.Strategies.Eval
instance GHC.Internal.Control.Monad.Fix.MonadFix Control.Parallel.Strategies.Eval
