BenchLib

type Size = Int

newtype Bench a b

Opaque type for the benchmark.

Instances

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

newtype Group

Opaque type for the benchmark group.

Instances

• CanRunOnly Group

newtype Suite

Opaque type for the benchmark suite.

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

The result of a benchmark.

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

The result of a benchmark group.

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

The result of a benchmark suite.

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

The result of one benchmark sample.

type CheckResults = { groupName :: String, results :: Array { benchName :: String, showedVal :: Maybe String }, size :: Size, success :: Boolean }

type RunOpts = { reporters :: Array Reporter }

Options to run benchmark suites.

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

Options for the benchmark suite.

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

Options for the benchmark group.

type BenchOpts = { iterations :: Int }

Options for Benchmarks.

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.

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.

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

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

runNode_ :: Suite -> Effect Unit

suite_ :: String -> Array Group -> Suite

Like suite, but with default options.

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

Like group, but with default options.

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

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

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

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

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

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

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

normalizeOutput :: forall a b b'. (b -> b') -> Bench 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.

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.