-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | small framework for performance measurement and analysis
--   
--   This library provides a powerful but simple way to measure software
--   performance. It provides both a framework for executing and analysing
--   benchmarks and a set of driver functions that makes it easy to build
--   and run benchmarks, and to analyse their results.
@package gauge
@version 0.2.3


-- | Benchmarking command-line configuration.
module Gauge.Main.Options

-- | Default benchmarking configuration.
defaultConfig :: Config

-- | Create a benchmark selector function that can tell if a name given on
--   the command line matches a defined benchmark.
makeSelector :: MatchType -> [String] -> (String -> Bool)
parseWith :: Config -> [String] -> (Config, [String])
describe :: String

-- | A string describing the version of this benchmark (really, the version
--   of gauge that was used to build it).
versionInfo :: String

-- | Top-level benchmarking configuration.
data Config
Config :: Maybe Double -> Bool -> Maybe Double -> Maybe Int -> MilliSeconds -> Bool -> Bool -> Maybe FilePath -> Maybe FilePath -> Int -> [([String], String)] -> Maybe FilePath -> Maybe FilePath -> Maybe FilePath -> Maybe FilePath -> Maybe FilePath -> Maybe FilePath -> Verbosity -> FilePath -> Maybe Int64 -> MatchType -> Mode -> DisplayMode -> Config

-- | Confidence interval for bootstrap estimation (greater than 0, less
--   than 1).
[confInterval] :: Config -> Maybe Double

-- | <i>Obsolete, unused</i>. This option used to force garbage collection
--   between every benchmark run, but it no longer has an effect (we now
--   unconditionally force garbage collection). This option remains solely
--   for backwards API compatibility.
[forceGC] :: Config -> Bool

-- | Number of seconds to run a single benchmark. In practice, execution
--   time may exceed this limit to honor minimum number of samples or
--   minimum duration of each sample. Increased time limit allows us to
--   take more samples. Use 0 for a single sample benchmark.
[timeLimit] :: Config -> Maybe Double

-- | Minimum number of samples to be taken.
[minSamples] :: Config -> Maybe Int

-- | Minimum duration of each sample, increased duration allows us to
--   perform more iterations in each sample. To enforce a single iteration
--   in a sample use duration 0.
[minDuration] :: Config -> MilliSeconds

-- | Discard the very first iteration of a benchmark. The first iteration
--   includes the potentially extra cost of one time evaluations
--   introducing large variance.
[includeFirstIter] :: Config -> Bool

-- | Quickly measure and report raw measurements.
[quickMode] :: Config -> Bool

-- | Just measure the given benchmark and place the raw output in this
--   file, do not analyse and generate a report.
[measureOnly] :: Config -> Maybe FilePath

-- | Specify the path of the benchmarking program to use (this program
--   itself) for measuring the benchmarks in a separate process.
[measureWith] :: Config -> Maybe FilePath

-- | Number of resamples to perform when bootstrapping.
[resamples] :: Config -> Int

-- | Regressions to perform.
[regressions] :: Config -> [([String], String)]

-- | File to write binary measurement and analysis data to. If not
--   specified, this will be a temporary file.
[rawDataFile] :: Config -> Maybe FilePath

-- | File to write report output to, with template expanded.
[reportFile] :: Config -> Maybe FilePath

-- | File to write CSV summary to.
[csvFile] :: Config -> Maybe FilePath

-- | File to write CSV measurements to.
[csvRawFile] :: Config -> Maybe FilePath

-- | File to write JSON-formatted results to.
[jsonFile] :: Config -> Maybe FilePath

-- | File to write JUnit-compatible XML results to.
[junitFile] :: Config -> Maybe FilePath

-- | Verbosity level to use when running and analysing benchmarks.
[verbosity] :: Config -> Verbosity

-- | Template file to use if writing a report.
[template] :: Config -> FilePath

-- | Number of iterations
[iters] :: Config -> Maybe Int64

-- | Type of matching to use, if any
[match] :: Config -> MatchType

-- | Mode of operation
[mode] :: Config -> Mode
[displayMode] :: Config -> DisplayMode

-- | Control the amount of information displayed.
data Verbosity
Quiet :: Verbosity
Normal :: Verbosity
Verbose :: Verbosity
data DisplayMode
Condensed :: DisplayMode
StatsTable :: DisplayMode

-- | How to match a benchmark name.
data MatchType

-- | Match the exact benchmark name
Exact :: MatchType

