git.iko.soy/typeable/aeson
on master help sign in
Expanded AesonCompareAutoInstances benchmark
3c28560Bas van Dijk
benchmarks/AesonCompareAutoInstances.hs+135−24
compare with master
unifiedsplit
@@ -14,7 +14,7 @@ import GHC.Generics (Generic)
14
14
15import Data.Aeson.Types
15import Data.Aeson.Types
16import Data.Aeson.TH (mkToJSON, mkParseJSON)
16import Data.Aeson.TH (mkToJSON, mkParseJSON)
17−import qualified Data.Aeson.Generic as G (fromJSON, toJSON)
17+import qualified Data.Aeson.Generic as G (fromJSON, toJSON)
18
18
19--------------------------------------------------------------------------------
19--------------------------------------------------------------------------------
20
20
@@ -33,53 +33,164 @@ instance NFData a => NFData (D a) where
33 rnf (Product s c x) = s `deepseq` c `deepseq` rnf x
33 rnf (Product s c x) = s `deepseq` c `deepseq` rnf x
34 rnf (Record d b y) = d `deepseq` b `deepseq` rnf y
34 rnf (Record d b y) = d `deepseq` b `deepseq` rnf y
35
35
36−--------------------------------------------------------------------------------
37−
38type T = D (D (D ()))
36type T = D (D (D ()))
39
37
40d :: T
38d :: T
41−d = Record
39+d = Record
42 { testOne = 1234.56789
40 { testOne = 1234.56789
43 , testTwo = True
41 , testTwo = True
44 , testThree = Product "Hello World!" 'a' $
42 , testThree = Product "Hello World!" 'a' $
45− Record
43+ Record
46 { testOne = 9876.54321
44 { testOne = 9876.54321
47 , testTwo = False
45 , testTwo = False
48 , testThree = Product "Yeehaa!!!" '\n' Nullary
46 , testThree = Product "Yeehaa!!!" '\n' Nullary
49 }
47 }
50 }
48 }
51
49
52−--------------------------------------------------------------------------------
53−
54instance ToJSON a => ToJSON (D a)
50instance ToJSON a => ToJSON (D a)
55instance FromJSON a => FromJSON (D a)
51instance FromJSON a => FromJSON (D a)
56
52
53+thDToJSON :: ToJSON a => D a -> Value
54+thDToJSON = $(mkToJSON id ''D)
55+
56+thDParseJSON :: FromJSON a => Value -> Parser (D a)
57+thDParseJSON = $(mkParseJSON id ''D)
58+
59+thDFromJSON :: FromJSON a => Value -> Result (D a)
60+thDFromJSON = parse thDParseJSON
61+
57--------------------------------------------------------------------------------
62--------------------------------------------------------------------------------
58
63
59−thToJSON :: ToJSON a => D a -> Value
64+data BigRecord = BigRecord
60−thToJSON = $(mkToJSON id ''D)
65+ { field01 :: !(), field02 :: !(), field03 :: !(), field04 :: !(), field05 :: !()
66+ , field06 :: !(), field07 :: !(), field08 :: !(), field09 :: !(), field10 :: !()
67+ , field11 :: !(), field12 :: !(), field13 :: !(), field14 :: !(), field15 :: !()
68+ , field16 :: !(), field17 :: !(), field18 :: !(), field19 :: !(), field20 :: !()
69+ , field21 :: !(), field22 :: !(), field23 :: !(), field24 :: !(), field25 :: !()
70+ } deriving (Eq, Generic, Data, Typeable)
71+
72+instance NFData BigRecord
73+
74+bigRecord = BigRecord () () () () ()
75+ () () () () ()
76+ () () () () ()
77+ () () () () ()
78+ () () () () ()
79+
80+instance ToJSON BigRecord
81+instance FromJSON BigRecord
82+
83+thBigRecordToJSON :: BigRecord -> Value
84+thBigRecordToJSON = $(mkToJSON id ''BigRecord)
85+
86+thBigRecordParseJSON :: Value -> Parser BigRecord
87+thBigRecordParseJSON = $(mkParseJSON id ''BigRecord)
88+
89+thBigRecordFromJSON :: Value -> Result BigRecord
90+thBigRecordFromJSON = parse thBigRecordParseJSON
91+
92+--------------------------------------------------------------------------------
93+
94+data BigProduct = BigProduct
95+ !() !() !() !() !()
96+ !() !() !() !() !()
97+ !() !() !() !() !()
98+ !() !() !() !() !()
99+ !() !() !() !() !()
100+ deriving (Eq, Generic, Data, Typeable)
101+
102+instance NFData BigProduct
103+
104+bigProduct = BigProduct () () () () ()
105+ () () () () ()
106+ () () () () ()
107+ () () () () ()
108+ () () () () ()
109+
110+instance ToJSON BigProduct
111+instance FromJSON BigProduct
112+
113+thBigProductToJSON :: BigProduct -> Value
114+thBigProductToJSON = $(mkToJSON id ''BigProduct)
115+
116+thBigProductParseJSON :: Value -> Parser BigProduct
117+thBigProductParseJSON = $(mkParseJSON id ''BigProduct)
118+
119+thBigProductFromJSON :: Value -> Result BigProduct
120+thBigProductFromJSON = parse thBigProductParseJSON
121+
122+--------------------------------------------------------------------------------
123+
124+data BigSum = F01 | F02 | F03 | F04 | F05
125+ | F06 | F07 | F08 | F09 | F10
126+ | F11 | F12 | F13 | F14 | F15
127+ | F16 | F17 | F18 | F19 | F20
128+ | F21 | F22 | F23 | F24 | F25
129+ deriving (Eq, Generic, Data, Typeable)
130+
131+instance NFData BigSum
132+
133+bigSum = F12
134+
135+instance ToJSON BigSum
136+instance FromJSON BigSum
137+
138+thBigSumToJSON :: BigSum -> Value
139+thBigSumToJSON = $(mkToJSON id ''BigSum)
61
140
62−thParseJSON :: FromJSON a => Value -> Parser (D a)
141+thBigSumParseJSON :: Value -> Parser BigSum
63−thParseJSON = $(mkParseJSON id ''D)
142+thBigSumParseJSON = $(mkParseJSON id ''BigSum)
64
143
65−thFromJSON :: FromJSON a => Value -> Result (D a)
144+thBigSumFromJSON :: Value -> Result BigSum
66−thFromJSON = parse thParseJSON
145+thBigSumFromJSON = parse thBigSumParseJSON
67
146
68--------------------------------------------------------------------------------
147--------------------------------------------------------------------------------
69
148
70−type FJ = Value -> Result T
149+type FJ a = Value -> Result a
71
150
72main :: IO ()
151main :: IO ()
73−main =
74− let v = thToJSON d
75− in d `deepseq` v `deepseq` defaultMain
152+main = defaultMain
153+ [ let v = thDToJSON d
154+ in d `deepseq` v `deepseq`
155+ bgroup "D"
76− [ group "toJSON" (nf thToJSON d)
156+ [ group "toJSON" (nf thDToJSON d)
77− (nf G.toJSON d)
157+ (nf G.toJSON d)
78− (nf toJSON d)
158+ (nf toJSON d)
159+ , group "fromJSON" (nf (thDFromJSON :: FJ T) v)
160+ (nf (G.fromJSON :: FJ T) v)
161+ (nf (fromJSON :: FJ T) v)
162+ ]
163+ , let v = thBigRecordToJSON bigRecord
164+ in bigRecord `deepseq` v `deepseq`
165+ bgroup "BigRecord"
166+ [ group "toJSON" (nf thBigRecordToJSON bigRecord)
167+ (nf G.toJSON bigRecord)
168+ (nf toJSON bigRecord)
79− , group "fromJSON" (nf (thFromJSON :: FJ) v)
169+ , group "fromJSON" (nf (thBigRecordFromJSON :: FJ BigRecord) v)
80− (nf (G.fromJSON :: FJ) v)
170+ (nf (G.fromJSON :: FJ BigRecord) v)
81− (nf (fromJSON :: FJ) v)
171+ (nf (fromJSON :: FJ BigRecord) v)
172+ ]
173+ , let v = thBigProductToJSON bigProduct
174+ in bigProduct `deepseq` v `deepseq`
175+ bgroup "BigProduct"
176+ [ group "toJSON" (nf thBigProductToJSON bigProduct)
177+ (nf G.toJSON bigProduct)
178+ (nf toJSON bigProduct)
179+ , group "fromJSON" (nf (thBigProductFromJSON :: FJ BigProduct) v)
180+ (nf (G.fromJSON :: FJ BigProduct) v)
181+ (nf (fromJSON :: FJ BigProduct) v)
182+ ]
183+ , let v = thBigSumToJSON bigSum
184+ in bigSum `deepseq` v `deepseq`
185+ bgroup "BigSum"
186+ [ group "toJSON" (nf thBigSumToJSON bigSum)
187+ (nf G.toJSON bigSum)
188+ (nf toJSON bigSum)
189+ , group "fromJSON" (nf (thBigSumFromJSON :: FJ BigSum) v)
190+ (nf (G.fromJSON :: FJ BigSum) v)
191+ (nf (fromJSON :: FJ BigSum) v)
192+ ]
82− ]
193+ ]
83
194
84group n th syb gen = bgroup n [ bench "th" th
195group n th syb gen = bgroup n [ bench "th" th
85 , bench "syb" syb
196 , bench "syb" syb