Hoogle Search

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

evaluate :: C a => T a -> a -> a

numeric-prelude MathObj.PowerSeries

Evaluate (truncated) power series.
evaluate :: C a => [a] -> a -> a

numeric-prelude MathObj.PowerSeries.Core

No documentation available.
evaluate :: a -> IO a

protolude Protolude

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.

numeric-prelude	MathObj.PowerSeries

numeric-prelude	MathObj.PowerSeries.Core

protolude	Protolude

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

express	Data.Express

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

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

express	Data.Express.Core

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

evaluate :: a -> IO a

base-prelude BasePrelude

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.
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.
evaluate :: a -> IO a

rebase Rebase.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.
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.

base-prelude	BasePrelude

hmatrix-gsl	Numeric.GSL.Interpolation

rebase	Rebase.Prelude

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

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"]

Page 2 of many | Previous | Next