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


-- | Performance methods and monad.
--   
--   A set of tools to measure performance of Haskell programs. See the
--   Perf module and readme for an example and full API documentation.
@package perf
@version 0.13.0.0


-- | Statistical choices for multiple performance measurements.
module Perf.Stats

-- | Compute the average
average :: [Double] -> Double

-- | Compute the median
median :: [Double] -> Double

-- | Compute the tenth percentile
tenth :: [Double] -> Double

-- | Compute the average of an Integral
averageI :: Integral a => [a] -> Double

-- | Command-line options for type of statistic.
data StatDType
StatAverage :: StatDType
StatMedian :: StatDType
StatBest :: StatDType

-- | Compute a statistic.
statD :: StatDType -> [Double] -> Double

-- | Compute a list of statistics.
statDs :: StatDType -> [[Double]] -> [Double]

-- | Parse command-line <a>StatDType</a> options.
parseStatD :: Parser StatDType

-- | Add a statistic to a State Map
addStat :: (Ord k, Monad m) => k -> s -> StateT (Map k s) m ()

-- | Linguistic conversion of an ordinal
ordy :: Int -> [Text]

-- | Compute all stats.
allStats :: Int -> Map [Text] [[Double]] -> Map [Text] [Double]

-- | Convert a Map of performance result to a statistic.
statify :: Ord a => StatDType -> Map a [[Double]] -> Map [a] [Double]
instance GHC.Show.Show Perf.Stats.StatDType
instance GHC.Classes.Eq Perf.Stats.StatDType


-- | Abstract types of performance measurement.
module Perf.Types

-- | Abstraction of a performance measurement within a monadic context.
--   
--   <ul>
--   <li>measure applies a function to a value, returning a tuple of the
--   performance measure, and the computation result.</li>
--   <li>measureM evaluates a monadic value and returns a
--   performance-result tuple.</li>
--   </ul>
data Measure m t
Measure :: (forall a b. (a -> b) -> a -> m (t, b)) -> (forall a. m a -> m (t, a)) -> Measure m t
[measure] :: Measure m t -> forall a b. (a -> b) -> a -> m (t, b)
[measureM] :: Measure m t -> forall a. m a -> m (t, a)

-- | Convert a Measure into a multi measure.
repeated :: Applicative m => Int -> Measure m t -> Measure m [t]

-- | Abstraction of a performance measurement with a pre and a post step
--   wrapping the computation.
data StepMeasure m t
StepMeasure :: m i -> (i -> m t) -> StepMeasure m t
[pre] :: StepMeasure m t -> m i
[post] :: StepMeasure m t -> i -> m t

-- | Convert a StepMeasure into a Measure
toMeasure :: Monad m => StepMeasure m t -> Measure m t

-- | Convert a StepMeasure into a Measure running the computation multiple
--   times.
toMeasureN :: Monad m => Int -> StepMeasure m t -> Measure m [t]

-- | A single step measurement.
step :: Monad m => m i -> (i -> m t) -> (a -> b) -> a -> m (t, b)

-- | A single step measurement.
stepM :: Monad m => m i -> (i -> m t) -> m a -> m (t, a)

-- | Multiple measurement
multi :: Monad m => ((a -> b) -> a -> m (t, b)) -> Int -> (a -> b) -> a -> m ([t], b)

-- | Multiple measurements
multiM :: Monad m => (m a -> m (t, a)) -> Int -> m a -> m ([t], a)

-- | Lift an application to a PerfT m, providing a label and a
--   <a>Measure</a>.
--   
--   Measurements with the same label will be mappended
fap :: (MonadIO m, Semigroup t) => Text -> (a -> b) -> a -> PerfT m t b

-- | Lift an application to a PerfT m, forcing the argument.
afap :: (NFData a, MonadIO m, Semigroup t) => Text -> (a -> b) -> a -> PerfT m t b

-- | Lift an application to a PerfT m, forcing argument and result.
ffap :: (NFData a, NFData b, MonadIO m, Semigroup t) => Text -> (a -> b) -> a -> PerfT m t b

-- | Lift a number to a PerfT m, providing a label, function, and input.
--   
--   Measurements with the same label will be added
fan :: (MonadIO m, Num t) => Text -> (a -> b) -> a -> PerfT m t b

-- | Lift a monadic value to a PerfT m, providing a label and a
--   <a>Measure</a>.
--   
--   Measurements with the same label will be added
fam :: (MonadIO m, Semigroup t) => Text -> m a -> PerfT m t a

