{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, RecordWildCards #-}

-- |
-- Module      : Criterion.Main.Options
-- Copyright   : (c) 2014 Bryan O'Sullivan
--
-- License     : BSD-style
-- Maintainer  : bos@serpentine.com
-- Stability   : experimental
-- Portability : GHC
--
-- Benchmarking command-line configuration.

module Criterion.Main.Options
    (
      Mode(..)
    , MatchType(..)
    , defaultConfig
    , parseWith
    , config
    , describe
    , describeWith
    , versionInfo
    ) where

import Control.Monad (when)
import Criterion.Analysis (validateAccessors)
import Criterion.Types (Config(..), Verbosity(..), measureAccessors,
                        measureKeys)
import Data.Char (isSpace, toLower)
import Data.Data (Data, Typeable)
import Data.Int (Int64)
import Data.List (isPrefixOf)
import Data.Version (showVersion)
import GHC.Generics (Generic)
import Options.Applicative
import Options.Applicative.Help (Chunk(..), tabulate)
import Options.Applicative.Help.Pretty ((.$.))
import Options.Applicative.Types
import Paths_criterion (version)
import Prelude ()
import Prelude.Compat
import Statistics.Types (mkCL,cl95)
import Text.PrettyPrint.ANSI.Leijen (Doc, text)
import qualified Data.Map as M

-- | How to match a benchmark name.
data MatchType = Prefix
                 -- ^ Match by prefix. For example, a prefix of
                 -- @\"foo\"@ will match @\"foobar\"@.
               | Glob
                 -- ^ Match by Unix-style glob pattern. When using this match
                 -- type, benchmark names are treated as if they were
                 -- file-paths. For example, the glob patterns @\"*/ba*\"@ and
                 -- @\"*/*\"@ will match @\"foo/bar\"@, but @\"*\"@ or @\"*bar\"@
                 -- __will not__.
               | Pattern
                 -- ^ Match by searching given substring in benchmark
                 -- paths.
               | IPattern
                 -- ^ Same as 'Pattern', but case insensitive.
               deriving (MatchType -> MatchType -> Bool
(MatchType -> MatchType -> Bool)
-> (MatchType -> MatchType -> Bool) -> Eq MatchType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MatchType -> MatchType -> Bool
$c/= :: MatchType -> MatchType -> Bool
== :: MatchType -> MatchType -> Bool
$c== :: MatchType -> MatchType -> Bool
Eq, Eq MatchType
Eq MatchType =>
(MatchType -> MatchType -> Ordering)
-> (MatchType -> MatchType -> Bool)
-> (MatchType -> MatchType -> Bool)
-> (MatchType -> MatchType -> Bool)
-> (MatchType -> MatchType -> Bool)
-> (MatchType -> MatchType -> MatchType)
-> (MatchType -> MatchType -> MatchType)
-> Ord MatchType
MatchType -> MatchType -> Bool
MatchType -> MatchType -> Ordering
MatchType -> MatchType -> MatchType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MatchType -> MatchType -> MatchType
$cmin :: MatchType -> MatchType -> MatchType
max :: MatchType -> MatchType -> MatchType
$cmax :: MatchType -> MatchType -> MatchType
>= :: MatchType -> MatchType -> Bool
$c>= :: MatchType -> MatchType -> Bool
> :: MatchType -> MatchType -> Bool
$c> :: MatchType -> MatchType -> Bool
<= :: MatchType -> MatchType -> Bool
$c<= :: MatchType -> MatchType -> Bool
< :: MatchType -> MatchType -> Bool
$c< :: MatchType -> MatchType -> Bool
compare :: MatchType -> MatchType -> Ordering
$ccompare :: MatchType -> MatchType -> Ordering
$cp1Ord :: Eq MatchType
Ord, MatchType
MatchType -> MatchType -> Bounded MatchType
forall a. a -> a -> Bounded a
maxBound :: MatchType
$cmaxBound :: MatchType
minBound :: MatchType
$cminBound :: MatchType
Bounded, Int -> MatchType
MatchType -> Int
MatchType -> [MatchType]
MatchType -> MatchType
MatchType -> MatchType -> [MatchType]
MatchType -> MatchType -> MatchType -> [MatchType]
(MatchType -> MatchType)
-> (MatchType -> MatchType)
-> (Int -> MatchType)
-> (MatchType -> Int)
-> (MatchType -> [MatchType])
-> (MatchType -> MatchType -> [MatchType])
-> (MatchType -> MatchType -> [MatchType])
-> (MatchType -> MatchType -> MatchType -> [MatchType])
-> Enum MatchType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: MatchType -> MatchType -> MatchType -> [MatchType]
$cenumFromThenTo :: MatchType -> MatchType -> MatchType -> [MatchType]
enumFromTo :: MatchType -> MatchType -> [MatchType]
$cenumFromTo :: MatchType -> MatchType -> [MatchType]
enumFromThen :: MatchType -> MatchType -> [MatchType]
$cenumFromThen :: MatchType -> MatchType -> [MatchType]
enumFrom :: MatchType -> [MatchType]
$cenumFrom :: MatchType -> [MatchType]
fromEnum :: MatchType -> Int
$cfromEnum :: MatchType -> Int
toEnum :: Int -> MatchType
$ctoEnum :: Int -> MatchType
pred :: MatchType -> MatchType
$cpred :: MatchType -> MatchType
succ :: MatchType -> MatchType
$csucc :: MatchType -> MatchType
Enum, ReadPrec [MatchType]
ReadPrec MatchType
Int -> ReadS MatchType
ReadS [MatchType]
(Int -> ReadS MatchType)
-> ReadS [MatchType]
-> ReadPrec MatchType
-> ReadPrec [MatchType]
-> Read MatchType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MatchType]
$creadListPrec :: ReadPrec [MatchType]
readPrec :: ReadPrec MatchType
$creadPrec :: ReadPrec MatchType
readList :: ReadS [MatchType]
$creadList :: ReadS [MatchType]
readsPrec :: Int -> ReadS MatchType
$creadsPrec :: Int -> ReadS MatchType
Read, Int -> MatchType -> ShowS
[MatchType] -> ShowS
MatchType -> String
(Int -> MatchType -> ShowS)
-> (MatchType -> String)
-> ([MatchType] -> ShowS)
-> Show MatchType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MatchType] -> ShowS
$cshowList :: [MatchType] -> ShowS
show :: MatchType -> String
$cshow :: MatchType -> String
showsPrec :: Int -> MatchType -> ShowS
$cshowsPrec :: Int -> MatchType -> ShowS
Show, Typeable, Typeable MatchType
Constr
DataType
Typeable MatchType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MatchType -> c MatchType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MatchType)
-> (MatchType -> Constr)
-> (MatchType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MatchType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MatchType))
-> ((forall b. Data b => b -> b) -> MatchType -> MatchType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MatchType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MatchType -> r)
-> (forall u. (forall d. Data d => d -> u) -> MatchType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MatchType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MatchType -> m MatchType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MatchType -> m MatchType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MatchType -> m MatchType)
-> Data MatchType
MatchType -> Constr
MatchType -> DataType
(forall b. Data b => b -> b) -> MatchType -> MatchType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchType -> c MatchType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MatchType -> u
forall u. (forall d. Data d => d -> u) -> MatchType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MatchType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MatchType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MatchType -> m MatchType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MatchType -> m MatchType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchType -> c MatchType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MatchType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MatchType)
$cIPattern :: Constr
$cPattern :: Constr
$cGlob :: Constr
$cPrefix :: Constr
$tMatchType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MatchType -> m MatchType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MatchType -> m MatchType
gmapMp :: (forall d. Data d => d -> m d) -> MatchType -> m MatchType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MatchType -> m MatchType
gmapM :: (forall d. Data d => d -> m d) -> MatchType -> m MatchType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MatchType -> m MatchType
gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MatchType -> u
gmapQ :: (forall d. Data d => d -> u) -> MatchType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MatchType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MatchType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MatchType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MatchType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MatchType -> r
gmapT :: (forall b. Data b => b -> b) -> MatchType -> MatchType
$cgmapT :: (forall b. Data b => b -> b) -> MatchType -> MatchType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MatchType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MatchType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MatchType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MatchType)
dataTypeOf :: MatchType -> DataType
$cdataTypeOf :: MatchType -> DataType
toConstr :: MatchType -> Constr
$ctoConstr :: MatchType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchType -> c MatchType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchType -> c MatchType
$cp1Data :: Typeable MatchType
Data,
                         (forall x. MatchType -> Rep MatchType x)
