Add flag for benchmarks to select local or external aeson dependency

Author: Lysxia

benchmarks/AesonFoldable.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PackageImports #-}
 
 module Main (main) where
 
@@ -9,8 +8,7 @@ import Prelude ()
 import Prelude.Compat
 
 import Data.Foldable (toList)
-import qualified "aeson" Data.Aeson as A
-import qualified "aeson-benchmarks" Data.Aeson as B
+import qualified Data.Aeson as A
 import qualified Data.Sequence as S
 import qualified Data.Vector as V
 import qualified Data.Vector.Unboxed as U
@@ -21,10 +19,6 @@ import qualified Data.Vector.Unboxed as U
 
 newtype L f = L { getL :: f Int }
 
-instance Foldable f => B.ToJSON (L f) where
-    toJSON = error "do not use this"
-    toEncoding = B.toEncoding . toList . getL
-
 instance Foldable f => A.ToJSON (L f) where
     toJSON = error "do not use this"
     toEncoding = A.toEncoding . toList . getL
@@ -35,10 +29,6 @@ instance Foldable f => A.ToJSON (L f) where
 
 newtype F f = F { getF :: f Int }
 
-instance Foldable f => B.ToJSON (F f) where
-    toJSON = error "do not use this"
-    toEncoding = B.foldable . getF
-
 instance Foldable f => A.ToJSON (F f) where
     toJSON = error "do not use this"
     toEncoding = A.foldable . getF
@@ -63,52 +53,34 @@ valueUVector = U.fromList valueList
 -- Main
 -------------------------------------------------------------------------------
 
-benchEncodeA
+benchEncode
     :: A.ToJSON a
     => String
     -> a
     -> Benchmark
-benchEncodeA name val
+benchEncode name val
     = bench ("A " ++ name) $ nf A.encode val
 