-- | Match by prefix. For example, a prefix of <tt>"foo"</tt> will match
--   <tt>"foobar"</tt>.
Prefix :: MatchType

-- | Match by searching given substring in benchmark paths.
Pattern :: MatchType

-- | Same as <a>Pattern</a>, but case insensitive.
IPattern :: MatchType

-- | Execution mode for a benchmark program.
data Mode

-- | List all benchmarks.
List :: Mode

-- | Print the version.
Version :: Mode

-- | Print help
Help :: Mode

-- | Default Benchmark mode
DefaultMode :: Mode
instance GHC.Generics.Generic Gauge.Main.Options.Config
instance Data.Data.Data Gauge.Main.Options.Config
instance GHC.Show.Show Gauge.Main.Options.Config
instance GHC.Read.Read Gauge.Main.Options.Config
instance GHC.Classes.Eq Gauge.Main.Options.Config
instance GHC.Generics.Generic Gauge.Main.Options.DisplayMode
instance Data.Data.Data Gauge.Main.Options.DisplayMode
instance GHC.Show.Show Gauge.Main.Options.DisplayMode
instance GHC.Read.Read Gauge.Main.Options.DisplayMode
instance GHC.Classes.Eq Gauge.Main.Options.DisplayMode
instance GHC.Generics.Generic Gauge.Main.Options.Mode
instance Data.Data.Data Gauge.Main.Options.Mode
instance GHC.Show.Show Gauge.Main.Options.Mode
instance GHC.Read.Read Gauge.Main.Options.Mode
instance GHC.Classes.Eq Gauge.Main.Options.Mode
instance GHC.Generics.Generic Gauge.Main.Options.MatchType
instance Data.Data.Data Gauge.Main.Options.MatchType
instance GHC.Show.Show Gauge.Main.Options.MatchType
instance GHC.Read.Read Gauge.Main.Options.MatchType
instance GHC.Enum.Enum Gauge.Main.Options.MatchType
instance GHC.Enum.Bounded Gauge.Main.Options.MatchType
instance GHC.Classes.Ord Gauge.Main.Options.MatchType
instance GHC.Classes.Eq Gauge.Main.Options.MatchType
instance GHC.Generics.Generic Gauge.Main.Options.Verbosity
instance Data.Data.Data Gauge.Main.Options.Verbosity
instance GHC.Show.Show Gauge.Main.Options.Verbosity
instance GHC.Read.Read Gauge.Main.Options.Verbosity
instance GHC.Enum.Enum Gauge.Main.Options.Verbosity
instance GHC.Enum.Bounded Gauge.Main.Options.Verbosity
instance GHC.Classes.Ord Gauge.Main.Options.Verbosity
instance GHC.Classes.Eq Gauge.Main.Options.Verbosity


-- | Constructing and running benchmarks.
module Gauge.Benchmark

-- | A pure function or impure action that can be benchmarked. The function
--   to be benchmarked is wrapped into a function (<a>runRepeatedly</a>)
--   that takes an <a>Int64</a> parameter which indicates the number of
--   times to run the given function or action. The wrapper is constructed
--   automatically by the APIs provided in this library to construct
--   <a>Benchmarkable</a>.
--   
--   When <a>perRun</a> is not set then <a>runRepeatedly</a> is invoked to
--   perform all iterations in one measurement interval. When <a>perRun</a>
--   is set, <a>runRepeatedly</a> is always invoked with 1 iteration in one
--   measurement interval, before a measurement <a>allocEnv</a> is invoked
--   and after the measurement <a>cleanEnv</a> is invoked. The performance
--   counters for each iteration are then added together for all
--   iterations.
data Benchmarkable
Benchmarkable :: Int64 -> IO a -> Int64 -> a -> IO () -> a -> Int64 -> IO () -> Bool -> Benchmarkable
[allocEnv] :: Benchmarkable -> Int64 -> IO a
[cleanEnv] :: Benchmarkable -> Int64 -> a -> IO ()
[runRepeatedly] :: Benchmarkable -> a -> Int64 -> IO ()
[perRun] :: Benchmarkable -> Bool

-- | This is a low level function to construct a <a>Benchmarkable</a> value
--   from an impure wrapper action, where the <a>Int64</a> parameter
--   dictates the number of times the action wrapped inside would run. You
--   would normally be using the other higher level APIs rather than this
--   function to construct a benchmarkable.
toBenchmarkable :: (Int64 -> IO ()) -> Benchmarkable