-> (forall x. Rep MatchType x -> MatchType) -> Generic MatchType
forall x. Rep MatchType x -> MatchType
forall x. MatchType -> Rep MatchType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MatchType x -> MatchType
$cfrom :: forall x. MatchType -> Rep MatchType x
Generic)

-- | Execution mode for a benchmark program.
data Mode = List
            -- ^ List all benchmarks.
          | Version
            -- ^ Print the version.
          | RunIters Config Int64 MatchType [String]
            -- ^ Run the given benchmarks, without collecting or
            -- analysing performance numbers.
          | Run Config MatchType [String]
            -- ^ Run and analyse the given benchmarks.
          deriving (Mode -> Mode -> Bool
(Mode -> Mode -> Bool) -> (Mode -> Mode -> Bool) -> Eq Mode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mode -> Mode -> Bool
$c/= :: Mode -> Mode -> Bool
== :: Mode -> Mode -> Bool
$c== :: Mode -> Mode -> Bool
Eq, ReadPrec [Mode]
ReadPrec Mode
Int -> ReadS Mode
ReadS [Mode]
(Int -> ReadS Mode)
-> ReadS [Mode] -> ReadPrec Mode -> ReadPrec [Mode] -> Read Mode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Mode]
$creadListPrec :: ReadPrec [Mode]
readPrec :: ReadPrec Mode
$creadPrec :: ReadPrec Mode
readList :: ReadS [Mode]
$creadList :: ReadS [Mode]
readsPrec :: Int -> ReadS Mode
$creadsPrec :: Int -> ReadS Mode
Read, Int -> Mode -> ShowS
[Mode] -> ShowS
Mode -> String
(Int -> Mode -> ShowS)
-> (Mode -> String) -> ([Mode] -> ShowS) -> Show Mode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mode] -> ShowS
$cshowList :: [Mode] -> ShowS
show :: Mode -> String
$cshow :: Mode -> String
showsPrec :: Int -> Mode -> ShowS
$cshowsPrec :: Int -> Mode -> ShowS
Show, Typeable, Typeable Mode
Constr
DataType
Typeable Mode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Mode -> c Mode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Mode)
-> (Mode -> Constr)
-> (Mode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Mode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mode))
-> ((forall b. Data b => b -> b) -> Mode -> Mode)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r)
-> (forall u. (forall d. Data d => d -> u) -> Mode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Mode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Mode -> m Mode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mode -> m Mode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Mode -> m Mode)
-> Data Mode
Mode -> Constr
Mode -> DataType
(forall b. Data b => b -> b) -> Mode -> Mode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mode -> c Mode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Mode -> u
forall u. (forall d. Data d => d -> u) -> Mode -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mode -> c Mode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mode)
$cRun :: Constr
$cRunIters :: Constr
$cVersion :: Constr
$cList :: Constr
$tMode :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Mode -> m Mode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
gmapMp :: (forall d. Data d => d -> m d) -> Mode -> m Mode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
gmapM :: (forall d. Data d => d -> m d) -> Mode -> m Mode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Mode -> m Mode
gmapQi :: Int -> (forall d. Data d => d -> u) -> Mode -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Mode -> u
gmapQ :: (forall d. Data d => d -> u) -> Mode -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Mode -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mode -> r
gmapT :: (forall b. Data b => b -> b) -> Mode -> Mode
$cgmapT :: (forall b. Data b => b -> b) -> Mode -> Mode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mode)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Mode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Mode)
dataTypeOf :: Mode -> DataType
$cdataTypeOf :: Mode -> DataType
toConstr :: Mode -> Constr
$ctoConstr :: Mode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Mode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mode -> c Mode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Mode -> c Mode
$cp1Data :: Typeable Mode
Data, (forall x. Mode -> Rep Mode x)
-> (forall x. Rep Mode x -> Mode) -> Generic Mode
forall x. Rep Mode x -> Mode
forall x. Mode -> Rep Mode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Mode x -> Mode
$cfrom :: forall x. Mode -> Rep Mode x
Generic)