-- | lift a pure, unnamed function application to PerfT
(|$|) :: Semigroup t => (a -> b) -> a -> PerfT IO t b

-- | lift a monadic, unnamed function application to PerfT
($|) :: Semigroup t => IO a -> PerfT IO t a

-- | lift an unnamed numeric measure to PerfT
(|+|) :: Num t => (a -> b) -> a -> PerfT IO t b

-- | Performance measurement transformer storing a <a>Measure</a> and a map
--   of named results.
newtype PerfT m t a
PerfT :: StateT (Measure m t, Map Text t) m a -> PerfT m t a
[measurePerf] :: PerfT m t a -> StateT (Measure m t, Map Text t) m a

-- | The transformer over Identity
type Perf t a = PerfT Identity t a

-- | Run the performance measure, returning (computational result,
--   measurement).
runPerfT :: Functor m => Measure m t -> PerfT m t a -> m (a, Map Text t)

-- | Consume the PerfT layer and return the original monadic result.
--   Fingers crossed, PerfT structure should be completely compiled away.
evalPerfT :: Monad m => Measure m t -> PerfT m t a -> m a

-- | Consume a PerfT layer and return the measurement.
execPerfT :: Monad m => Measure m t -> PerfT m t a -> m (Map Text t)

-- | run a PerfT and also calculate performance over the entire computation
outer :: (MonadIO m, Semigroup s) => Text -> Measure m s -> Measure m t -> PerfT m t a -> m (a, (Map Text s, Map Text t))

-- | run a PerfT and calculate excess performance over the entire
--   computation
slop :: (MonadIO m, Num t, Semigroup t) => Text -> Measure m t -> PerfT m t a -> m (a, Map Text t)

-- | run a multi PerfT and calculate excess performance over the entire
--   computation
slops :: (MonadIO m, Num t, Semigroup t) => Int -> Measure m t -> PerfT m [t] a -> m (a, (Map Text t, Map Text [t]))
instance GHC.Base.Monad m => GHC.Base.Monad (Perf.Types.PerfT m t)
instance GHC.Base.Monad m => GHC.Base.Applicative (Perf.Types.PerfT m t)
instance GHC.Base.Functor m => GHC.Base.Functor (Perf.Types.PerfT m t)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Perf.Types.PerfT m t)
instance GHC.Base.Functor m => GHC.Base.Functor (Perf.Types.StepMeasure m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Perf.Types.StepMeasure m)
instance GHC.Base.Functor m => GHC.Base.Functor (Perf.Types.Measure m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Perf.Types.Measure m)


-- | Use of <a>Clock</a> from the <a>clock</a> library to measure time
--   performance of a computation.
module Perf.Time

-- | A performance measure of number of nanoseconds.
type Nanos = Integer

-- | <a>MonotonicRaw</a> is the default for macOS &amp; linux, at around 42
--   nano time resolution, and a <a>tick_</a> measurement of around 170
--   nanos. For Windows, <a>ThreadCPUTime</a> has a similar time resolution
--   at 42 nanos and a <a>tick_</a> of around 500 nanos.
defaultClock :: Clock

-- | Convert <a>Nanos</a> to seconds.
toSecs :: Nanos -> Double

-- | A single reading of a specific <a>Clock</a>.
nanosWith :: Clock -> IO Nanos

-- | A single <a>defaultClock</a> reading (note that the absolute value is
--   not meaningful).
nanos :: IO Nanos

-- | tick_ measures the number of nanos it takes to read the clock.
tick_ :: IO Nanos

-- | Warm up the clock, to avoid a high first measurement. Without a
--   warmup, one or more larger values can occur at the start of a
--   measurement spree, and often are in the zone of an L2 miss.
warmup :: Int -> IO ()

-- | tick from a specific <a>Clock</a>
tickWith :: Clock -> (a -> b) -> a -> IO (Nanos, b)

-- | <i>tick f a</i>
--   
--   <ul>
--   <li>strictly evaluates f and a to WHNF</li>
--   <li>reads the clock</li>
--   <li>strictly evaluates f a to WHNF</li>
--   <li>reads the clock</li>
--   <li>returns (nanos, f a)</li>
--   </ul>
tick :: (a -> b) -> a -> IO (Nanos, b)