-- | Perform an action, then evaluate its result to normal form. This is
--   particularly useful for forcing a lazy <a>IO</a> action to be
--   completely performed.
nfIO :: NFData a => IO a -> Benchmarkable

-- | Perform an action, then evaluate its result to weak head normal form
--   (WHNF). This is useful for forcing an <a>IO</a> action whose result is
--   an expression to be evaluated down to a more useful value.
whnfIO :: IO a -> Benchmarkable

-- | Apply an argument to a function, and evaluate the result to normal
--   form (NF).
nf :: NFData b => (a -> b) -> a -> Benchmarkable

-- | Apply an argument to a function, and evaluate the result to weak head
--   normal form (WHNF).
whnf :: (a -> b) -> a -> Benchmarkable

-- | Create a Benchmarkable where a fresh environment is allocated for
--   every batch of runs of the benchmarkable.
--   
--   The environment is evaluated to normal form before the benchmark is
--   run.
--   
--   When using <a>whnf</a>, <a>whnfIO</a>, etc. Gauge creates a
--   <a>Benchmarkable</a> whichs runs a batch of <tt>N</tt> repeat runs of
--   that expressions. Gauge may run any number of these batches to get
--   accurate measurements. Environments created by <a>env</a> and
--   <a>envWithCleanup</a>, are shared across all these batches of runs.
--   
--   This is fine for simple benchmarks on static input, but when
--   benchmarking IO operations where these operations can modify (and
--   especially grow) the environment this means that later batches might
--   have their accuracy effected due to longer, for example, longer
--   garbage collection pauses.
--   
--   An example: Suppose we want to benchmark writing to a Chan, if we
--   allocate the Chan using environment and our benchmark consists of
--   <tt>writeChan env ()</tt>, the contents and thus size of the Chan will
--   grow with every repeat. If Gauge runs a 1,000 batches of 1,000
--   repeats, the result is that the channel will have 999,000 items in it
--   by the time the last batch is run. Since GHC GC has to copy the live
--   set for every major GC this means our last set of writes will suffer a
--   lot of noise of the previous repeats.
--   
--   By allocating a fresh environment for every batch of runs this
--   function should eliminate this effect.
perBatchEnv :: (NFData env, NFData b) => (Int64 -> IO env) -> (env -> IO b) -> Benchmarkable

-- | Same as <a>perBatchEnv</a>, but but allows for an additional callback
--   to clean up the environment. Resource clean up is exception safe, that
--   is, it runs even if the <a>Benchmark</a> throws an exception.
perBatchEnvWithCleanup :: (NFData env, NFData b) => (Int64 -> IO env) -> (Int64 -> env -> IO ()) -> (env -> IO b) -> Benchmarkable

-- | Create a Benchmarkable where a fresh environment is allocated for
--   every run of the operation to benchmark. This is useful for
--   benchmarking mutable operations that need a fresh environment, such as
--   sorting a mutable Vector.
--   
--   As with <a>env</a> and <a>perBatchEnv</a> the environment is evaluated
--   to normal form before the benchmark is run.
--   
--   This introduces extra noise and result in reduce accuracy compared to
--   other Gauge benchmarks. But allows easier benchmarking for mutable
--   operations than was previously possible.
perRunEnv :: (NFData env, NFData b) => IO env -> (env -> IO b) -> Benchmarkable

-- | Same as <a>perRunEnv</a>, but but allows for an additional callback to
--   clean up the environment. Resource clean up is exception safe, that
--   is, it runs even if the <a>Benchmark</a> throws an exception.
perRunEnvWithCleanup :: (NFData env, NFData b) => IO env -> (env -> IO ()) -> (env -> IO b) -> Benchmarkable

-- | Specification of a collection of benchmarks and environments. A
--   benchmark may consist of:
--   
--   <ul>
--   <li>An environment that creates input data for benchmarks, created
--   with <a>env</a>.</li>
--   <li>A single <a>Benchmarkable</a> item with a name, created with
--   <a>bench</a>.</li>
--   <li>A (possibly nested) group of <a>Benchmark</a>s, created with
--   <a>bgroup</a>.</li>
--   </ul>
data Benchmark
[Environment] :: NFData env => IO env -> (env -> IO a) -> (env -> Benchmark) -> Benchmark
[Benchmark] :: String -> Benchmarkable -> Benchmark
[BenchGroup] :: String -> [Benchmark] -> Benchmark