-- | Default benchmarking configuration.
defaultConfig :: Config
defaultConfig :: Config
defaultConfig = Config :: CL Double
-> Double
-> Int
-> [([String], String)]
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Verbosity
-> String
-> Config
Config {
      confInterval :: CL Double
confInterval = CL Double
forall a. Fractional a => CL a
cl95
    , timeLimit :: Double
timeLimit    = 5
    , resamples :: Int
resamples    = 1000
    , regressions :: [([String], String)]
regressions  = []
    , rawDataFile :: Maybe String
rawDataFile  = Maybe String
forall a. Maybe a
Nothing
    , reportFile :: Maybe String
reportFile   = Maybe String
forall a. Maybe a
Nothing
    , csvFile :: Maybe String
csvFile      = Maybe String
forall a. Maybe a
Nothing
    , jsonFile :: Maybe String
jsonFile     = Maybe String
forall a. Maybe a
Nothing
    , junitFile :: Maybe String
junitFile    = Maybe String
forall a. Maybe a
Nothing
    , verbosity :: Verbosity
verbosity    = Verbosity
Normal
    , template :: String
template     = "default"
    }

-- | Parse a command line.
parseWith :: Config
             -- ^ Default configuration to use if options are not
             -- explicitly specified.
          -> Parser Mode
