Hoogle Search

Within LTS Haskell 24.4 (ghc-9.10.2)

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

  1. frequency :: HasCallStack => [(Int, Gen a)] -> Gen a

    QuickCheck Test.QuickCheck.Gen

    Chooses one of the given generators, with a weighted random distribution. The input list must be non-empty.

  2. sequential :: SpecWith a -> SpecWith a

    hspec Test.Hspec

    sequential marks all spec items of the given spec to be evaluated sequentially.

  3. sequentialTestGroup :: TestName -> DependencyType -> [TestTree] -> TestTree

    tasty Test.Tasty

    Create a named group of test cases or other groups. Tests are executed in order. For parallel execution, see testGroup.

  4. Seq :: TestOutput -> TestOutput -> TestOutput

    tasty Test.Tasty.Ingredients.ConsoleReporter

    Two sets of TestOutput on the same level.

  5. package deepseq

    Deep evaluation of data structures This package provides methods for fully evaluating data structures ("deep evaluation"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread. The primary use of this package is via the deepseq function, a "deep" version of seq. It is implemented on top of an NFData typeclass ("Normal Form Data", data structures with no unevaluated components) which defines strategies for fully evaluating different data types. See module documentation in Control.DeepSeq for more details.

  6. module Control.DeepSeq

    This module provides overloaded functions, such as deepseq and rnf, for fully evaluating data structures (that is, evaluating to "Normal Form"). A typical use is to prevent resource leaks in lazy IO programs, by forcing all characters from a file to be read. For example: 

    import System.IO
import Control.DeepSeq
import Control.Exception (evaluate)

readFile' :: FilePath -> IO String
readFile' fn = do
h <- openFile fn ReadMode
s <- hGetContents h
evaluate (rnf s)
hClose h
return s
    Note: The example above should rather be written in terms of bracket to ensure releasing file-descriptors in a timely matter (see the description of force for an example). deepseq differs from seq as it traverses data structures deeply, for example, seq will evaluate only to the first constructor in the list: 
    > [1,2,undefined] `seq` 3
3
    While deepseq will force evaluation of all the list elements: 
    > [1,2,undefined] `deepseq` 3
*** Exception: Prelude.undefined
    Another common use is to ensure any exceptions hidden within lazy fields of a data structure do not leak outside the scope of the exception handler, or to force evaluation of a data structure in one thread, before passing to another thread (preventing work moving to the wrong threads).

  7. deepseq :: NFData a => a -> b -> b

    deepseq Control.DeepSeq

    deepseq: fully evaluates the first argument, before returning the second. The name deepseq is used to illustrate the relationship to seq: where seq is shallow in the sense that it only evaluates the top level of its argument, deepseq traverses the entire data structure evaluating it completely. deepseq can be useful for forcing pending exceptions, eradicating space leaks, or forcing lazy I/O to happen. It is also useful in conjunction with parallel Strategies (see the parallel package). There is no guarantee about the ordering of evaluation. The implementation may evaluate the components of the structure in any order or in parallel. To impose an actual order on evaluation, use pseq from Control.Parallel in the parallel package.

  8. sequenceWithIOErrors_ :: [IO ()] -> IO ()

    directory System.Directory.Internal

    No documentation available.

  9. ArithSeqE :: Range -> Exp

    template-haskell Language.Haskell.TH 

    { [ 1 ,2 .. 10 ] }

  10. BndrReq :: BndrVis

    template-haskell Language.Haskell.TH 

    a

Page 136 of many | Previous | Next