-- | Create a single benchmark.
bench :: String -> Benchmarkable -> Benchmark

-- | Group several benchmarks together under a common name.
bgroup :: String -> [Benchmark] -> Benchmark

-- | Run a benchmark (or collection of benchmarks) in the given
--   environment. The purpose of an environment is to lazily create input
--   data to pass to the functions that will be benchmarked.
--   
--   A common example of environment data is input that is read from a
--   file. Another is a large data structure constructed in-place.
--   
--   By deferring the creation of an environment when its associated
--   benchmarks need the its, we avoid two problems that this strategy
--   caused:
--   
--   <ul>
--   <li>Memory pressure distorted the results of unrelated benchmarks. If
--   one benchmark needed e.g. a gigabyte-sized input, it would force the
--   garbage collector to do extra work when running some other benchmark
--   that had no use for that input. Since the data created by an
--   environment is only available when it is in scope, it should be
--   garbage collected before other benchmarks are run.</li>
--   <li>The time cost of generating all needed inputs could be significant
--   in cases where no inputs (or just a few) were really needed. This
--   occurred often, for instance when just one out of a large suite of
--   benchmarks was run, or when a user would list the collection of
--   benchmarks without running any.</li>
--   </ul>
--   
--   <b>Creation.</b> An environment is created right before its related
--   benchmarks are run. The <a>IO</a> action that creates the environment
--   is run, then the newly created environment is evaluated to normal form
--   (hence the <a>NFData</a> constraint) before being passed to the
--   function that receives the environment.
--   
--   <b>Complex environments.</b> If you need to create an environment that
--   contains multiple values, simply pack the values into a tuple.
--   
--   <b>Lazy pattern matching.</b> In situations where a "real" environment
--   is not needed, e.g. if a list of benchmark names is being generated,
--   <tt>undefined</tt> will be passed to the function that receives the
--   environment. This avoids the overhead of generating an environment
--   that will not actually be used.
--   
--   The function that receives the environment must use lazy pattern
--   matching to deconstruct the tuple, as use of strict pattern matching
--   will cause a crash if <tt>undefined</tt> is passed in.
--   
--   <b>Example.</b> This program runs benchmarks in an environment that
--   contains two values. The first value is the contents of a text file;
--   the second is a string. Pay attention to the use of a lazy pattern to
--   deconstruct the tuple in the function that returns the benchmarks to
--   be run.
--   
--   <pre>
--   setupEnv = do
--     let small = replicate 1000 (1 :: Int)
--     big &lt;- map length . words &lt;$&gt; readFile "/usr/dict/words"
--     return (small, big)
--   
--   main = defaultMain [
--      -- notice the lazy pattern match here!
--      env setupEnv $ \ ~(small,big) -&gt; bgroup "main" [
--      bgroup "small" [
--        bench "length" $ whnf length small
--      , bench "length . filter" $ whnf (length . filter (==1)) small
--      ]
--    ,  bgroup "big" [
--        bench "length" $ whnf length big
--      , bench "length . filter" $ whnf (length . filter (==1)) big
--      ]
--    ] ]
--   </pre>
--   
--   <b>Discussion.</b> The environment created in the example above is
--   intentionally <i>not</i> ideal. As Haskell's scoping rules suggest,
--   the variable <tt>big</tt> is in scope for the benchmarks that use only
--   <tt>small</tt>. It would be better to create a separate environment
--   for <tt>big</tt>, so that it will not be kept alive while the
--   unrelated benchmarks are being run.
env :: NFData env => IO env -> (env -> Benchmark) -> Benchmark

-- | Same as <a>env</a>, but but allows for an additional callback to clean
--   up the environment. Resource clean up is exception safe, that is, it
--   runs even if the <a>Benchmark</a> throws an exception.
envWithCleanup :: NFData env => IO env -> (env -> IO a) -> (env -> Benchmark) -> Benchmark

-- | Retrieve the names of all benchmarks. Grouped benchmarks are prefixed
--   with the name of the group they're in.
benchNames :: Benchmark -> [String]

-- | Run benchmarkables, selected by a given selector function, under a
--   given benchmark and analyse the output using the given analysis
--   function.
runBenchmark :: (String -> Bool) -> Benchmark -> BenchmarkAnalysis -> Gauge ()