parseWith :: Config -> Parser Mode
parseWith cfg :: Config
cfg = Config -> Parser Config
config Config
cfg Parser Config -> Parser (Config -> Mode) -> Parser Mode
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser (Config -> Mode)
runMode
                -- Important: only run `config` once here, as we only want the
                -- command-line options resulting from `config` to appear once
                -- in the `--help` output. See #168.
  where
    runMode :: Parser (Config -> Mode)
    runMode :: Parser (Config -> Mode)
runMode =
      Parser (MatchType -> [String] -> Config -> Mode)
-> Parser (Config -> Mode)
matchNames ((MatchType -> [String] -> Config -> Mode)
-> Parser (MatchType -> [String] -> Config -> Mode)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((MatchType -> [String] -> Config -> Mode)
 -> Parser (MatchType -> [String] -> Config -> Mode))
-> (MatchType -> [String] -> Config -> Mode)
-> Parser (MatchType -> [String] -> Config -> Mode)
forall a b. (a -> b) -> a -> b
$ \mt :: MatchType
mt bs :: [String]
bs cfg' :: Config
cfg' -> Config -> MatchType -> [String] -> Mode
Run Config
cfg' MatchType
mt [String]
bs) Parser (Config -> Mode)
-> Parser (Config -> Mode) -> Parser (Config -> Mode)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      Parser (Config -> Mode)
runIters Parser (Config -> Mode)
-> Parser (Config -> Mode) -> Parser (Config -> Mode)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Mode -> Config -> Mode
forall a b. a -> b -> a
const Mode
List (Config -> Mode) -> Parser Bool -> Parser (Config -> Mode)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Mod FlagFields Bool -> Parser Bool
switch (String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "list" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> Char -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'l' Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help "List benchmarks")) Parser (Config -> Mode)
-> Parser (Config -> Mode) -> Parser (Config -> Mode)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Mode -> Config -> Mode
forall a b. a -> b -> a
const Mode
Version (Config -> Mode) -> Parser Bool -> Parser (Config -> Mode)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Mod FlagFields Bool -> Parser Bool
switch (String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "version" Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help "Show version info"))

    runIters :: Parser (Config -> Mode)
    runIters :: Parser (Config -> Mode)
runIters = Parser (MatchType -> [String] -> Config -> Mode)
-> Parser (Config -> Mode)
matchNames (Parser (MatchType -> [String] -> Config -> Mode)
 -> Parser (Config -> Mode))
-> Parser (MatchType -> [String] -> Config -> Mode)
-> Parser (Config -> Mode)
forall a b. (a -> b) -> a -> b
$ (\iters :: Int64
iters mt :: MatchType
mt bs :: [String]
bs cfg' :: Config
cfg' -> Config -> Int64 -> MatchType -> [String] -> Mode
RunIters Config
cfg' Int64
iters MatchType
mt [String]
bs)
      (Int64 -> MatchType -> [String] -> Config -> Mode)
-> Parser Int64 -> Parser (MatchType -> [String] -> Config -> Mode)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int64 -> Mod OptionFields Int64 -> Parser Int64
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM Int64
forall a. Read a => ReadM a
auto
          (String -> Mod OptionFields Int64
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "iters" Mod OptionFields Int64
-> Mod OptionFields Int64 -> Mod OptionFields Int64
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields Int64
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'n' Mod OptionFields Int64
-> Mod OptionFields Int64 -> Mod OptionFields Int64
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int64
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "ITERS" Mod OptionFields Int64
-> Mod OptionFields Int64 -> Mod OptionFields Int64
forall a. Semigroup a => a -> a -> a
<>
           String -> Mod OptionFields Int64
forall (f :: * -> *) a. String -> Mod f a
help "Run benchmarks, don't analyse")

    matchNames :: Parser (MatchType -> [String] -> Config -> Mode)
               -> Parser (Config -> Mode)
    matchNames :: Parser (MatchType -> [String] -> Config -> Mode)
-> Parser (Config -> Mode)
matchNames wat :: Parser (MatchType -> [String] -> Config -> Mode)
wat = Parser (MatchType -> [String] -> Config -> Mode)
wat
      Parser (MatchType -> [String] -> Config -> Mode)
