Integer -> Double

fromInteger :: Num a => Integer -> a
base Prelude
unsafeCoerce :: a -> b
base Unsafe.Coerce
throwDyn :: Typeable exception => exception -> b
base Control.OldException
Raise any value as an exception, provided it is in the Typeable class.
encodeFloat :: RealFloat a => Integer -> Int -> a
base Prelude
($) :: (a -> b) -> a -> b
base Prelude, base Data.Function
Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example: > f $ g $ h x = f (g (h x)) It is also useful in higher-order situations, such as map ($ 0) xs, or Data.List.zipWith ($) fs xs.
($!) :: (a -> b) -> a -> b
base Prelude
Strict (call-by-value) application, defined in terms of seq.
seq :: a -> b -> b
base Prelude
Evaluates its first argument to head normal form, and then returns its second argument as the result.
par :: a -> b -> b
base GHC.Conc.Sync, base GHC.Conc
par :: a -> b -> b
parallel 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. a `par` b is exactly equivalent semantically to b. par is generally used when the value of a is likely to be required later, but not immediately. Also it is a good idea to ensure that a 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 -threaded option, and GPH, for now). On other implementations, par a b = b.
pseq :: a -> b -> b
base GHC.Conc.Sync, base GHC.Conc
pseq :: a -> b -> b
parallel Control.Parallel
Semantically identical to seq, but with a subtle operational difference: seq is strict in both its arguments, so the compiler may, for example, rearrange a `seq` b into b `seq` a `seq` b. This is normally no problem when using seq 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 a before b, because we know that b has already been sparked in parallel with par. This is why we have pseq. In contrast to seq, pseq 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.
apply :: Fun a b -> (a -> b)
QuickCheck Test.QuickCheck.Function
extB :: (Typeable a, Typeable b) => a -> b -> a
syb Data.Generics.Aliases
Extend a generic builder
const :: a -> b -> a
base Prelude, base Data.Function
Constant function.
fromConstrB :: Data a => (forall d. Data d => d) -> Constr -> a
base Data.Data
Build a term and use a generic function for subterms
runReader :: Reader r a -> r -> a
transformers Control.Monad.Trans.Reader, mtl Control.Monad.Reader
Runs a Reader and extracts the final value from it. (The inverse of reader.)
evalState :: State s a -> s -> a
transformers Control.Monad.Trans.State.Lazy, transformers Control.Monad.Trans.State.Strict, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Evaluate a state computation with the given initial state and return the final value, discarding the final state. *  m s = fst (runState m >  
throw :: Exception e => e -> a
base Control.Exception.Base, base Control.Exception, base Control.OldException
Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad.
cast :: (Typeable a, Typeable b) => a -> Maybe b
base Data.Typeable
The type-safe cast operation
gfindtype :: (Data x, Typeable y) => x -> Maybe y
syb Data.Generics.Schemes
Find (unambiguously) an immediate subterm of a given type

Show more results