-- | <i>tickWHNF f a</i>
--   
--   <ul>
--   <li>reads the clock</li>
--   <li>strictly evaluates f a to WHNF (this may also kick off thunk
--   evaluation in f or a which will also be captured in the cycle
--   count)</li>
--   <li>reads the clock</li>
--   <li>returns (nanos, f a)</li>
--   </ul>
tickWHNF :: (a -> b) -> a -> IO (Nanos, b)

-- | <i>tickLazy f a</i>
--   
--   <ul>
--   <li>reads the clock</li>
--   <li>lazily evaluates f a</li>
--   <li>reads the clock</li>
--   <li>returns (nanos, f a)</li>
--   </ul>
tickLazy :: (a -> b) -> a -> IO (Nanos, b)

-- | <i>tickForce f a</i>
--   
--   <ul>
--   <li>deeply evaluates f and a,</li>
--   <li>reads the clock</li>
--   <li>deeply evaluates f a</li>
--   <li>reads the clock</li>
--   <li>returns (nanos, f a)</li>
--   </ul>
tickForce :: (NFData a, NFData b) => (a -> b) -> a -> IO (Nanos, b)

-- | <i>tickForceArgs f a</i>
--   
--   <ul>
--   <li>deeply evaluates f and a,</li>
--   <li>reads the clock</li>
--   <li>strictly evaluates f a to WHNF</li>
--   <li>reads the clock</li>
--   <li>returns (nanos, f a)</li>
--   </ul>
tickForceArgs :: NFData a => (a -> b) -> a -> IO (Nanos, b)

-- | measures an <i>IO a</i>
tickIO :: IO a -> IO (Nanos, a)

-- | n measurements of a tick
--   
--   returns a list of Nanos and the last evaluated f a
ticks :: Int -> (a -> b) -> a -> IO ([Nanos], b)

-- | n measurements of a tickIO
--   
--   returns an IO tuple; list of Nanos and the last evaluated f a
ticksIO :: Int -> IO a -> IO ([Nanos], a)

-- | tick as a <a>Measure</a>
time :: Measure IO Nanos

-- | tick as a multi-Measure
times :: Int -> Measure IO [Nanos]

-- | tickWith as a multi-Measure
timesWith :: Clock -> Int -> Measure IO [Nanos]

-- | tick as a <a>StepMeasure</a>
stepTime :: StepMeasure IO Nanos


-- | Space performance measurement.
module Perf.Space

-- | GHC allocation statistics.
data SpaceStats
SpaceStats :: Word64 -> Word32 -> Word64 -> Word64 -> Word64 -> SpaceStats
[allocatedBytes] :: SpaceStats -> Word64
[gcollects] :: SpaceStats -> Word32
[maxLiveBytes] :: SpaceStats -> Word64
[gcLiveBytes] :: SpaceStats -> Word64
[maxMem] :: SpaceStats -> Word64

-- | Convert <a>SpaceStats</a> to a list of numbers.
ssToList :: Num a => SpaceStats -> [a]

-- | Labels for <a>SpaceStats</a>.
spaceLabels :: [Text]

-- | A allocation <a>StepMeasure</a> with a flag to determine if
--   <a>performGC</a> should run prior to the measurement.
space :: Bool -> StepMeasure IO SpaceStats

-- | Measure memory allocation, with a flag to run <a>performGC</a> prior
--   to the measurement.
allocation :: Bool -> StepMeasure IO Bytes

-- | Number of bytes
newtype Bytes
Bytes :: Word64 -> Bytes
[unbytes] :: Bytes -> Word64
instance GHC.Classes.Eq Perf.Space.SpaceStats
instance GHC.Show.Show Perf.Space.SpaceStats
instance GHC.Read.Read Perf.Space.SpaceStats
instance GHC.Real.Integral Perf.Space.Bytes
instance GHC.Enum.Enum Perf.Space.Bytes
instance GHC.Real.Real Perf.Space.Bytes
instance GHC.Num.Num Perf.Space.Bytes
instance GHC.Classes.Ord Perf.Space.Bytes
instance GHC.Classes.Eq Perf.Space.Bytes
instance GHC.Read.Read Perf.Space.Bytes
instance GHC.Show.Show Perf.Space.Bytes
instance GHC.Base.Semigroup Perf.Space.Bytes
instance GHC.Base.Monoid Perf.Space.Bytes
instance GHC.Base.Semigroup Perf.Space.SpaceStats
instance GHC.Base.Monoid Perf.Space.SpaceStats
instance GHC.Num.Num Perf.Space.SpaceStats


-- | Simple counter.
module Perf.Count