-> Parser MatchType -> Parser ([String] -> Config -> Mode)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReadM MatchType -> Mod OptionFields MatchType -> Parser MatchType
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM MatchType
match
          (String -> Mod OptionFields MatchType
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "match" Mod OptionFields MatchType
-> Mod OptionFields MatchType -> Mod OptionFields MatchType
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields MatchType
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'm' Mod OptionFields MatchType
-> Mod OptionFields MatchType -> Mod OptionFields MatchType
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields MatchType
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "MATCH" Mod OptionFields MatchType
-> Mod OptionFields MatchType -> Mod OptionFields MatchType
forall a. Semigroup a => a -> a -> a
<> MatchType -> Mod OptionFields MatchType
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value MatchType
Prefix Mod OptionFields MatchType
-> Mod OptionFields MatchType -> Mod OptionFields MatchType
forall a. Semigroup a => a -> a -> a
<>
           String -> Mod OptionFields MatchType
forall (f :: * -> *) a. String -> Mod f a
help "How to match benchmark names (\"prefix\", \"glob\", \"pattern\", or \"ipattern\")")
      Parser ([String] -> Config -> Mode)
-> Parser [String] -> Parser (Config -> Mode)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser String -> Parser [String]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ReadM String -> Mod ArgumentFields String -> Parser String
forall a. ReadM a -> Mod ArgumentFields a -> Parser a
argument ReadM String
forall s. IsString s => ReadM s
str (String -> Mod ArgumentFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "NAME..."))

-- | Parse a configuration.
config :: Config -> Parser Config
config :: Config -> Parser Config
config Config{..} = CL Double
-> Double
-> Int
-> [([String], String)]
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Maybe String
-> Verbosity
-> String
-> Config
Config
  (CL Double
 -> Double
 -> Int
 -> [([String], String)]
 -> Maybe String
 -> Maybe String
 -> Maybe String
 -> Maybe String
 -> Maybe String
 -> Verbosity
 -> String
 -> Config)
-> Parser (CL Double)
-> Parser
     (Double
      -> Int
      -> [([String], String)]
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Verbosity
      -> String
      -> Config)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM (CL Double)
-> Mod OptionFields (CL Double) -> Parser (CL Double)
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Double -> CL Double
forall a. (Ord a, Num a) => a -> CL a
mkCL (Double -> CL Double) -> ReadM Double -> ReadM (CL Double)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Double -> Double -> ReadM Double
forall a. (Show a, Read a, Ord a) => a -> a -> ReadM a
range 0.001 0.999)
      (String -> Mod OptionFields (CL Double)
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "ci" Mod OptionFields (CL Double)
-> Mod OptionFields (CL Double) -> Mod OptionFields (CL Double)
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields (CL Double)
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'I' Mod OptionFields (CL Double)
-> Mod OptionFields (CL Double) -> Mod OptionFields (CL Double)
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields (CL Double)
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "CI" Mod OptionFields (CL Double)
-> Mod OptionFields (CL Double) -> Mod OptionFields (CL Double)
forall a. Semigroup a => a -> a -> a
<> CL Double -> Mod OptionFields (CL Double)
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value CL Double
confInterval Mod OptionFields (CL Double)
-> Mod OptionFields (CL Double) -> Mod OptionFields (CL Double)
forall a. Semigroup a => a -> a -> a
<>
       String -> Mod OptionFields (CL Double)
forall (f :: * -> *) a. String -> Mod f a
help "Confidence interval")
  Parser
  (Double
   -> Int
   -> [([String], String)]
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Verbosity
   -> String
   -> Config)
-> Parser Double
-> Parser
     (Int
      -> [([String], String)]
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Verbosity
      -> String
      -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReadM Double -> Mod OptionFields Double -> Parser Double
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Double -> Double -> ReadM Double
forall a. (Show a, Read a, Ord a) => a -> a -> ReadM a
range 0.1 86400)
      (String -> Mod OptionFields Double
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "time-limit" Mod OptionFields Double
-> Mod OptionFields Double -> Mod OptionFields Double
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields Double
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'L' Mod OptionFields Double
-> Mod OptionFields Double -> Mod OptionFields Double
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Double
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "SECS" Mod OptionFields Double
-> Mod OptionFields Double -> Mod OptionFields Double
forall a. Semigroup a => a -> a -> a
<> Double -> Mod OptionFields Double
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value Double
timeLimit Mod OptionFields Double
-> Mod OptionFields Double -> Mod OptionFields Double
forall a. Semigroup a => a -> a -> a
<>
       String -> Mod OptionFields Double
forall (f :: * -> *) a. String -> Mod f a
help "Time limit to run a benchmark")
  Parser
  (Int
   -> [([String], String)]
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Verbosity
   -> String
   -> Config)