-- | The function to run after measurement
data BenchmarkAnalysis
BenchmarkNormal :: (String -> Vector Measured -> Gauge a) -> BenchmarkAnalysis
BenchmarkIters :: Int64 -> BenchmarkAnalysis
instance GHC.Show.Show Gauge.Benchmark.Benchmark


-- | Analysis code for benchmarks.
module Gauge.Analysis

-- | Outliers from sample data, calculated using the boxplot technique.
data Outliers
Outliers :: !Int64 -> !Int64 -> !Int64 -> !Int64 -> !Int64 -> Outliers
[samplesSeen] :: Outliers -> !Int64

-- | More than 3 times the interquartile range (IQR) below the first
--   quartile.
[lowSevere] :: Outliers -> !Int64

-- | Between 1.5 and 3 times the IQR below the first quartile.
[lowMild] :: Outliers -> !Int64

-- | Between 1.5 and 3 times the IQR above the third quartile.
[highMild] :: Outliers -> !Int64

-- | More than 3 times the IQR above the third quartile.
[highSevere] :: Outliers -> !Int64

-- | A description of the extent to which outliers in the sample data
--   affect the sample mean and standard deviation.
data OutlierEffect

-- | Less than 1% effect.
Unaffected :: OutlierEffect

-- | Between 1% and 10%.
Slight :: OutlierEffect

-- | Between 10% and 50%.
Moderate :: OutlierEffect

-- | Above 50% (i.e. measurements are useless).
Severe :: OutlierEffect

-- | Analysis of the extent to which outliers in a sample affect its
--   standard deviation (and to some extent, its mean).
data OutlierVariance
OutlierVariance :: OutlierEffect -> String -> Double -> OutlierVariance

-- | Qualitative description of effect.
[ovEffect] :: OutlierVariance -> OutlierEffect

-- | Brief textual description of effect.
[ovDesc] :: OutlierVariance -> String

-- | Quantitative description of effect (a fraction between 0 and 1).
[ovFraction] :: OutlierVariance -> Double

-- | Report of a sample analysis.
data Report

-- | Result of a bootstrap analysis of a non-parametric sample.
data SampleAnalysis
SampleAnalysis :: [Regression] -> Estimate ConfInt Double -> Estimate ConfInt Double -> OutlierVariance -> SampleAnalysis

-- | Estimates calculated via linear regression.
[anRegress] :: SampleAnalysis -> [Regression]

-- | Estimated mean.
[anMean] :: SampleAnalysis -> Estimate ConfInt Double

-- | Estimated standard deviation.
[anStdDev] :: SampleAnalysis -> Estimate ConfInt Double

-- | Description of the effects of outliers on the estimated variance.
[anOutlierVar] :: SampleAnalysis -> OutlierVariance

-- | Perform an analysis of a measurement.
analyseSample :: String -> Vector Measured -> Gauge (Either String Report)

-- | Multiply the <a>Estimate</a>s in an analysis by the given value, using
--   <a>scale</a>.
scale :: Double -> SampleAnalysis -> SampleAnalysis

-- | Analyse a single benchmark.
analyseBenchmark :: String -> Vector Measured -> Gauge Report

-- | Display the mean of a <a>Sample</a>, and characterise the outliers
--   present in the sample.
analyseMean :: Sample -> Int -> Gauge Double

-- | Count the total number of outliers in a sample.
countOutliers :: Outliers -> Int64

-- | Classify outliers in a data set, using the boxplot technique.
classifyOutliers :: Sample -> Outliers

-- | Display a report of the <a>Outliers</a> present in a <a>Sample</a>.
noteOutliers :: Outliers -> Gauge ()

-- | Compute the extent to which outliers in the sample data affect the
--   sample mean and standard deviation.
outlierVariance :: Estimate ConfInt Double -> Estimate ConfInt Double -> Double -> OutlierVariance

-- | Regress the given predictors against the responder.
--   
--   Errors may be returned under various circumstances, such as invalid
--   names or lack of needed data.
--   
--   See <a>olsRegress</a> for details of the regression performed.
regress :: GenIO -> [String] -> String -> Vector Measured -> Gauge (Either String Regression)

-- | Run a benchmark interactively and analyse its performanc.
benchmark' :: Benchmarkable -> IO ()