-- | Register 1 as a performance measure
count :: Applicative m => StepMeasure m Int

-- | Count the number of times measured.
countN :: Int -> Measure IO Int


-- | Unification of the various different performance measure types, mostly
--   to unify reporting and data management.
module Perf.Measure

-- | Command-line measurement options.
data MeasureType
MeasureTime :: MeasureType
MeasureSpace :: MeasureType
MeasureSpaceTime :: MeasureType
MeasureAllocation :: MeasureType
MeasureCount :: MeasureType

-- | Parse command-line <a>MeasureType</a> options.
parseMeasure :: Parser MeasureType

-- | unification of the different measurements to being a list of doubles.
measureDs :: MeasureType -> Clock -> Int -> Measure IO [[Double]]

-- | unification of the different measurements to being a list of doubles.
measureLabels :: MeasureType -> [Text]

-- | How to fold the list of performance measures.
measureFinalStat :: MeasureType -> [Double] -> Double
instance GHC.Show.Show Perf.Measure.MeasureType
instance GHC.Classes.Eq Perf.Measure.MeasureType


-- | Reporting on performance, potentially checking versus a canned
--   results.
module Perf.Report

-- | Benchmark name
type Name = String

-- | Whether to include header information.
data Header
Header :: Header
NoHeader :: Header

-- | Command-line parser for <a>Header</a>
parseHeader :: Parser Header

-- | Levels of geometric difference in compared performance that triggers
--   reporting.
data CompareLevels
CompareLevels :: Double -> Double -> Double -> CompareLevels
[errorLevel] :: CompareLevels -> Double
[warningLevel] :: CompareLevels -> Double
[improvedLevel] :: CompareLevels -> Double

-- | <pre>
--   &gt;&gt;&gt; defaultCompareLevels
--   CompareLevels {errorLevel = 0.2, warningLevel = 5.0e-2, improvedLevel = 5.0e-2}
--   </pre>
defaultCompareLevels :: CompareLevels

-- | Command-line parser for <a>CompareLevels</a>
parseCompareLevels :: CompareLevels -> Parser CompareLevels

-- | Options for production of a performance report.
data ReportOptions
ReportOptions :: Int -> Clock -> StatDType -> MeasureType -> Golden -> Header -> CompareLevels -> ReportOptions

-- | Number of times to run a benchmark.
[reportN] :: ReportOptions -> Int
[reportClock] :: ReportOptions -> Clock
[reportStatDType] :: ReportOptions -> StatDType
[reportMeasureType] :: ReportOptions -> MeasureType
[reportGolden] :: ReportOptions -> Golden
[reportHeader] :: ReportOptions -> Header
[reportCompare] :: ReportOptions -> CompareLevels

-- | Default options
--   
--   <pre>
--   &gt;&gt;&gt; defaultReportOptions
--   ReportOptions {reportN = 1000, reportClock = MonotonicRaw, reportStatDType = StatAverage, reportMeasureType = MeasureTime, reportGolden = Golden {golden = "other/bench.perf", check = True, record = False}, reportHeader = Header, reportCompare = CompareLevels {errorLevel = 0.2, warningLevel = 5.0e-2, improvedLevel = 5.0e-2}}
--   </pre>
defaultReportOptions :: ReportOptions

-- | Command-line parser for <a>ReportOptions</a>
parseReportOptions :: Parser ReportOptions

-- | Default command-line parser.
infoReportOptions :: ParserInfo ReportOptions

-- | Report results
--   
--   If a goldenFile is checked, and performance has degraded, the function
--   will exit with <a>ExitFailure</a> so that 'cabal bench' and other
--   types of processes can signal performance issues.
report :: ReportOptions -> Map [Text] [Double] -> IO ()

-- | Run and report a benchmark to the console. For example,
--   
--   <tt>reportMain "foo" (fap "sum" sum [1..1000])</tt> would:
--   
--   <ul>
--   <li>run a benchmark for summing the numbers 1 to a thousand.</li>
--   <li>look for saved performance data in
--   other/foo-1000-MeasureTime-StatAverage.perf</li>
--   <li>report on performance in isolation or versus the canned data file
--   if it exists.</li>
--   <li>exit with failure if the performace had degraded.</li>
--   </ul>
reportMain :: Name -> PerfT IO [[Double]] a -> IO ()

-- | Run and report a benchmark to the console with the supplied options.
reportMainWith :: ReportOptions -> Name -> PerfT IO [[Double]] a -> IO ()

