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 :: InterpolationMethod -> [(Double, Double)] -> Double -> Double

   hmatrix-gsl	Numeric.GSL.Interpolation

   Evaluate a function by interpolating within the given dataset. For example:

   >>> let xs = [1..10]
   
   >>> let ys map (**2) [1..10]
   
   >>> evaluate Akima (zip xs ys) 2.2
   4.840000000000001
   

   To successfully evaluate points x, the domain (x) values in points must be monotonically increasing. The evaluation point x must lie between the smallest and largest values in the sampled domain.

2. evaluate :: a -> IO a

   cabal-install-solver	Distribution.Solver.Compat.Prelude

   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.

3. evaluate :: Ord a => [a] -> [a] -> Eval

   combinatorial	Combinatorics.Mastermind

   Given the code and a guess, compute the evaluation.

   >>> filter ((Mastermind.Eval 2 0 ==) . Mastermind.evaluate "aabbb") $ replicateM 5 ['a'..'c']
   ["aaaaa","aaaac","aaaca","aaacc","aacaa","aacac","aacca","aaccc","acbcc","accbc","acccb","cabcc","cacbc","caccb","ccbbc","ccbcb","cccbb"]
   

4. evaluate :: KernelState -> String -> Publisher -> (KernelState -> [WidgetMsg] -> IO KernelState) -> Interpreter (KernelState, ErrorOccurred)

   ihaskell	IHaskell.Eval.Evaluate

   Evaluate some IPython input code.

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

   monad-peel	Control.Exception.Peel

   Generalized version of evaluate.

6. evaluate :: AST -> Template

   simple-templates	Web.Simple.Templates.Language

   No documentation available.

7. evaluate :: forall m p (n :: Nat) . Monad m => (p -> m Bool) -> UnaryBV p n -> m Integer

   what4	What4.Expr.UnaryBV

   Evaluate a unary bitvector as an integer given an evaluation function.

8. evaluate :: Enum a => [a] -> [a] -> Eval

   board-games	Game.Mastermind

   Given the code and a guess, compute the evaluation.

   \(CodePair secret attempt) -> MM.evaluate secret attempt == MM.evaluate attempt secret
   

9. evaluate :: Typeable a => Expr -> Maybe a

   code-conjure	Conjure.Engine

   O(n). Just the value of an expression when possible (correct type), Nothing otherwise. This does not catch errors from undefined Dynamic values.

   > let one = val (1 :: Int)
   > let bee = val 'b'
   > let negateE = value "negate" (negate :: Int -> Int)
   

   > evaluate one :: Maybe Int
   Just 1
   

   > evaluate one :: Maybe Char
   Nothing
   

   > evaluate bee :: Maybe Int
   Nothing
   

   > evaluate bee :: Maybe Char
   Just 'b'
   

   > evaluate $ negateE :$ one :: Maybe Int
   Just (-1)
   

   > evaluate $ negateE :$ bee :: Maybe Int
   Nothing
   

10. evaluate :: Typeable a => Expr -> Maybe a

    code-conjure	Conjure.Expr

    O(n). Just the value of an expression when possible (correct type), Nothing otherwise. This does not catch errors from undefined Dynamic values.

    > let one = val (1 :: Int)
    > let bee = val 'b'
    > let negateE = value "negate" (negate :: Int -> Int)
    

    > evaluate one :: Maybe Int
    Just 1
    

    > evaluate one :: Maybe Char
    Nothing
    

    > evaluate bee :: Maybe Int
    Nothing
    

    > evaluate bee :: Maybe Char
    Just 'b'
    

    > evaluate $ negateE :$ one :: Maybe Int
    Just (-1)
    

    > evaluate $ negateE :$ bee :: Maybe Int
    Nothing
    

Page 3 of many | Previous | Next