Replace criterion with gauge (#1035)

This reduces build times for the benchmarks.

dhall/benchmark/deep-nested-large-record/Main.hs

@@ -1,13 +1,13 @@
 {-# LANGUAGE OverloadedStrings #-}
 module Main (main) where
 
-import Criterion.Main (defaultMain)
+import Gauge(defaultMain)
 
-import qualified Criterion as Criterion
 import qualified Data.Sequence as Seq
 import qualified Dhall.Core as Core
 import qualified Dhall.Import as Import
 import qualified Dhall.TypeCheck as TypeCheck
+import qualified Gauge
 
 dhallPreludeImport :: Core.Import
 dhallPreludeImport = Core.Import
@@ -21,8 +21,8 @@ dhallPreludeImport = Core.Import
     }
   }
 
-issue412 :: Core.Expr s TypeCheck.X -> Criterion.Benchmarkable
-issue412 prelude = Criterion.whnf TypeCheck.typeOf expr
+issue412 :: Core.Expr s TypeCheck.X -> Gauge.Benchmarkable
+issue412 prelude = Gauge.whnf TypeCheck.typeOf expr
   where
     expr
       = Core.Let (pure (Core.Binding "prelude" Nothing prelude))
@@ -30,8 +30,8 @@ issue412 prelude = Criterion.whnf TypeCheck.typeOf expr
       $ Seq.replicate 5
       $ Core.Var (Core.V "prelude" 0) `Core.Field` "types" `Core.Field` "Little" `Core.Field` "Foo"
 
-unionPerformance :: Core.Expr s TypeCheck.X -> Criterion.Benchmarkable
-unionPerformance prelude = Criterion.whnf TypeCheck.typeOf expr
+unionPerformance :: Core.Expr s TypeCheck.X -> Gauge.Benchmarkable
+unionPerformance prelude = Gauge.whnf TypeCheck.typeOf expr
   where
     innerBinding =
         Core.Binding "big" Nothing
@@ -47,6 +47,6 @@ main :: IO ()
 main = do
   prelude <- Import.load (Core.Embed dhallPreludeImport)
   defaultMain
-    [ Criterion.bench "issue 412" (issue412 prelude)
-    , Criterion.bench "union performance" (unionPerformance prelude)
+    [ Gauge.bench "issue 412" (issue412 prelude)
+    , Gauge.bench "union performance" (unionPerformance prelude)
     ]

dhall/benchmark/map/Main.hs

@@ -3,22 +3,22 @@
 
 module Main where
 
-import Criterion.Main (defaultMain, bgroup, bench, whnf, nfIO)
+import Gauge (defaultMain, bgroup, bench, whnf, nfIO)
 
-import qualified Criterion.Main as Criterion
+import qualified Gauge
 import qualified Dhall.Map as Map
 
 testData :: Integer -> Map.Map Integer Integer
 testData i = foldr (\j -> Map.insert j j) mempty [1 .. i]
 
-benchOrderedTraversal :: String -> Map.Map Integer Integer -> Criterion.Benchmark
+benchOrderedTraversal :: String -> Map.Map Integer Integer -> Gauge.Benchmark
 benchOrderedTraversal dataLabel mapData =
     bgroup ("Ordered Traversals: " <> dataLabel)
         [ bench "traverseWithKey" $
             whnf (Map.traverseWithKey (\_ i -> pure @Maybe $ i ^ i)) mapData
         ]
 
-benchUnorderedTraversal :: String -> Map.Map Integer Integer -> Criterion.Benchmark
+benchUnorderedTraversal :: String -> Map.Map Integer Integer -> Gauge.Benchmark
 benchUnorderedTraversal dataLabel mapData =
     bgroup ("Unordered Traversals: " <> dataLabel)
         [ bench "unorderedTraverseWithKey_" $

dhall/benchmark/parser/Main.hs

@@ -4,14 +4,14 @@
 module Main where
 
 import Control.Monad (forM)
-import Criterion.Main (defaultMain, bgroup, bench, whnf, nfIO)
 import Data.Map (Map, foldrWithKey, singleton, unions)
 import Data.Monoid ((<>))
+import Gauge (defaultMain, bgroup, bench, whnf, nfIO)
 
 import System.Directory
 
 import qualified Codec.Serialise
-import qualified Criterion.Main as Criterion
+import qualified Gauge
 import qualified Data.ByteString.Lazy
 import qualified Data.Text as T
 import qualified Data.Text.IO as TIO
@@ -55,17 +55,17 @@ loadPreludeFiles = loadDirectory "Prelude"
         loadFile :: FilePath -> IO PreludeFiles
         loadFile path = singleton path <$> TIO.readFile path
 
-benchParser :: PreludeFiles -> Criterion.Benchmark
+benchParser :: PreludeFiles -> Gauge.Benchmark
 benchParser =
       bgroup "exprFromText"
     . foldrWithKey (\name expr -> (benchExprFromText name expr :)) []
 
-benchExprFromText :: String -> T.Text -> Criterion.Benchmark
+benchExprFromText :: String -> T.Text -> Gauge.Benchmark
 benchExprFromText name expr =
     bench name $ whnf (Dhall.exprFromText "(input)") expr
 
 benchExprFromBytes
-    :: String -> Data.ByteString.Lazy.ByteString -> Criterion.Benchmark
+    :: String -> Data.ByteString.Lazy.ByteString -> Gauge.Benchmark
 benchExprFromBytes name bytes = bench name (whnf f bytes)
   where
     f bytes = do

dhall/dhall.cabal

@@ -587,9 +587,9 @@ Benchmark dhall-parser
         base                      >= 4        && < 5  ,
         bytestring                                    ,
         containers                >= 0.5.0.0  && < 0.7,
-        criterion                 >= 1.1      && < 1.6,
         dhall                                         ,
         directory                                     ,
+        gauge                     >= 0.2.4    && < 0.3,
         serialise                                     ,
         text                      >= 0.11.1.0 && < 1.3
     Default-Language: Haskell2010
@@ -604,8 +604,8 @@ Benchmark deep-nested-large-record
     Build-Depends:
         base                      >= 4        && < 5  ,
         containers                >= 0.5.0.0  && < 0.7,
-        criterion                 >= 1.1      && < 1.6,
-        dhall
+        dhall                                         ,
+        gauge                     >= 0.2.4    && < 0.3
     Default-Language: Haskell2010
 
 Benchmark dhall-command
@@ -624,7 +624,7 @@ Benchmark map-operations
     Hs-Source-Dirs: benchmark/map
     Build-Depends:
         base                      >= 4        && < 5  ,
-        criterion                 >= 1.1      && < 1.6,
-        dhall
+        dhall                                         ,
+        gauge                     >= 0.2.4    && < 0.3
     Default-Language: Haskell2010
     ghc-options: -rtsopts -O2