-- | Write results to file
writeResult :: FilePath -> Map [Text] Double -> IO ()

-- | Read results from a file.
readResult :: FilePath -> IO (Either String (Map [Text] Double))

-- | Comparison data between two results.
data CompareResult
CompareResult :: Maybe Double -> Maybe Double -> Text -> CompareResult
[oldResult] :: CompareResult -> Maybe Double
[newResult] :: CompareResult -> Maybe Double
[noteResult] :: CompareResult -> Text

-- | Compare two results and produce some notes given level triggers.
compareNote :: Ord a => CompareLevels -> Map a Double -> Map a Double -> Map a CompareResult

-- | Format a result as a table.
reportOrg2D :: Map [Text] Text -> IO ()

-- | Golden file options.
data Golden
Golden :: FilePath -> Bool -> Bool -> Golden
[golden] :: Golden -> FilePath
[check] :: Golden -> Bool
[record] :: Golden -> Bool

-- | Default filepath is "other/bench.perf"
defaultGolden :: Golden

-- | Parse command-line golden file options.
parseGolden :: Parser Golden

-- | Replace the Golden file path with the suggested stem, but only if the
--   user did not specify a specific file path at the command line.
replaceDefaultFilePath :: FilePath -> ReportOptions -> ReportOptions
instance GHC.Generics.Generic Perf.Report.Header
instance GHC.Show.Show Perf.Report.Header
instance GHC.Classes.Eq Perf.Report.Header
instance GHC.Show.Show Perf.Report.CompareLevels
instance GHC.Classes.Eq Perf.Report.CompareLevels
instance GHC.Classes.Eq Perf.Report.CompareResult
instance GHC.Show.Show Perf.Report.CompareResult
instance GHC.Show.Show Perf.Report.Golden
instance GHC.Classes.Eq Perf.Report.Golden
instance GHC.Generics.Generic Perf.Report.Golden
instance GHC.Generics.Generic Perf.Report.ReportOptions
instance GHC.Show.Show Perf.Report.ReportOptions
instance GHC.Classes.Eq Perf.Report.ReportOptions


-- | <a>Order of complexity</a>) calculations.
module Perf.BigO

-- | order type
data O

-- | cubic
N3 :: O

-- | quadratic
N2 :: O

-- | ^3/2
N32 :: O

-- | N * log N
NLogN :: O

-- | linear
N1 :: O

-- | sqrt N
N12 :: O

-- | log N
LogN :: O

-- | constant
N0 :: O

-- | enumeration of O types
--   
--   <pre>
--   &gt;&gt;&gt; olist
--   [N3,N2,N32,NLogN,N1,N12,LogN,N0]
--   </pre>
olist :: [O]

-- | Calculate the expected performance measure
--   
--   <pre>
--   &gt;&gt;&gt; promote (order N2 1) 10
--   100.0
--   </pre>
promote :: Order Double -> Double -> Double

-- | Calculate the expected performance measure per n
--   
--   <pre>
--   &gt;&gt;&gt; promote (order N2 1) 10
--   100.0
--   </pre>
promote1 :: Order Double -> Double