-> Parser Int
-> Parser
     ([([String], String)]
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Verbosity
      -> String
      -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Int -> Int -> ReadM Int
forall a. (Show a, Read a, Ord a) => a -> a -> ReadM a
range 1 1000000)
      (String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "resamples" Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "COUNT" Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> Int -> Mod OptionFields Int
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value Int
resamples Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<>
       String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help "Number of bootstrap resamples to perform")
  Parser
  ([([String], String)]
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Verbosity
   -> String
   -> Config)
-> Parser [([String], String)]
-> Parser
     (Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Verbosity
      -> String
      -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ([String], String) -> Parser [([String], String)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (ReadM ([String], String)
-> Mod OptionFields ([String], String) -> Parser ([String], String)
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM ([String], String)
regressParams
            (String -> Mod OptionFields ([String], String)
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "regress" Mod OptionFields ([String], String)
-> Mod OptionFields ([String], String)
-> Mod OptionFields ([String], String)
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields ([String], String)
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "RESP:PRED.." Mod OptionFields ([String], String)
-> Mod OptionFields ([String], String)
-> Mod OptionFields ([String], String)
forall a. Semigroup a => a -> a -> a
<>
             String -> Mod OptionFields ([String], String)
forall (f :: * -> *) a. String -> Mod f a
help "Regressions to perform"))
  Parser
  (Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Verbosity
   -> String
   -> Config)
-> Parser (Maybe String)
-> Parser
     (Maybe String
      -> Maybe String
      -> Maybe String
      -> Maybe String
      -> Verbosity
      -> String
      -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe String -> Mod OptionFields String -> Parser (Maybe String)
outputOption Maybe String
rawDataFile (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "raw" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<>
                                String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "File to write raw data to")
  Parser
  (Maybe String
   -> Maybe String
   -> Maybe String
   -> Maybe String
   -> Verbosity
   -> String
   -> Config)
-> Parser (Maybe String)
-> Parser
     (Maybe String
      -> Maybe String -> Maybe String -> Verbosity -> String -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe String -> Mod OptionFields String -> Parser (Maybe String)
outputOption Maybe String
reportFile (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "output" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'o' Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<>
                               String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "File to write report to")
  Parser
  (Maybe String
   -> Maybe String -> Maybe String -> Verbosity -> String -> Config)
-> Parser (Maybe String)
-> Parser
     (Maybe String -> Maybe String -> Verbosity -> String -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe String -> Mod OptionFields String -> Parser (Maybe String)
outputOption Maybe String
csvFile (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "csv" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<>
                            String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "File to write CSV summary to")
  Parser
  (Maybe String -> Maybe String -> Verbosity -> String -> Config)
-> Parser (Maybe String)
-> Parser (Maybe String -> Verbosity -> String -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe String -> Mod OptionFields String -> Parser (Maybe String)
outputOption Maybe String
jsonFile (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "json" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<>
                             String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "File to write JSON summary to")
  Parser (Maybe String -> Verbosity -> String -> Config)
-> Parser (Maybe String) -> Parser (Verbosity -> String -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe String -> Mod OptionFields String -> Parser (Maybe String)
outputOption Maybe String
junitFile (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "junit" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<>
                              String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "File to write JUnit summary to")
  Parser (Verbosity -> String -> Config)
-> Parser Verbosity -> Parser (String -> Config)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Int -> Verbosity
forall a. Enum a => Int -> a
toEnum (Int -> Verbosity) -> Parser Int -> Parser Verbosity
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (Int -> Int -> ReadM Int
forall a. (Show a, Read a, Ord a) => a -> a -> ReadM a
range 0 2)
                  (String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "verbosity" Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 'v' Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields Int
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "LEVEL" Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<>
                   Int -> Mod OptionFields Int
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value (Verbosity -> Int
forall a. Enum a => a -> Int
fromEnum Verbosity
verbosity) Mod OptionFields Int
-> Mod OptionFields Int -> Mod OptionFields Int
forall a. Semigroup a => a -> a -> a
<>
                   String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help "Verbosity level"))
  Parser (String -> Config) -> Parser String -> Parser Config
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long "template" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> Char -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short 't' Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "FILE" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<>
                 String -> Mod OptionFields String
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value String
template Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<>
                 String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help "Template to use for report")

outputOption :: Maybe String -> Mod OptionFields String -> Parser (Maybe String)
outputOption :: Maybe String -> Mod OptionFields String -> Parser (Maybe String)
outputOption file :: Maybe String
file m :: Mod OptionFields String
m =
  Parser String -> Parser (Maybe String)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption (Mod OptionFields String
m Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar "FILE" Mod OptionFields String
-> Mod OptionFields String -> Mod OptionFields String
forall a. Semigroup a => a -> a -> a
<> Mod OptionFields String
-> (String -> Mod OptionFields String)
-> Maybe String
-> Mod OptionFields String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Mod OptionFields String
forall a. Monoid a => a
mempty String -> Mod OptionFields String
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value Maybe String
file))

range :: (Show a, Read a, Ord a) => a -> a -> ReadM a
range :: a -> a -> ReadM a
range lo :: a
lo hi :: a
hi = do
  String
s <- ReadM String
readerAsk
  case ReadS a
forall a. Read a => ReadS a
reads String
s of
    [(i :: a
i, "")]
      | a
i a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
lo Bool -> Bool -> Bool
&& a
i a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= a
hi -> a -> ReadM a
forall (m :: * -> *) a. Monad m => a -> m a
return a
i
      | Bool
otherwise -> String -> ReadM a
forall a. String -> ReadM a
readerError (String -> ReadM a) -> String -> ReadM a
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. Show a => a -> String
show a
i String -> ShowS
forall a. [a] -> [a] -> [a]
++ " is outside range " String -> ShowS
forall a. [a] -> [a] -> [a]
++
                                   (a, a) -> String
forall a. Show a => a -> String
show (a
lo,a
hi)
    _             -> String -> ReadM a
forall a. String -> ReadM a
readerError (String -> ReadM a) -> String -> ReadM a
forall a b. (a -> b) -> a -> b
$ ShowS
forall a. Show a => a -> String
show String
s String -> ShowS
forall a. [a] -> [a] -> [a]
++ " is not a number"

match :: ReadM MatchType
match :: ReadM MatchType
match = do
  String
m <- ReadM String
readerAsk
  case (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
m of
    mm :: String
mm | String
mm String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` "pfx"      -> MatchType -> ReadM MatchType
forall (m :: * -> *) a. Monad m => a -> m a
return MatchType
Prefix
       | String
mm String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` "prefix"   -> MatchType -> ReadM MatchType
forall (m :: * -> *) a. Monad m => a -> m a
return MatchType
Prefix
       | String
mm String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` "glob"     -> MatchType -> ReadM MatchType
forall (m :: * -> *) a. Monad m => a -> m a
return MatchType
Glob
       | String
mm String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` "pattern"  -> MatchType -> ReadM MatchType
forall (m :: * -> *) a. Monad m => a -> m a
return MatchType
Pattern
       | String
mm String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` "ipattern" -> MatchType -> ReadM MatchType
forall (m :: * -> *) a. Monad m => a -> m a
return MatchType
IPattern
       | Bool
otherwise                  -> String -> ReadM MatchType
forall a. String -> ReadM a
readerError (String -> ReadM MatchType) -> String -> ReadM MatchType
forall a b. (a -> b) -> a -> b
$
                                       ShowS
forall a. Show a => a -> String
show String
m String -> ShowS
forall a. [a] -> [a] -> [a]
++ " is not a known match type"
                                              String -> ShowS
forall a. [a] -> [a] -> [a]
++ "Try \"prefix\", \"pattern\", \"ipattern\" or \"glob\"."

regressParams :: ReadM ([String], String)
regressParams :: ReadM ([String], String)
regressParams = do
  String
m <- ReadM String
readerAsk
  let repl :: Char -> Char
repl ','   = ' '
      repl c :: Char
c     = Char
c
      tidy :: ShowS
tidy       = ShowS
forall a. [a] -> [a]
reverse ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
forall a. [a] -> [a]
reverse ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace
      (r :: String
r,ps :: String
ps)     = (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==':') String
m
  Bool -> ReadM () -> ReadM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
r) (ReadM () -> ReadM ()) -> ReadM () -> ReadM ()
forall a b. (a -> b) -> a -> b
$
    String -> ReadM ()
forall a. String -> ReadM a
readerError "no responder specified"
  Bool -> ReadM () -> ReadM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
ps) (ReadM () -> ReadM ()) -> ReadM () -> ReadM ()
forall a b. (a -> b) -> a -> b
$
    String -> ReadM ()
forall a. String -> ReadM a
readerError "no predictors specified"
  let ret :: ([String], String)
ret = (String -> [String]
words (String -> [String]) -> ShowS -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
repl ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ShowS
forall a. Int -> [a] -> [a]
drop 1 (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ String
ps, ShowS
tidy String
r)
  (String -> ReadM ([String], String))
-> ([(String, Measured -> Maybe Double)]
    -> ReadM ([String], String))
-> Either String [(String, Measured -> Maybe Double)]
-> ReadM ([String], String)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either String -> ReadM ([String], String)
forall a. String -> ReadM a
readerError (ReadM ([String], String)
-> [(String, Measured -> Maybe Double)] -> ReadM ([String], String)
forall a b. a -> b -> a
const (([String], String) -> ReadM ([String], String)
forall (m :: * -> *) a. Monad m => a -> m a
return ([String], String)
ret)) (Either String [(String, Measured -> Maybe Double)]
 -> ReadM ([String], String))
-> Either String [(String, Measured -> Maybe Double)]
-> ReadM ([String], String)
forall a b. (a -> b) -> a -> b
$ ([String]
 -> String -> Either String [(String, Measured -> Maybe Double)])
-> ([String], String)
-> Either String [(String, Measured -> Maybe Double)]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry [String]
-> String -> Either String [(String, Measured -> Maybe Double)]
validateAccessors ([String], String)
ret

-- | Flesh out a command-line parser.
describe :: Config -> ParserInfo Mode
describe :: Config -> ParserInfo Mode
describe cfg :: Config
cfg = Parser Mode -> ParserInfo Mode
forall a. Parser a -> ParserInfo a
describeWith (Parser Mode -> ParserInfo Mode) -> Parser Mode -> ParserInfo Mode
forall a b. (a -> b) -> a -> b
$ Config -> Parser Mode
parseWith Config
cfg

-- | Flesh out command-line information using a custom 'Parser'.
describeWith :: Parser a -> ParserInfo a
describeWith :: Parser a -> ParserInfo a
describeWith parser :: Parser a
parser = Parser a -> InfoMod a -> ParserInfo a
forall a. Parser a -> InfoMod a -> ParserInfo a
info (Parser (a -> a)
forall a. Parser (a -> a)
helper Parser (a -> a) -> Parser a -> Parser a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a
parser) (InfoMod a -> ParserInfo a) -> InfoMod a -> ParserInfo a
forall a b. (a -> b) -> a -> b
$
    String -> InfoMod a
forall a. String -> InfoMod a
header ("Microbenchmark suite - " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
versionInfo) InfoMod a -> InfoMod a -> InfoMod a
forall a. Semigroup a => a -> a -> a
<>
    InfoMod a
forall a. InfoMod a
fullDesc InfoMod a -> InfoMod a -> InfoMod a
forall a. Semigroup a => a -> a -> a
<>
    Maybe Doc -> InfoMod a
forall a. Maybe Doc -> InfoMod a
footerDoc (Chunk Doc -> Maybe Doc
forall a. Chunk a -> Maybe a
unChunk Chunk Doc
regressionHelp)

-- | A string describing the version of this benchmark (really, the
-- version of criterion that was used to build it).
versionInfo :: String
versionInfo :: String
versionInfo = "built with criterion " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Version -> String
showVersion Version
version

-- We sort not by name, but by likely frequency of use.
regressionHelp :: Chunk Doc
regressionHelp :: Chunk Doc
regressionHelp =
    (Doc -> Doc) -> Chunk Doc -> Chunk Doc
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (String -> Doc
text "Regression metrics (for use with --regress):" Doc -> Doc -> Doc
.$.) (Chunk Doc -> Chunk Doc) -> Chunk Doc -> Chunk Doc
forall a b. (a -> b) -> a -> b
$
      [(Doc, Doc)] -> Chunk Doc
tabulate [(String -> Doc
text String
n,String -> Doc
text String
d) | (n :: String
n,(_,d :: String
d)) <- (String -> (String, (Measured -> Maybe Double, String)))
-> [String] -> [(String, (Measured -> Maybe Double, String))]
forall a b. (a -> b) -> [a] -> [b]
map String -> (String, (Measured -> Maybe Double, String))
f [String]
measureKeys]
  where f :: String -> (String, (Measured -> Maybe Double, String))
f k :: String
k = (String
k, Map String (Measured -> Maybe Double, String)
measureAccessors Map String (Measured -> Maybe Double, String)
-> String -> (Measured -> Maybe Double, String)
forall k a. Ord k => Map k a -> k -> a
M.! String
k)