Designing elm-lang/benchmark

Benchmark (slash) LowLevel.elm

module Benchmark.LowLevel
    exposing
        ( Error(..)
        , measure
        , measure1
        , measure2
        , measure3
        , measure4
        , measure5
        , measure6
        , measure7
        , measure8
        )

{-| Elm Benchmarking
@docs Error, measure, measure1, measure2, measure3, measure4, measure5, measure6, measure7, measure8
-}

import Time exposing (Time)
import Task exposing (Task)
import Native.Benchmark


{-| -}
type Error
    = StackOverflow
    | UnknownError String


{-| -}
measure :
    (() -> a)
    -> Task Error (Time, a)
measure =
    Native.Benchmark.measure


{-| -}
measure1 :
    (a -> b)
    -> a
    -> Task Error (Time, b)
measure1 =
    Native.Benchmark.measure1


{-| -}
measure2 :
    (a -> b -> c)
    -> a
    -> b
    -> Task Error (Time, c)
measure2 =
    Native.Benchmark.measure2


{-| -}
measure3 :
    (a -> b -> c -> d)
    -> a
    -> b
    -> c
    -> Task Error (Time, d)
measure3 =
    Native.Benchmark.measure3


{-| -}
measure4 :
    (a -> b -> c -> d -> e)
    -> a
    -> b
    -> c
    -> d
    -> Task Error (Time, e)
measure4 =
    Native.Benchmark.measure4


{-| -}
measure5 :
    (a -> b -> c -> d -> e -> f)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> Task Error (Time, f)
measure5 =
    Native.Benchmark.measure5


{-| -}
measure6 :
    (a -> b -> c -> d -> e -> f -> g)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> Task Error (Time, g)
measure6 =
    Native.Benchmark.measure6


{-| -}
measure7 :
    (a -> b -> c -> d -> e -> f -> g -> h)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> Task Error (Time, h)
measure7 =
    Native.Benchmark.measure7


{-| -}
measure8 :
    (a -> b -> c -> d -> e -> f -> g -> h -> i)
    -> a
    -> b
    -> c
    -> d
    -> e
    -> f
    -> g
    -> h
    -> Task Error (Time, i)
measure8 =
    Native.Benchmark.measure8

Native (slash) Benchmark.js

var _elm_lang$benchmark$Native_Benchmark = function () {

var getTimestamp = typeof performance !== 'undefined' ?
  performance.now.bind(performance) :
  Date.now;

function determineError(error)
{
  var elmError;

  if (error instanceof RangeError)
  {
    elmError = { ctor: 'StackOverflow' };
  }
  else
  {
    elmError = { ctor: 'UnknownError', _0: error.message };
  }

  return _elm_lang$core$Native_Scheduler.fail(elmError);
}

function timingToTask(startTime, endTime, result)
{
  var output = _elm_lang$core$Native_Utils.Tuple2(endTime - startTime, result);
  return _elm_lang$core$Native_Scheduler.succeed(output);
}

function runAndHandleErrors(toRun)
{
  return _elm_lang$core$Native_Scheduler.nativeBinding(function(callback)
  {
    try
    {
      callback(toRun());
    }
    catch (error)
    {
      callback(determineError(error));
    }
}


/**
 * measure : (() -> a) -> Task Benchmark.Error (Time, a)
 */
function measure(thunk)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = fn();
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure1 : (a -> b) -> a -> Task Benchmark.Error (Time, b)
 */
function measure1(fn, a)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = fn(a);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure2 : (a -> b -> c) -> a -> b -> Task Benchmark.Error (Time, c)
 */
function measure2(fn, a, b)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = A2(fn, a, b);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure3 : (a -> b -> c -> d) -> a -> b -> c -> Task Benchmark.Error (Time, d)
 */
function measure3(fn, a, b, c)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = A3(fn, a, b, c);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure4 : (a -> b -> c -> d -> e) -> a -> b -> c -> d -> Task Benchmark.Error (Time, e)
 */
function measure4(fn, a, b, c, d)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = A4(fn, a, b, c, d);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure5 : (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> Task Benchmark.Error (Time, f)
 */
function measure5(fn, a, b, c, d, e)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = A5(fn, a, b, c, d, e);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure6 : (a -> b -> c -> d -> e -> f -> g) -> a -> b -> c -> d -> e -> f -> Task Benchmark.Error (Time, g)
 */
function measure6(fn, a, b, c, d, e, f)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = A6(fn, a, b, c, d, e, f);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure7 : (a -> b -> c -> d -> e -> f -> g -> h) -> a -> b -> c -> -> d -> e -> f -> g -> Task Benchmark.Error (Time, h)
 */
function measure7(fn, a, b, c, d, e, f, g)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = A7(fn, a, b, c, d, e, f, g);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

/**
 * measure8 : (a -> b -> c -> d -> e -> f -> g -> h -> i) -> a -> b -> c -> d -> e -> f -> g -> h -> Task Benchmark.Error (Time, i)
 */
function measure8(fn, a, b, c, d, e, f, g, h)
{
  return runAndHandleErrors(function ()
  {
    var startTime = getTimestamp();
    var result = A8(fn, a, b, c, d, e, f, g, h);
    var endTime = getTimestamp();
    return timingToTask(startTime, endTime, result);
  });
}

return {
  measure: measure,
  measure1: F2(measure1),
  measure2: F3(measure2),
  measure3: F4(measure3),
  measure4: F5(measure4),
  measure5: F6(measure5),
  measure6: F7(measure6),
  measure7: F8(measure7),
  measure8: F9(measure8)
};

}();