-- | functions to compute performance measure
--   
--   <pre>
--   &gt;&gt;&gt; fmap ($ 0) promote_
--   [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; fmap ($ 1) promote_
--   [1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0]
--   </pre>
--   
--   Ordering makes sense around N=10
--   
--   <pre>
--   &gt;&gt;&gt; fmap ($ 10) promote_
--   [1000.0,100.0,31.622776601683793,23.02585092994046,10.0,3.1622776601683795,2.302585092994046,1.0]
--   </pre>
--   
--   Having NP may cause big num problems
--   
--   <pre>
--   &gt;&gt;&gt; fmap ($ 1000) promote_
--   [1.0e9,1000000.0,31622.776601683792,6907.755278982137,1000.0,31.622776601683793,6.907755278982137,1.0]
--   </pre>
promote_ :: [Double -> Double]

-- | Calculate an Order from a given O, an n, and a total performance
--   measurement
--   
--   A measurement of 1e6 for n=1000 with an order of N2 is:
--   
--   <pre>
--   &gt;&gt;&gt; demote N2 1000 1000000
--   Order {factors = [0.0,1.0,0.0,0.0,0.0,0.0,0.0,0.0]}
--   </pre>
--   
--   <pre>
--   promote (demote N2 n m) n m == m
--   </pre>
demote :: O -> Double -> Double -> Order Double

-- | Calculate an Order from a measure, and an O
--   
--   <pre>
--   &gt;&gt;&gt; demote1 N2 1000
--   Order {factors = [0.0,1000.0,0.0,0.0,0.0,0.0,0.0,0.0]}
--   </pre>
--   
--   <pre>
--   demote1 N2 m == demote o 1 m
--   </pre>
demote1 :: O -> Double -> Order Double

-- | The factor for each O given an n, and a measurement.
--   
--   <pre>
--   &gt;&gt;&gt; spectrum 100 10000
--   Order {factors = [1.0e-2,1.0,10.0,21.71472409516259,100.0,1000.0,2171.4724095162587,10000.0]}
--   </pre>
spectrum :: Double -> Double -> Order Double

-- | a set of factors for each order, which represents a full Order
--   specification.
newtype Order a
Order :: [a] -> Order a
[factors] :: Order a -> [a]

-- | find the dominant order, and it's factor
--   
--   <pre>
--   &gt;&gt;&gt; bigO o
--   (N2,1.0)
--   </pre>
bigO :: (Ord a, Num a) => Order a -> (O, a)

-- | compute the runtime component of an Order, defined as the difference
--   between the dominant order and the total for a single run.
--   
--   <pre>
--   &gt;&gt;&gt; runtime o
--   100.0
--   </pre>
runtime :: Order Double -> Double

-- | A set of factors consisting of the dominant order, the dominant order
--   factor and a constant factor
data BigOrder a
BigOrder :: O -> a -> a -> BigOrder a
[bigOrder] :: BigOrder a -> O
[bigFactor] :: BigOrder a -> a
[bigConstant] :: BigOrder a -> a

-- | compute the BigOrder
--   
--   <pre>
--   &gt;&gt;&gt; fromOrder o
--   BigOrder {bigOrder = N2, bigFactor = 1.0, bigConstant = 100.0}
--   </pre>
fromOrder :: Order Double -> BigOrder Double

-- | convert a BigOrder to an Order.
--   
--   toOrder . fromOrder is not a round trip iso.
--   
--   <pre>
--   &gt;&gt;&gt; toOrder (fromOrder o)
--   Order {factors = [0.0,1.0,0.0,0.0,0.0,0.0,0.0,100.0]}
--   </pre>
toOrder :: BigOrder Double -> Order Double

-- | create an Order
--   
--   <pre>
--   &gt;&gt;&gt; order N2 1
--   Order {factors = [0,1,0,0,0,0,0,0]}
--   </pre>
order :: Num a => O -> a -> Order a

-- | performance curve for a Measure.
mcurve :: Semigroup a => Measure IO a -> (Int -> b) -> [Int] -> IO [a]

-- | repetitive Double Meaure performance curve.
dcurve :: (Int -> Measure IO [Double]) -> StatDType -> Int -> (Int -> a) -> [Int] -> IO [Double]

-- | time performance curve.
tcurve :: StatDType -> Int -> (Int -> a) -> [Int] -> IO [Double]

-- | The errors for a list of n's and measurements, based on the spectrum
--   of the last measurement.
diffs :: [Double] -> [Double] -> [[Double]]

-- | minimum error order for a list of measurements
--   
--   <pre>
--   &gt;&gt;&gt; bestO ns ms
--   N1
--   </pre>
bestO :: [Double] -> [Double] -> O

-- | fit the best order for the last measurement and return it, and the
--   error terms for the measurements
--   
--   <pre>
--   &gt;&gt;&gt; estO ns ms
--   (Order {factors = [0.0,0.0,0.0,0.0,102.90746947660953,0.0,0.0,0.0]},[2702.0925305233905,2446.9253052339045,-301.7469476609531,-10317.469476609534,0.0])
--   </pre>
estO :: [Double] -> [Double] -> (Order Double, [Double])

-- | fit orders from the last measurement to the first, using the residuals
--   at each step.
--   
--   <pre>
--   &gt;&gt;&gt; estOs ns ms
--   [Order {factors = [0.0,0.0,0.0,0.0,102.90746947660953,0.0,0.0,0.0]},Order {factors = [0.0,0.0,-0.32626703235351473,0.0,0.0,0.0,0.0,0.0]},Order {factors = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,24.520084692561625]},Order {factors = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,2432.722690017952]},Order {factors = [0.0,0.0,0.0,0.0,0.0,0.0,0.0,245.1760228452299]}]
--   </pre>
estOs :: [Double] -> [Double] -> [Order Double]

