Hoogle Search

Within LTS Haskell 24.3 (ghc-9.10.2)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. evaluate :: a -> IO a

   monadology	Control.Monad.Ology.General.Exception

   Evaluate the argument to weak head normal form. evaluate is typically used to uncover any exceptions that a lazy value may contain, and possibly handle them. evaluate only evaluates to weak head normal form. If deeper evaluation is needed, the force function from Control.DeepSeq may be handy:

   evaluate $ force x
   

   There is a subtle difference between evaluate x and return $! x, analogous to the difference between throwIO and throw. If the lazy value x throws an exception, return $! x will fail to return an IO action and will throw an exception instead. evaluate x, on the other hand, always produces an IO action; that action will throw an exception upon execution iff x throws an exception upon evaluation. The practical implication of this difference is that due to the imprecise exceptions semantics,

   (return $! error "foo") >> error "bar"
   

   may throw either "foo" or "bar", depending on the optimizations performed by the compiler. On the other hand,

   evaluate (error "foo") >> error "bar"
   

   is guaranteed to throw "foo". The rule of thumb is to use evaluate to force or handle exceptions in lazy values. If, on the other hand, you are forcing a lazy value for efficiency reasons only and do not care about exceptions, you may use return $! x.

2. evaluate :: s -> T s a -> a

   monoid-transformer	Data.Monoid.State

   No documentation available.

3. evaluate :: (Function o, Num o, Ord (Domain o), Num (Codomain o)) => Piecewise o -> Domain o -> Codomain o

   probability-polynomial	Numeric.Function.Piecewise

   Evaluate the piecewise function at a point. See Piecewise for the semantics.

4. evaluate :: MonadIO m => a -> m a

   classy-prelude-yesod	ClassyPrelude.Yesod

   Lifted version of evaluate.

5. evaluate :: (MonadDOM m, IsDocument self, ToJSString expression, IsNode contextNode) => self -> Maybe expression -> Maybe contextNode -> Maybe XPathNSResolver -> Maybe Word -> Maybe XPathResult -> m XPathResult

   jsaddle-dom	JSDOM.Generated.Document

   Mozilla Document.evaluate documentation

6. evaluate :: (MonadDOM m, ToJSString expression, IsNode contextNode) => XPathEvaluator -> Maybe expression -> Maybe contextNode -> Maybe XPathNSResolver -> Maybe Word -> Maybe XPathResult -> m XPathResult

   jsaddle-dom	JSDOM.Generated.XPathEvaluator

   Mozilla XPathEvaluator.evaluate documentation

7. evaluate :: (MonadDOM m, IsNode contextNode) => XPathExpression -> Maybe contextNode -> Maybe Word -> Maybe XPathResult -> m XPathResult

   jsaddle-dom	JSDOM.Generated.XPathExpression

   Mozilla XPathExpression.evaluate documentation

8. evaluate :: Settings -> String -> [(String, Double)] -> Double

   mathexpr	Numeric.MathExpr

   Evaluate an expression Example: `evaluate def "x + y ^ 2" [("x", 1), ("y", 2)]

9. module Language.Javascript.JSaddle.Evaluate

   If you just want to run some JavaScript that you have as a string this is you can use eval or evaluateScript.

10. module IHaskell.Eval.Evaluate

    This module exports all functions used for evaluation of IHaskell input.

Page 4 of many | Previous | Next