-benchEncodeB
-    :: B.ToJSON a
-    => String
-    -> a
-    -> Benchmark
-benchEncodeB name val
-    = bench ("B " ++ name) $ nf B.encode val
-
 main :: IO ()
 main =  defaultMain
     [ bgroup "encode"
         [ bgroup "List"
-            [ benchEncodeB "-"     valueList
-            , benchEncodeB "L" $ L valueList
-            , benchEncodeB "F" $ F valueList
-            , benchEncodeA "-"     valueList
-            , benchEncodeA "L" $ L valueList
-            , benchEncodeA "F" $ F valueList
+            [ benchEncode "-"     valueList
+            , benchEncode "L" $ L valueList
+            , benchEncode "F" $ F valueList
             ]
         , bgroup "Seq"
-            [ benchEncodeB "-"     valueSeq
-            , benchEncodeB "L" $ L valueSeq
-            , benchEncodeB "F" $ F valueSeq
-            , benchEncodeA "-"     valueSeq
-            , benchEncodeA "L" $ L valueSeq
-            , benchEncodeA "F" $ F valueSeq
+            [ benchEncode "-"     valueSeq
+            , benchEncode "L" $ L valueSeq
+            , benchEncode "F" $ F valueSeq
             ]
         , bgroup "Vector"
-            [ benchEncodeB "-"     valueVector
-            , benchEncodeB "L" $ L valueVector
-            , benchEncodeB "F" $ F valueVector
-            , benchEncodeA "-"     valueVector
-            , benchEncodeA "L" $ L valueVector
-            , benchEncodeA "F" $ F valueVector
+            [ benchEncode "-"     valueVector
+            , benchEncode "L" $ L valueVector
+            , benchEncode "F" $ F valueVector
             ]
         , bgroup "Vector.Unboxed"
-            [ benchEncodeB "-"     valueUVector
-            , benchEncodeA "-"     valueUVector
+            [ benchEncode "-"     valueUVector
             ]
         ]
     ]

benchmarks/AesonMap.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE PackageImports #-}
 {-# LANGUAGE RankNTypes #-}
 
@@ -15,9 +14,8 @@ import Criterion.Main
 import Data.Hashable
 import Data.Proxy (Proxy (..))
 import Data.Tagged (Tagged (..))
-import qualified "aeson" Data.Aeson as A
-import qualified "aeson-benchmarks" Data.Aeson as B
-import qualified "aeson-benchmarks" Data.Aeson.Types as B (fromJSONKeyCoerce)
+import Data.Aeson
+import Data.Aeson.Types (fromJSONKeyCoerce)
 import qualified Data.ByteString.Lazy as LBS
 import qualified Data.HashMap.Strict as HM
 import qualified Data.Map as M
@@ -47,10 +45,10 @@ instance NFData T1 where
 instance Hashable T1 where
     hashWithSalt salt (T1 t) = hashWithSalt salt t
 
-instance B.FromJSON T1 where
-    parseJSON = B.withText "T1" $ pure . T1
-instance B.FromJSONKey T1 where
-    fromJSONKey = B.FromJSONKeyText T1
+instance FromJSON T1 where
+    parseJSON = withText "T1" $ pure . T1
+instance FromJSONKey T1 where
+    fromJSONKey = FromJSONKeyText T1
 
 -------------------------------------------------------------------------------
 -- Coerce
@@ -64,10 +62,10 @@ instance NFData T2 where
 instance Hashable T2 where
     hashWithSalt salt (T2 t) = hashWithSalt salt t
 
-instance B.FromJSON T2 where
-    parseJSON = B.withText "T2" $ pure . T2
-instance B.FromJSONKey T2 where
-    fromJSONKey = B.fromJSONKeyCoerce
+instance FromJSON T2 where
+    parseJSON = withText "T2" $ pure . T2
+instance FromJSONKey T2 where
+    fromJSONKey = fromJSONKeyCoerce
 
 -------------------------------------------------------------------------------
 -- TextParser
@@ -81,10 +79,10 @@ instance NFData T3 where
 instance Hashable T3 where
     hashWithSalt salt (T3 t) = hashWithSalt salt t
 
-instance B.FromJSON T3 where
-    parseJSON = B.withText "T3" $ pure . T3
-instance B.FromJSONKey T3 where
-    fromJSONKey = B.FromJSONKeyTextParser (pure . T3)
+instance FromJSON T3 where
+    parseJSON = withText "T3" $ pure . T3
+instance FromJSONKey T3 where
+    fromJSONKey = FromJSONKeyTextParser (pure . T3)
 
 -------------------------------------------------------------------------------
 -- Values
@@ -97,40 +95,30 @@ value1000 = value 1000
 value10000 = value 10000
 
 encodedValue10 :: LBS.ByteString
-encodedValue10 = B.encode value10
+encodedValue10 = encode value10
 
 encodedValue100 :: LBS.ByteString
-encodedValue100 = B.encode value100
+encodedValue100 = encode value100
 
 encodedValue1000 :: LBS.ByteString
-encodedValue1000 = B.encode value1000
+encodedValue1000 = encode value1000
 
 encodedValue10000 :: LBS.ByteString
-encodedValue10000 = B.encode value10000
+encodedValue10000 = encode value10000
 
 -------------------------------------------------------------------------------
 -- Helpers
 -------------------------------------------------------------------------------
 
-decodeHMB
-    :: (B.FromJSONKey k, Eq k, Hashable k)
+decodeHM
+    :: (FromJSON (HM.HashMap k T.Text), Eq k, Hashable k)
     => Proxy k -> LBS.ByteString -> Maybe (HM.HashMap k T.Text)
-decodeHMB _ = B.decode
+decodeHM _ = decode
 
-decodeHMA
-    :: (A.FromJSON (HM.HashMap k T.Text), Eq k, Hashable k)
-    => Proxy k -> LBS.ByteString -> Maybe (HM.HashMap k T.Text)
-decodeHMA _ = A.decode
-
-decodeMapB
-    :: (B.FromJSONKey k, Ord k)
-    => Proxy k -> LBS.ByteString -> Maybe (M.Map k T.Text)
-decodeMapB _ = B.decode
-
-decodeMapA
-    :: (A.FromJSON (M.Map k T.Text), Ord k)
+decodeMap
+    :: (FromJSON (M.Map k T.Text), Ord k)
     => Proxy k -> LBS.ByteString -> Maybe (M.Map k T.Text)
-decodeMapA _ = A.decode
+decodeMap _ = decode
 
 proxyText :: Proxy T.Text
 proxyText = Proxy
@@ -156,45 +144,41 @@ benchDecodeHM
     -> LBS.ByteString
     -> Benchmark
 benchDecodeHM name val = bgroup name
-    [  bench "Text"            $ nf (decodeHMB proxyText) val
-    ,  bench "Identity"        $ nf (decodeHMB proxyT1)   val
-    ,  bench "Coerce"          $ nf (decodeHMB proxyT2)   val
-    ,  bench "Parser"          $ nf (decodeHMB proxyT3)   val
-    ,  bench "aeson-hackage"   $ nf (decodeHMA proxyText) val
-    ,  bench "Tagged Text"     $ nf (decodeHMB $ proxyTagged proxyText) val
-    ,  bench "Tagged Identity" $ nf (decodeHMB $ proxyTagged proxyT1)   val
-    ,  bench "Tagged Coerce"   $ nf (decodeHMB $ proxyTagged proxyT2)   val
-    ,  bench "Tagged Parser"   $ nf (decodeHMB $ proxyTagged proxyT3)   val
+    [  bench "Text"            $ nf (decodeHM proxyText) val
+    ,  bench "Identity"        $ nf (decodeHM proxyT1)   val
+    ,  bench "Coerce"          $ nf (decodeHM proxyT2)   val
+    ,  bench "Parser"          $ nf (decodeHM proxyT3)   val
+    ,  bench "Tagged Text"     $ nf (decodeHM $ proxyTagged proxyText) val
+    ,  bench "Tagged Identity" $ nf (decodeHM $ proxyTagged proxyT1)   val
+    ,  bench "Tagged Coerce"   $ nf (decodeHM $ proxyTagged proxyT2)   val
+    ,  bench "Tagged Parser"   $ nf (decodeHM $ proxyTagged proxyT3)   val
     ]
 
 benchDecodeMap
     :: String
     -> LBS.ByteString
     -> Benchmark
 benchDecodeMap name val = bgroup name
-    [  bench "Text"           $ nf (decodeMapB proxyText) val
-    ,  bench "Identity"       $ nf (decodeMapB proxyT1)   val
-    ,  bench "Coerce"         $ nf (decodeMapB proxyT2)   val
-    ,  bench "Parser"         $ nf (decodeMapB proxyT3)   val
-    ,  bench "aeson-hackage"  $ nf (decodeMapA proxyText) val
+    [  bench "Text"           $ nf (decodeMap proxyText) val
+    ,  bench "Identity"       $ nf (decodeMap proxyT1)   val
+    ,  bench "Coerce"         $ nf (decodeMap proxyT2)   val
+    ,  bench "Parser"         $ nf (decodeMap proxyT3)   val
     ]
 
 benchEncodeHM
     :: String
     -> HM.HashMap T.Text T.Text
     -> Benchmark
 benchEncodeHM name val = bgroup name
-    [ bench "Text"       $ nf B.encode val
-    , bench "aeson-0.11" $ nf A.encode val
+    [ bench "Text"       $ nf encode val
     ]
 
 benchEncodeMap
     :: String
     -> HM.HashMap T.Text T.Text
     -> Benchmark
 benchEncodeMap name val = bgroup name
-    [ bench "Text"       $ nf B.encode val'
-    , bench "aeson-0.11" $ nf A.encode val'
+    [ bench "Text"       $ nf encode val'
     ]
   where
     val' :: M.Map T.Text T.Text

benchmarks/AesonParse.hs

@@ -1,13 +1,12 @@
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PackageImports #-}
 
 module Main (main) where
 
 import Prelude ()
 import Prelude.Compat
 
-import "aeson-benchmarks" Data.Aeson
+import Data.Aeson
 import Control.Monad
 import Data.Attoparsec.ByteString (IResult(..), parseWith)
 import Data.Time.Clock

benchmarks/Compare.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE PackageImports #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 
 module Main (main) where
@@ -14,7 +13,7 @@ import Data.Json.Builder
 import Twitter
 import Twitter.Manual ()
 import Typed.Common
-import qualified "aeson-benchmarks" Data.Aeson as Aeson
+import qualified Data.Aeson as Aeson
 import qualified Compare.JsonBench as JsonBench
 
 main :: IO ()

benchmarks/CompareWithJSON.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE PackageImports #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
 module Main (main) where
@@ -11,10 +10,9 @@ import Blaze.ByteString.Builder.Char.Utf8 (fromString)
 import Control.DeepSeq (NFData(rnf))
 import Criterion.Main
 import Data.Maybe (fromMaybe)
-import qualified "aeson-benchmarks" Data.Aeson as A
-import qualified "aeson-benchmarks" Data.Aeson.Text as A
-import qualified "aeson-benchmarks" Data.Aeson.Parser.Internal as I
-import qualified "aeson" Data.Aeson as B
+import qualified Data.Aeson as A
+import qualified Data.Aeson.Text as A
+import qualified Data.Aeson.Parser.Internal as I
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.Lazy as BL
 import qualified Data.Text.Lazy          as TL
@@ -39,20 +37,14 @@ decodeJ s =
     J.Ok v -> v
     J.Error _ -> error "fail to parse via JSON"
 
-decodeA :: BL.ByteString -> A.Value
-decodeA s = fromMaybe (error "fail to parse via Aeson") $ A.decode s
+decode :: BL.ByteString -> A.Value
+decode s = fromMaybe (error "fail to parse via Aeson") $ A.decode s
 
-decodeA' :: BL.ByteString -> A.Value
-decodeA' s = fromMaybe (error "fail to parse via Aeson") $ A.decode' s
+decode' :: BL.ByteString -> A.Value
+decode' s = fromMaybe (error "fail to parse via Aeson") $ A.decode' s
 
-decodeAS :: BS.ByteString -> A.Value
-decodeAS s = fromMaybe (error "fail to parse via Aeson") $ A.decodeStrict' s
-
-decodeB :: BL.ByteString -> B.Value
-decodeB s = fromMaybe (error "fail to parse via Aeson") $ B.decode s
-
-decodeBS :: BS.ByteString -> B.Value
-decodeBS s = fromMaybe (error "fail to parse via Aeson") $ B.decodeStrict' s
+decodeS :: BS.ByteString -> A.Value
+decodeS s = fromMaybe (error "fail to parse via Aeson") $ A.decodeStrict' s
 
 decodeIP :: BL.ByteString -> A.Value
 decodeIP s = fromMaybe (error "fail to parse via Parser.decodeWith") $
@@ -80,32 +72,29 @@ main = do
   defaultMain [
       bgroup "decode" [
         bgroup "en" [
-          bench "aeson/lazy"     $ nf decodeA enA
-        , bench "aeson/strict"   $ nf decodeA' enA
-        , bench "aeson/stricter" $ nf decodeAS enS
-        , bench "aeson/hackage"  $ nf decodeB enA
-        , bench "aeson/hackage'" $ nf decodeBS enS
+          bench "aeson/lazy"     $ nf decode enA
+        , bench "aeson/strict"   $ nf decode' enA
+        , bench "aeson/stricter" $ nf decodeS enS
         , bench "aeson/parser"   $ nf decodeIP enA
         , bench "json"           $ nf decodeJ enJ
         ]
       , bgroup "jp" [
-          bench "aeson"          $ nf decodeA jpA
-        , bench "aeson/stricter" $ nf decodeAS jpS
-        , bench "aeson/hackage"  $ nf decodeB jpA
+          bench "aeson"          $ nf decode jpA
+        , bench "aeson/stricter" $ nf decodeS jpS
         , bench "json"           $ nf decodeJ jpJ
         ]
       ]
     , bgroup "encode" [
         bgroup "en" [
-          bench "aeson-to-bytestring" $ nf A.encode (decodeA enA)
-        , bench "aeson-via-text-to-bytestring" $ nf encodeViaText (decodeA enA)
-        , bench "aeson-to-text" $ nf encodeToText (decodeA enA)
+          bench "aeson-to-bytestring" $ nf A.encode (decode enA)
+        , bench "aeson-via-text-to-bytestring" $ nf encodeViaText (decode enA)
+        , bench "aeson-to-text" $ nf encodeToText (decode enA)
         , bench "json"  $ nf encodeJ (decodeJ enJ)
         ]
       , bgroup "jp" [
-          bench "aeson-to-bytestring" $ nf A.encode (decodeA jpA)
-        , bench "aeson-via-text-to-bytestring" $ nf encodeViaText (decodeA jpA)
-        , bench "aeson-to-text" $ nf encodeToText (decodeA jpA)
+          bench "aeson-to-bytestring" $ nf A.encode (decode jpA)
+        , bench "aeson-via-text-to-bytestring" $ nf encodeViaText (decode jpA)
+        , bench "aeson-to-text" $ nf encodeToText (decode jpA)
         , bench "json"  $ nf encodeJ (decodeJ jpJ)
         ]
       ]