-- | BigOrder estimate
--   
--   <pre>
--   estOrder (\x -&gt; sum [1..x]) 100 [1,10,100,1000,10000]
--   BigOrder {bigOrder = N1, bigFactor = 76.27652961460446, bigConstant = 0.0}
--   </pre>
--   
--   <pre>
--   estOrder (\x -&gt; sum $ nub [1..x]) 100 [1,10,100,1000]
--   BigOrder {bigOrder = N2, bigFactor = 13.485763594353541, bigConstant = 0.0}
--   </pre>
estOrder :: (Int -> b) -> Int -> [Int] -> IO (BigOrder Double)
instance GHC.Enum.Enum Perf.BigO.O
instance GHC.Generics.Generic Perf.BigO.O
instance GHC.Show.Show Perf.BigO.O
instance GHC.Classes.Ord Perf.BigO.O
instance GHC.Classes.Eq Perf.BigO.O
instance GHC.Base.Functor Perf.BigO.Order
instance GHC.Generics.Generic (Perf.BigO.Order a)
instance GHC.Show.Show a => GHC.Show.Show (Perf.BigO.Order a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Perf.BigO.Order a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Perf.BigO.Order a)
instance GHC.Base.Functor Perf.BigO.BigOrder
instance GHC.Generics.Generic (Perf.BigO.BigOrder a)
instance GHC.Show.Show a => GHC.Show.Show (Perf.BigO.BigOrder a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Perf.BigO.BigOrder a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Perf.BigO.BigOrder a)
instance GHC.Num.Num a => GHC.Num.Num (Perf.BigO.Order a)


-- | Algorithms and functions for testing purposes
module Perf.Algos

-- | Algorithm examples for testing
data Example
ExampleSumFuse :: Example
ExampleSum :: Example
ExampleLengthF :: Example
ExampleConstFuse :: Example
ExampleMapInc :: Example
ExampleNoOp :: Example

-- | All the example algorithms.
allExamples :: [Example]

-- | Parse command-line options for algorithm examples.
parseExample :: Parser Example

-- | Unification of example function applications
data ExamplePattern a
PatternSumFuse :: Text -> (Num a => a -> a) -> a -> ExamplePattern a
PatternSum :: Text -> (Num a => [a] -> a) -> [a] -> ExamplePattern a
PatternLengthF :: Text -> ([a] -> Int) -> [a] -> ExamplePattern a
PatternConstFuse :: Text -> (Int -> ()) -> Int -> ExamplePattern a
PatternMapInc :: Text -> ([Int] -> [Int]) -> [Int] -> ExamplePattern a
PatternNoOp :: Text -> (() -> ()) -> () -> ExamplePattern a

-- | Convert an <a>Example</a> to an <a>ExamplePattern</a>.
examplePattern :: Example -> Int -> ExamplePattern Int

-- | Labels
exampleLabel :: ExamplePattern a -> Text

-- | Convert an <a>ExamplePattern</a> to a <a>PerfT</a>.
testExample :: (Semigroup a, MonadIO m) => ExamplePattern Int -> PerfT m a ()

-- | run an example measurement.
statExamples :: (Semigroup a, MonadIO m) => Int -> PerfT m a ()

-- | Unification of sum function applications
data SumPattern a
SumFuse :: Text -> (Int -> Int) -> Int -> SumPattern a
SumFusePoly :: Text -> ((Enum a, Num a) => a -> a) -> a -> SumPattern a
SumPoly :: Text -> (Num a => [a] -> a) -> [a] -> SumPattern a
SumMono :: Text -> ([Int] -> Int) -> [Int] -> SumPattern a

-- | All the sum algorithms.
allSums :: Int -> [SumPattern Int]

-- | Convert an <a>SumPattern</a> to a <a>PerfT</a>.
testSum :: (Semigroup a, MonadIO m) => SumPattern Int -> PerfT m a Int

-- | Run a sum algorithm measurement.
statSums :: MonadIO m => Int -> Int -> (Int -> Measure m [a]) -> m (Map Text [a])

-- | tail resursive
sumTail :: Num a => [a] -> a

-- | lazy recursion.
sumTailLazy :: Num a => [a] -> a

-- | With argument order flipped
sumFlip :: Num a => [a] -> a

-- | Lazy with argument order flipped.
sumFlipLazy :: Num a => [a] -> a

-- | Co-routine style
sumCo :: Num a => [a] -> a