-- | Run a benchmark interactively and analyse its performance.
benchmarkWith' :: Config -> Benchmarkable -> IO ()
instance GHC.Generics.Generic Gauge.Analysis.Report
instance GHC.Show.Show Gauge.Analysis.Report
instance GHC.Classes.Eq Gauge.Analysis.Report
instance GHC.Generics.Generic Gauge.Analysis.KDE
instance Data.Data.Data Gauge.Analysis.KDE
instance GHC.Show.Show Gauge.Analysis.KDE
instance GHC.Classes.Eq Gauge.Analysis.KDE
instance GHC.Generics.Generic Gauge.Analysis.SampleAnalysis
instance GHC.Show.Show Gauge.Analysis.SampleAnalysis
instance GHC.Classes.Eq Gauge.Analysis.SampleAnalysis
instance GHC.Generics.Generic Gauge.Analysis.Regression
instance GHC.Show.Show Gauge.Analysis.Regression
instance GHC.Classes.Eq Gauge.Analysis.Regression
instance GHC.Generics.Generic Gauge.Analysis.OutlierVariance
instance Data.Data.Data Gauge.Analysis.OutlierVariance
instance GHC.Show.Show Gauge.Analysis.OutlierVariance
instance GHC.Classes.Eq Gauge.Analysis.OutlierVariance
instance GHC.Generics.Generic Gauge.Analysis.OutlierEffect
instance Data.Data.Data Gauge.Analysis.OutlierEffect
instance GHC.Show.Show Gauge.Analysis.OutlierEffect
instance GHC.Classes.Ord Gauge.Analysis.OutlierEffect
instance GHC.Classes.Eq Gauge.Analysis.OutlierEffect
instance GHC.Generics.Generic Gauge.Analysis.Outliers
instance Data.Data.Data Gauge.Analysis.Outliers
instance GHC.Show.Show Gauge.Analysis.Outliers
instance GHC.Classes.Eq Gauge.Analysis.Outliers
instance Control.DeepSeq.NFData Gauge.Analysis.Report
instance Control.DeepSeq.NFData Gauge.Analysis.KDE
instance Control.DeepSeq.NFData Gauge.Analysis.SampleAnalysis
instance Control.DeepSeq.NFData Gauge.Analysis.Regression
instance Control.DeepSeq.NFData Gauge.Analysis.OutlierVariance
instance Control.DeepSeq.NFData Gauge.Analysis.OutlierEffect
instance Control.DeepSeq.NFData Gauge.Analysis.Outliers


-- | Wrappers for compiling and running benchmarks quickly and easily. See
--   <a>defaultMain</a> below for an example.
module Gauge.Main

-- | An entry point that can be used as a <tt>main</tt> function.
--   
--   <pre>
--   import Gauge.Main
--   
--   fib :: Int -&gt; Int
--   fib 0 = 0
--   fib 1 = 1
--   fib n = fib (n-1) + fib (n-2)
--   
--   main = defaultMain [
--          bgroup "fib" [ bench "10" $ whnf fib 10
--                       , bench "35" $ whnf fib 35
--                       , bench "37" $ whnf fib 37
--                       ]
--                      ]
--   </pre>
defaultMain :: [Benchmark] -> IO ()

-- | An entry point that can be used as a <tt>main</tt> function, with
--   configurable defaults.
--   
--   Example:
--   
--   <pre>
--   import Gauge.Main.Options
--   import Gauge.Main
--   
--   myConfig = defaultConfig {
--                -- Do not GC between runs.
--                forceGC = False
--              }
--   
--   main = defaultMainWith myConfig [
--            bench "fib 30" $ whnf fib 30
--          ]
--   </pre>
--   
--   If you save the above example as <tt>"Fib.hs"</tt>, you should be able
--   to compile it as follows:
--   
--   <pre>
--   ghc -O --make Fib
--   </pre>
--   
--   Run <tt>"Fib --help"</tt> on the command line to get a list of command
--   line options.
defaultMainWith :: Config -> [Benchmark] -> IO ()

-- | Run a set of <a>Benchmark</a>s with the given <a>Mode</a>.
--   
--   This can be useful if you have a <a>Mode</a> from some other source
--   (e.g. from a one in your benchmark driver's command-line parser).
runMode :: Mode -> Config -> [String] -> [Benchmark] -> IO ()

-- | Run a benchmark interactively with default config, and analyse its
--   performance.
benchmark :: Benchmarkable -> IO ()

-- | Run a benchmark interactively with supplied config, and analyse its
--   performance.
benchmarkWith :: Config -> Benchmarkable -> IO ()


-- | Fast and reliable micro benchmarking.
module Gauge
