git.iko.soy/typeable/aeson
on 1.2.2.0 help sign in
typeable/aeson/benchmarks/AesonMap.hs
231 lines 6.9 kB history raw
1{-# LANGUAGE FlexibleContexts #-}
2{-# LANGUAGE OverloadedStrings #-}
3{-# LANGUAGE PackageImports #-}
4{-# LANGUAGE RankNTypes #-}
6{-# OPTIONS_GHC -fno-warn-orphans #-}
8module Main (main) where
10import Prelude ()
11import Prelude.Compat
13import Control.DeepSeq
14import Criterion.Main
15import Data.Hashable
16import Data.Proxy (Proxy (..))
17import Data.Tagged (Tagged (..))
18import qualified "aeson" Data.Aeson as A
19import qualified "aeson-benchmarks" Data.Aeson as B
20import qualified "aeson-benchmarks" Data.Aeson.Types as B (fromJSONKeyCoerce)
21import qualified Data.ByteString.Lazy as LBS
22import qualified Data.HashMap.Strict as HM
23import qualified Data.Map as M
24import qualified Data.Text as T
26value :: Int -> HM.HashMap T.Text T.Text
27value n = HM.fromList $ map f [1..n]
28 where
29 f m = let t = T.pack (show m) in (t, t)
31-------------------------------------------------------------------------------
32-- Orphans
33-------------------------------------------------------------------------------
35instance Hashable b => Hashable (Tagged a b) where
36 hashWithSalt salt (Tagged a) = hashWithSalt salt a
38-------------------------------------------------------------------------------
39-- Text
40-------------------------------------------------------------------------------
42newtype T1 = T1 T.Text
43 deriving (Eq, Ord)
45instance NFData T1 where
46 rnf (T1 t) = rnf t
47instance Hashable T1 where
48 hashWithSalt salt (T1 t) = hashWithSalt salt t
50instance B.FromJSON T1 where
51 parseJSON = B.withText "T1" $ pure . T1
52instance B.FromJSONKey T1 where
53 fromJSONKey = B.FromJSONKeyText T1
55-------------------------------------------------------------------------------
56-- Coerce
57-------------------------------------------------------------------------------
59newtype T2 = T2 T.Text
60 deriving (Eq, Ord)
62instance NFData T2 where
63 rnf (T2 t) = rnf t
64instance Hashable T2 where
65 hashWithSalt salt (T2 t) = hashWithSalt salt t
67instance B.FromJSON T2 where
68 parseJSON = B.withText "T2" $ pure . T2
69instance B.FromJSONKey T2 where
70 fromJSONKey = B.fromJSONKeyCoerce
72-------------------------------------------------------------------------------
73-- TextParser
74-------------------------------------------------------------------------------
76newtype T3 = T3 T.Text
77 deriving (Eq, Ord)
79instance NFData T3 where
80 rnf (T3 t) = rnf t
81instance Hashable T3 where
82 hashWithSalt salt (T3 t) = hashWithSalt salt t
84instance B.FromJSON T3 where
85 parseJSON = B.withText "T3" $ pure . T3
86instance B.FromJSONKey T3 where
87 fromJSONKey = B.FromJSONKeyTextParser (pure . T3)
89-------------------------------------------------------------------------------
90-- Values
91-------------------------------------------------------------------------------
93value10, value100, value1000, value10000 :: HM.HashMap T.Text T.Text
94value10 = value 10
95value100 = value 100
96value1000 = value 1000
97value10000 = value 10000
99encodedValue10 :: LBS.ByteString
100encodedValue10 = B.encode value10
102encodedValue100 :: LBS.ByteString
103encodedValue100 = B.encode value100
105encodedValue1000 :: LBS.ByteString
106encodedValue1000 = B.encode value1000
108encodedValue10000 :: LBS.ByteString
109encodedValue10000 = B.encode value10000
111-------------------------------------------------------------------------------
112-- Helpers
113-------------------------------------------------------------------------------
115decodeHMB
116 :: (B.FromJSONKey k, Eq k, Hashable k)
117 => Proxy k -> LBS.ByteString -> Maybe (HM.HashMap k T.Text)
118decodeHMB _ = B.decode
120decodeHMA
121 :: (A.FromJSON (HM.HashMap k T.Text), Eq k, Hashable k)
122 => Proxy k -> LBS.ByteString -> Maybe (HM.HashMap k T.Text)
123decodeHMA _ = A.decode
125decodeMapB
126 :: (B.FromJSONKey k, Ord k)
127 => Proxy k -> LBS.ByteString -> Maybe (M.Map k T.Text)
128decodeMapB _ = B.decode
130decodeMapA
131 :: (A.FromJSON (M.Map k T.Text), Ord k)
132 => Proxy k -> LBS.ByteString -> Maybe (M.Map k T.Text)
133decodeMapA _ = A.decode
135proxyText :: Proxy T.Text
136proxyText = Proxy
138proxyT1 :: Proxy T1
139proxyT1 = Proxy
141proxyT2 :: Proxy T2
142proxyT2 = Proxy
144proxyT3 :: Proxy T3
145proxyT3 = Proxy
147proxyTagged :: Proxy a -> Proxy (Tagged () a)
148proxyTagged _ = Proxy
150-------------------------------------------------------------------------------
151-- Main
152-------------------------------------------------------------------------------
154benchDecodeHM
155 :: String
156 -> LBS.ByteString
157 -> Benchmark
158benchDecodeHM name val = bgroup name
159 [ bench "Text" $ nf (decodeHMB proxyText) val
160 , bench "Identity" $ nf (decodeHMB proxyT1) val
161 , bench "Coerce" $ nf (decodeHMB proxyT2) val
162 , bench "Parser" $ nf (decodeHMB proxyT3) val
163 , bench "aeson-hackage" $ nf (decodeHMA proxyText) val
164 , bench "Tagged Text" $ nf (decodeHMB $ proxyTagged proxyText) val
165 , bench "Tagged Identity" $ nf (decodeHMB $ proxyTagged proxyT1) val
166 , bench "Tagged Coerce" $ nf (decodeHMB $ proxyTagged proxyT2) val
167 , bench "Tagged Parser" $ nf (decodeHMB $ proxyTagged proxyT3) val
168 ]
170benchDecodeMap
171 :: String
172 -> LBS.ByteString
173 -> Benchmark
174benchDecodeMap name val = bgroup name
175 [ bench "Text" $ nf (decodeMapB proxyText) val
176 , bench "Identity" $ nf (decodeMapB proxyT1) val
177 , bench "Coerce" $ nf (decodeMapB proxyT2) val
178 , bench "Parser" $ nf (decodeMapB proxyT3) val
179 , bench "aeson-hackage" $ nf (decodeMapA proxyText) val
180 ]
182benchEncodeHM
183 :: String
184 -> HM.HashMap T.Text T.Text
185 -> Benchmark
186benchEncodeHM name val = bgroup name
187 [ bench "Text" $ nf B.encode val
188 , bench "aeson-0.11" $ nf A.encode val
189 ]
191benchEncodeMap
192 :: String
193 -> HM.HashMap T.Text T.Text
194 -> Benchmark
195benchEncodeMap name val = bgroup name
196 [ bench "Text" $ nf B.encode val'
197 , bench "aeson-0.11" $ nf A.encode val'
198 ]
199 where
200 val' :: M.Map T.Text T.Text
201 val' = M.fromList . HM.toList $ val
203main :: IO ()
204main = defaultMain
205 [ bgroup "decode"
206 [ bgroup "HashMap"
207 [ benchDecodeHM "10" encodedValue10
208 , benchDecodeHM "100" encodedValue100
209 , benchDecodeHM "1000" encodedValue1000
210 , benchDecodeHM "10000" encodedValue10000
211 ]
212 , bgroup "Map"
213 [ benchDecodeMap "10" encodedValue10
214 , benchDecodeMap "100" encodedValue100
215 , benchDecodeMap "1000" encodedValue1000
216 , benchDecodeMap "10000" encodedValue10000
217 ]
218 ]
219 , bgroup "encode"
220 [ bgroup "HashMap"
221 [ benchEncodeHM "100" value100
222 , benchEncodeHM "1000" value1000
223 , benchEncodeHM "10000" value10000
224 ]
225 , bgroup "Map"
226 [ benchEncodeMap "100" value100
227 , benchEncodeMap "1000" value1000
228 , benchEncodeMap "10000" value10000
229 ]
230 ]
231 ]