BenchLib

newtype Bench a b

Opaque type for the benchmark.

Instances

• Functor (Bench a)
• CanRunOnly (Bench a b)

type BenchOpts = { iterations :: Int }

Options for Benchmarks.

type BenchResult = { benchName :: String, samples :: Array SampleResult }

The result of a benchmark.

type CheckResult = { benchName :: String, showedInput :: Maybe String, showedOutput :: Maybe String }

type CheckResults = { groupName :: String, results :: Array CheckResult, size :: Size, success :: Boolean }

newtype Group

Opaque type for the benchmark group.

Instances

• CanRunOnly Group

type GroupOpts a b = { check :: Maybe (Size -> Array (a /\ b) -> Boolean), iterations :: Int, printInput :: Maybe (a -> String), printOutput :: Maybe (b -> String), sizes :: Array Int }

Options for the benchmark group.

type GroupResult = { benchResults :: Array BenchResult, checkResults :: Maybe (Array CheckResults), groupName :: String }

The result of a benchmark group.

type Reporter = { onBenchFinish :: BenchResult -> Aff Unit, onBenchStart :: String -> Aff Unit, onGroupFinish :: GroupResult -> Aff Unit, onGroupStart :: String -> Aff Unit, onSampleFinish :: SampleResult -> Aff Unit, onSampleStart :: Size -> Aff Unit, onSuiteFinish :: SuiteResult -> Aff Unit, onSuiteStart :: String -> Aff Unit }

A reporter is a set of functions that are called at different stages of the benchmark. It allows to customize the output of the benchmark suite or perform other actions like writing to a file.

type RunOpts = { reporters :: Array Reporter }

Options to run benchmark suites.

type SampleResult = { average :: Milliseconds, iterations :: Int, size :: Size }

The result of one benchmark sample.

type Size = Int

newtype Suite

Opaque type for the benchmark suite.

type SuiteOpts = { iterations :: Int, sizes :: Array Size }

Options for the benchmark suite.

type SuiteResult = { groupResults :: Array GroupResult, suiteName :: String }

The result of a benchmark suite.

basic :: forall a b. Bench a b -> Bench Unit Unit

bench :: forall a b. String -> (BenchOpts -> BenchOpts) -> (Size -> a) -> (a -> b) -> Bench a b

benchAff :: forall a b. String -> (BenchOpts -> BenchOpts) -> (Size -> Aff a) -> (a -> Aff b) -> Bench a b

benchAff_ :: forall a b. String -> (Size -> Aff a) -> (a -> Aff b) -> Bench a b

Like benchAff, but with default options.

bench_ :: forall a b. String -> (Size -> a) -> (a -> b) -> Bench a b

checkAllEq :: forall a. Eq a => Array a -> Boolean

Check if all elements in the array are equal. Useful for checking the results of benchmarks.

class CanRunOnly a  where

A combinator for entities that can be run only once. This is useful while debugging or developing benchmarks. So you do not have to run the whole suite again and again.

Members

• only :: Warn (Text "`only` usage") => a -> a

Instances

• CanRunOnly (Bench a b)
• CanRunOnly Group

defaultReporter :: Reporter

Default reporter useful for selective overriding. It will do nothing.

group :: forall a b. String -> (GroupOpts a b -> GroupOpts a b) -> Array (Bench a b) -> Group

Create a benchmark group of a given name. The group will be run with the provided options. The group is a collection of benchmarks

group_ :: forall a b. String -> Array (Bench a b) -> Group

Like group, but with default options.

normalize :: forall a a' b b'. (a -> a') -> (b -> b') -> Bench a b -> Bench a' b'

normalizeAff :: forall a a' b b'. (a -> Aff a') -> (b -> Aff b') -> Bench a b -> Bench a' b'

normalizeInput :: forall a a' b. (a -> a') -> Bench a b -> Bench a' b

normalizeInputAff :: forall a a' b. (a -> Aff a') -> Bench a b -> Bench a' b

normalizeOutput :: forall a b b'. (b -> b') -> Bench a b -> Bench a b'

normalizeOutputAff :: forall a b b'. (b -> Aff b') -> Bench a b -> Bench a b'

reportConsole :: Reporter

Console reporter. It will print the results to the console in human readable format.

runNode :: (RunOpts -> RunOpts) -> Suite -> Effect Unit

Run the benchmark suite.

runNode_ :: Suite -> Effect Unit

suite :: String -> (SuiteOpts -> SuiteOpts) -> Array Group -> Suite

Create a benchmark suite of a given name. The suite will be run with the provided options. The suite is a collection of groups, each containing multiple benchmarks.

suite_ :: String -> Array Group -> Suite

Like suite, but with default options.