-- | Co-routine, go style
sumCoGo :: Num a => [a] -> a

-- | Co-routine, case-style
sumCoCase :: Num a => [a] -> a

-- | Auxillary style.
sumAux :: Num a => [a] -> a

-- | foldr style
sumFoldr :: Num a => [a] -> a

-- | cata style
sumCata :: Num a => [a] -> a

-- | sum
sumSum :: Num a => [a] -> a

-- | Monomorphic sum
sumMono :: [Int] -> Int

-- | Polymorphic sum
sumPoly :: Num a => [a] -> a

-- | Lambda-style sum
sumLambda :: Num a => [a] -> a

-- | GHC-style foldr method.
sumF :: Num a => [a] -> a

-- | Fusion check
sumFuse :: Int -> Int

-- | Fusion under polymorph
sumFusePoly :: (Enum a, Num a) => a -> a

-- | foldl' fusion
sumFuseFoldl' :: Int -> Int

-- | foldr fusion
sumFuseFoldr :: Int -> Int

-- | Unification of length function applications
data LengthPattern a
LengthPoly :: Text -> ([a] -> Int) -> [a] -> LengthPattern a
LengthMono :: Text -> ([Int] -> Int) -> [Int] -> LengthPattern a

-- | All the length algorithms.
allLengths :: Int -> [LengthPattern Int]

-- | Convert an <a>LengthPattern</a> to a <a>PerfT</a>.
testLength :: (Semigroup a, MonadIO m) => LengthPattern Int -> PerfT m a Int

-- | Run a lengths algorithm
statLengths :: MonadIO m => Int -> Int -> (Int -> Measure m [a]) -> m (Map Text [a])

-- | tail resursive
lengthTail :: [a] -> Int

-- | lazy recursion.
lengthTailLazy :: [a] -> Int

-- | With argument order flipped
lengthFlip :: [a] -> Int

-- | Lazy with argument order flipped.
lengthFlipLazy :: [a] -> Int

-- | Co-routine style
lengthCo :: [a] -> Int

-- | Co-routine style as a Case statement.
lengthCoCase :: [a] -> Int

-- | Auxillary version.
lengthAux :: [a] -> Int

-- | foldr style
lengthFoldr :: [a] -> Int

-- | foldr style with explicit const usage.
lengthFoldrConst :: [a] -> Int

-- | GHC style
lengthF :: [a] -> Int

-- | Monomorphic, GHC style
lengthFMono :: [Int] -> Int

-- | Tail recursion
recurseTail :: (a -> b -> b) -> b -> [a] -> b

-- | Lazy tail recursion
recurseTailLazy :: (a -> b -> b) -> b -> [a] -> b

-- | Tail resursion with flipped argument order.
recurseFlip :: (a -> b -> b) -> b -> [a] -> b

-- | Lazy tail resursion with flipped argument order.
recurseFlipLazy :: (a -> b -> b) -> b -> [a] -> b

-- | Coroutine
recurseCo :: (a -> b -> b) -> b -> [a] -> b

-- | Lazy, coroutine
recurseCoLazy :: (a -> b -> b) -> b -> [a] -> b

-- | Cata style
recurseCata :: (a -> b -> b) -> b -> [a] -> b

-- | Increment a list.
mapInc :: [Int] -> [Int]

-- | Test of const fusion
constFuse :: Int -> ()

-- | Split a list.
splitHalf :: [a] -> ([a], [a])
instance GHC.Show.Show Perf.Algos.Example
instance GHC.Classes.Eq Perf.Algos.Example


-- | <h2>Introduction</h2>
--   
--   <tt>perf</tt> provides tools for measuring the runtime performance of
--   Haskell functions. It includes:
--   
--   <ul>
--   <li>time measurement via the <a>clock</a> library.</li>
--   <li>a polymorphic approach to what a <a>Measure</a> is so that a wide
--   variety of measurements such as counting, space and time measurement
--   can share the same API.</li>
--   <li><a>PerfT</a> which is a monad transformer designed to add the
--   collection of performance information to existing code. Running the
--   code produces a tuple of the original computation results, and a Map
--   of performance measurements that were specified.</li>
--   <li>functionality to determine performance order, in <a>BigO</a></li>
--   <li>reporting functionality encapsulated in <a>Report</a>.
--   <tt>perf</tt> can be run via 'cabal bench' and will, for example,
--   error on performance degradation; see the project's cabal file for an
--   example.</li>
--   </ul>
module Perf