git.iko.soy/typeable/aeson
on master help sign in
Add benchmarks for derived instances
d45d504lyxia
benchmarks/AesonCompareAutoInstances.hsdeleted−282
compare with master
unifiedsplit
@@ -1,282 +0,0 @@
1−{-# LANGUAGE DeriveGeneric #-}
2−{-# LANGUAGE FlexibleContexts #-}
3−{-# LANGUAGE TemplateHaskell #-}
4−
5−module Main (main) where
6−
7−import Prelude ()
8−import Prelude.Compat
9−
10−import Control.Monad
11−import Control.DeepSeq (NFData, rnf, deepseq)
12−import Criterion.Main hiding (defaultOptions)
13−import Data.Aeson
14−import Data.Aeson.Encoding
15−import Data.Aeson.TH
16−import Data.Aeson.Types
17−import Data.ByteString.Lazy (ByteString)
18−import Data.Data (Data)
19−import Data.Typeable (Typeable)
20−import GHC.Generics (Generic, Rep)
21−import Options
22−
23−toBS :: Encoding -> ByteString
24−toBS = encodingToLazyByteString
25−
26−gEncode :: (Generic a, GToEncoding Zero (Rep a)) => a -> ByteString
27−gEncode = toBS . genericToEncoding opts
28−
29−--------------------------------------------------------------------------------
30−
31−data D a = Nullary
32− | Unary Int
33− | Product String Char a
34− | Record { testOne :: Double
35− , testTwo :: Bool
36− , testThree :: D a
37− }
38− deriving (Show, Eq)
39−
40−deriveJSON opts ''D
41−
42−instance NFData a => NFData (D a) where
43− rnf Nullary = ()
44− rnf (Unary n) = rnf n
45− rnf (Product s c x) = s `deepseq` c `deepseq` rnf x
46− rnf (Record d b y) = d `deepseq` b `deepseq` rnf y
47−
48−type T = D (D (D ()))
49−
50−d :: T
51−d = Record
52− { testOne = 1234.56789
53− , testTwo = True
54− , testThree = Product "Hello World!" 'a'
55− Record
56− { testOne = 9876.54321
57− , testTwo = False
58− , testThree = Product "Yeehaa!!!" '\n' Nullary
59− }
60− }
61−
62−--------------------------------------------------------------------------------
63−
64−data D' a = Nullary'
65− | Unary' Int
66− | Product' String Char a
67− | Record' { testOne' :: Double
68− , testTwo' :: Bool
69− , testThree' :: D' a
70− }
71− deriving (Show, Eq, Generic)
72−
73−instance ToJSON a => ToJSON (D' a) where
74− toJSON = genericToJSON opts
75−
76−instance FromJSON a => FromJSON (D' a) where
77− parseJSON = genericParseJSON opts
78−
79−instance NFData a => NFData (D' a) where
80− rnf Nullary' = ()
81− rnf (Unary' n) = rnf n
82− rnf (Product' s c x) = s `deepseq` c `deepseq` rnf x
83− rnf (Record' d b y) = d `deepseq` b `deepseq` rnf y
84−
85−type T' = D' (D' (D' ()))
86−
87−d' :: T'
88−d' = Record'
89− { testOne' = 1234.56789
90− , testTwo' = True
91− , testThree' = Product' "Hello World!" 'a'
92− Record'
93− { testOne' = 9876.54321
94− , testTwo' = False
95− , testThree' = Product' "Yeehaa!!!" '\n' Nullary'
96− }
97− }
98−
99−--------------------------------------------------------------------------------
100−
101−data BigRecord = BigRecord
102− { field01 :: !Int, field02 :: !Int, field03 :: !Int, field04 :: !Int, field05 :: !Int
103− , field06 :: !Int, field07 :: !Int, field08 :: !Int, field09 :: !Int, field10 :: !Int
104− , field11 :: !Int, field12 :: !Int, field13 :: !Int, field14 :: !Int, field15 :: !Int
105− , field16 :: !Int, field17 :: !Int, field18 :: !Int, field19 :: !Int, field20 :: !Int
106− , field21 :: !Int, field22 :: !Int, field23 :: !Int, field24 :: !Int, field25 :: !Int
107− } deriving (Show, Eq, Generic)
108−
109−instance NFData BigRecord
110−
111−bigRecord = BigRecord 1 2 3 4 5
112− 6 7 8 9 10
113− 11 12 13 14 15
114− 16 17 18 19 20
115− 21 22 23 24 25
116−
117−return []
118−
119−gBigRecordToJSON :: BigRecord -> Value
120−gBigRecordToJSON = genericToJSON opts
121−
122−gBigRecordEncode :: BigRecord -> ByteString
123−gBigRecordEncode = gEncode
124−
125−gBigRecordFromJSON :: Value -> Result BigRecord
126−gBigRecordFromJSON = parse $ genericParseJSON opts
127−
128−thBigRecordToJSON :: BigRecord -> Value
129−thBigRecordToJSON = $(mkToJSON opts ''BigRecord)
130−
131−thBigRecordEncode :: BigRecord -> ByteString
132−thBigRecordEncode = toBS . $(mkToEncoding opts ''BigRecord)
133−
134−thBigRecordFromJSON :: Value -> Result BigRecord
135−thBigRecordFromJSON = parse $(mkParseJSON opts ''BigRecord)
136−
137−--------------------------------------------------------------------------------
138−
139−data BigProduct = BigProduct
140− !Int !Int !Int !Int !Int
141− !Int !Int !Int !Int !Int
142− !Int !Int !Int !Int !Int
143− !Int !Int !Int !Int !Int
144− !Int !Int !Int !Int !Int
145− deriving (Show, Eq, Generic)
146−
147−instance NFData BigProduct
148−
149−bigProduct = BigProduct 1 2 3 4 5
150− 6 7 8 9 10
151− 11 12 13 14 15
152− 16 17 18 19 20
153− 21 22 23 24 25
154−
155−return []
156−
157−gBigProductToJSON :: BigProduct -> Value
158−gBigProductToJSON = genericToJSON opts
159−
160−gBigProductEncode :: BigProduct -> ByteString
161−gBigProductEncode = gEncode
162−
163−gBigProductFromJSON :: Value -> Result BigProduct
164−gBigProductFromJSON = parse $ genericParseJSON opts
165−
166−thBigProductToJSON :: BigProduct -> Value
167−thBigProductToJSON = $(mkToJSON opts ''BigProduct)
168−
169−thBigProductEncode :: BigProduct -> ByteString
170−thBigProductEncode = toBS . $(mkToEncoding opts ''BigProduct)
171−
172−thBigProductFromJSON :: Value -> Result BigProduct
173−thBigProductFromJSON = parse $(mkParseJSON opts ''BigProduct)
174−
175−--------------------------------------------------------------------------------
176−
177−data BigSum = F01 | F02 | F03 | F04 | F05
178− | F06 | F07 | F08 | F09 | F10
179− | F11 | F12 | F13 | F14 | F15
180− | F16 | F17 | F18 | F19 | F20
181− | F21 | F22 | F23 | F24 | F25
182− deriving (Show, Eq, Generic)
183−
184−instance NFData BigSum
185−
186−bigSum = F25
187−
188−return []
189−
190−gBigSumToJSON :: BigSum -> Value
191−gBigSumToJSON = genericToJSON opts
192−
193−gBigSumEncode :: BigSum -> ByteString
194−gBigSumEncode = gEncode
195−
196−gBigSumFromJSON :: Value -> Result BigSum
197−gBigSumFromJSON = parse $ genericParseJSON opts
198−
199−thBigSumToJSON :: BigSum -> Value
200−thBigSumToJSON = $(mkToJSON opts ''BigSum)
201−
202−thBigSumEncode :: BigSum -> ByteString
203−thBigSumEncode = toBS . $(mkToEncoding opts ''BigSum)
204−
205−thBigSumFromJSON :: Value -> Result BigSum
206−thBigSumFromJSON = parse $(mkParseJSON opts ''BigSum)
207−
208−--------------------------------------------------------------------------------
209−
210−type FJ a = Value -> Result a
211−
212−runBench :: IO ()
213−runBench = defaultMain
214− [ let v = toJSON d
215− in (d, d', v) `deepseq`
216− bgroup "D"
217− [ group "toJSON" (nf toJSON d)
218− (nf toJSON d')
219− , group "encode" (nf encode d)
220− (nf encode d')
221− , group "fromJSON" (nf ( fromJSON :: FJ T ) v)
222− (nf ( fromJSON :: FJ T') v)
223− ]
224− , let v = thBigRecordToJSON bigRecord
225− in bigRecord `deepseq` v `deepseq`
226− bgroup "BigRecord"
227− [ group "toJSON" (nf thBigRecordToJSON bigRecord)
228− (nf gBigRecordToJSON bigRecord)
229− , group "encode" (nf thBigRecordEncode bigRecord)
230− (nf gBigRecordEncode bigRecord)
231− , group "fromJSON" (nf (thBigRecordFromJSON :: FJ BigRecord) v)
232− (nf ( gBigRecordFromJSON :: FJ BigRecord) v)
233− ]
234− , let v = thBigProductToJSON bigProduct
235− in bigProduct `deepseq` v `deepseq`
236− bgroup "BigProduct"
237− [ group "toJSON" (nf thBigProductToJSON bigProduct)
238− (nf gBigProductToJSON bigProduct)
239− , group "encode" (nf thBigProductEncode bigProduct)
240− (nf gBigProductEncode bigProduct)
241− , group "fromJSON" (nf (thBigProductFromJSON :: FJ BigProduct) v)
242− (nf (gBigProductFromJSON :: FJ BigProduct) v)
243− ]
244− , let v = thBigSumToJSON bigSum
245− in bigSum `deepseq` v `deepseq`
246− bgroup "BigSum"
247− [ group "toJSON" (nf thBigSumToJSON bigSum)
248− (nf gBigSumToJSON bigSum)
249− , group "encode" (nf thBigSumEncode bigSum)
250− (nf gBigSumEncode bigSum)
251− , group "fromJSON" (nf (thBigSumFromJSON :: FJ BigSum) v)
252− (nf (gBigSumFromJSON :: FJ BigSum) v)
253− ]
254− ]
255−
256−group n th gen = bgroup n [ bench "th" th
257− , bench "generic" gen
258− ]
259−
260−sanityCheck = do
261− check d toJSON fromJSON encode
262− check d' toJSON fromJSON encode
263− check bigRecord thBigRecordToJSON thBigRecordFromJSON thBigRecordEncode
264− check bigRecord gBigRecordToJSON gBigRecordFromJSON gBigRecordEncode
265− check bigProduct thBigProductToJSON thBigProductFromJSON thBigProductEncode
266− check bigProduct gBigProductToJSON gBigProductFromJSON gBigProductEncode
267− check bigSum thBigSumToJSON thBigSumFromJSON thBigSumEncode
268− check bigSum gBigSumToJSON gBigSumFromJSON gBigSumEncode
269−
270−check :: (Show a, Eq a)
271− => a -> (a -> Value) -> (Value -> Result a) -> (a -> ByteString) -> IO ()
272−check x toJSON fromJSON encode = do
273− unless (Success x == (fromJSON . toJSON) x) $ fail $ "toJSON: " ++ show x
274− unless (Success x == (decode' . encode) x) $ fail $ "encode: " ++ show x
275− where
276− decode' s = case decode s of
277− Just v -> fromJSON v
278− Nothing -> fail ""
279−
280−main = do
281− sanityCheck
282− runBench
benchmarks/Auto/G/BigProduct.hsnew file+33
@@ -0,0 +1,33 @@
1+{-# LANGUAGE DeriveGeneric #-}
2+
3+module Auto.G.BigProduct where
4+
5+import Control.DeepSeq
6+import Data.Aeson
7+import GHC.Generics (Generic)
8+import Options
9+
10+data BigProduct = BigProduct
11+ !Int !Int !Int !Int !Int
12+ !Int !Int !Int !Int !Int
13+ !Int !Int !Int !Int !Int
14+ !Int !Int !Int !Int !Int
15+ !Int !Int !Int !Int !Int
16+ deriving (Show, Eq, Generic)
17+
18+instance NFData BigProduct where
19+ rnf a = a `seq` ()
20+
21+instance ToJSON BigProduct where
22+ toJSON = genericToJSON opts
23+ toEncoding = genericToEncoding opts
24+
25+instance FromJSON BigProduct where
26+ parseJSON = genericParseJSON opts
27+
28+bigProduct :: BigProduct
29+bigProduct = BigProduct 1 2 3 4 5
30+ 6 7 8 9 10
31+ 11 12 13 14 15
32+ 16 17 18 19 20
33+ 21 22 23 24 25
benchmarks/Auto/G/BigRecord.hsnew file+33
@@ -0,0 +1,33 @@
1+{-# LANGUAGE DeriveGeneric #-}
2+
3+module Auto.G.BigRecord where
4+
5+import Control.DeepSeq
6+import Data.Aeson
7+import GHC.Generics (Generic)
8+import Options
9+
10+data BigRecord = BigRecord
11+ { field01 :: !Int, field02 :: !Int, field03 :: !Int, field04 :: !Int, field05 :: !Int
12+ , field06 :: !Int, field07 :: !Int, field08 :: !Int, field09 :: !Int, field10 :: !Int
13+ , field11 :: !Int, field12 :: !Int, field13 :: !Int, field14 :: !Int, field15 :: !Int
14+ , field16 :: !Int, field17 :: !Int, field18 :: !Int, field19 :: !Int, field20 :: !Int
15+ , field21 :: !Int, field22 :: !Int, field23 :: !Int, field24 :: !Int, field25 :: !Int
16+ } deriving (Show, Eq, Generic)
17+
18+instance NFData BigRecord where
19+ rnf a = a `seq` ()
20+
21+instance ToJSON BigRecord where
22+ toJSON = genericToJSON opts
23+ toEncoding = genericToEncoding opts
24+
25+instance FromJSON BigRecord where
26+ parseJSON = genericParseJSON opts
27+
28+bigRecord :: BigRecord
29+bigRecord = BigRecord 1 2 3 4 5
30+ 6 7 8 9 10
31+ 11 12 13 14 15
32+ 16 17 18 19 20
33+ 21 22 23 24 25
benchmarks/Auto/G/BigSum.hsnew file+28
@@ -0,0 +1,28 @@
1+{-# LANGUAGE DeriveGeneric #-}
2+
3+module Auto.G.BigSum where
4+
5+import Control.DeepSeq
6+import Data.Aeson
7+import GHC.Generics (Generic)
8+import Options
9+
10+data BigSum = F01 | F02 | F03 | F04 | F05
11+ | F06 | F07 | F08 | F09 | F10
12+ | F11 | F12 | F13 | F14 | F15
13+ | F16 | F17 | F18 | F19 | F20
14+ | F21 | F22 | F23 | F24 | F25
15+ deriving (Show, Eq, Generic)
16+
17+instance NFData BigSum where
18+ rnf a = a `seq` ()
19+
20+instance ToJSON BigSum where
21+ toJSON = genericToJSON opts
22+ toEncoding = genericToEncoding opts
23+
24+instance FromJSON BigSum where
25+ parseJSON = genericParseJSON opts
26+
27+bigSum :: BigSum
28+bigSum = F25
benchmarks/Auto/G/D.hsnew file+44
@@ -0,0 +1,44 @@
1+{-# LANGUAGE DeriveGeneric #-}
2+
3+module Auto.G.D where
4+
5+import Control.DeepSeq
6+import Data.Aeson
7+import GHC.Generics (Generic)
8+import Options
9+
10+data D a = Nullary
11+ | Unary Int
12+ | Product String Char a
13+ | Record { testOne :: Double
14+ , testTwo :: Bool
15+ , testThree :: D a
16+ }
17+ deriving (Show, Eq, Generic)
18+
19+instance NFData a => NFData (D a) where
20+ rnf Nullary = ()
21+ rnf (Unary n) = rnf n
22+ rnf (Product s c x) = s `deepseq` c `deepseq` rnf x
23+ rnf (Record a b y) = a `deepseq` b `deepseq` rnf y
24+
25+instance ToJSON a => ToJSON (D a) where
26+ toJSON = genericToJSON opts
27+ toEncoding = genericToEncoding opts
28+
29+instance FromJSON a => FromJSON (D a) where
30+ parseJSON = genericParseJSON opts
31+
32+type T = D (D (D ()))
33+
34+d :: T
35+d = Record
36+ { testOne = 1234.56789
37+ , testTwo = True
38+ , testThree = Product "Hello World!" 'a'
39+ Record
40+ { testOne = 9876.54321
41+ , testTwo = False
42+ , testThree = Product "Yeehaa!!!" '\n' Nullary
43+ }
44+ }
benchmarks/Auto/T/BigProduct.hsnew file+27
@@ -0,0 +1,27 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+
3+module Auto.T.BigProduct where
4+
5+import Control.DeepSeq
6+import Data.Aeson.TH
7+import Options
8+
9+data BigProduct = BigProduct
10+ !Int !Int !Int !Int !Int
11+ !Int !Int !Int !Int !Int
12+ !Int !Int !Int !Int !Int
13+ !Int !Int !Int !Int !Int
14+ !Int !Int !Int !Int !Int
15+ deriving (Show, Eq)
16+
17+instance NFData BigProduct where
18+ rnf a = a `seq` ()
19+
20+deriveJSON opts ''BigProduct
21+
22+bigProduct :: BigProduct
23+bigProduct = BigProduct 1 2 3 4 5
24+ 6 7 8 9 10
25+ 11 12 13 14 15
26+ 16 17 18 19 20
27+ 21 22 23 24 25
benchmarks/Auto/T/BigRecord.hsnew file+27
@@ -0,0 +1,27 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+
3+module Auto.T.BigRecord where
4+
5+import Control.DeepSeq
6+import Data.Aeson.TH
7+import Options
8+
9+data BigRecord = BigRecord
10+ { field01 :: !Int, field02 :: !Int, field03 :: !Int, field04 :: !Int, field05 :: !Int
11+ , field06 :: !Int, field07 :: !Int, field08 :: !Int, field09 :: !Int, field10 :: !Int
12+ , field11 :: !Int, field12 :: !Int, field13 :: !Int, field14 :: !Int, field15 :: !Int
13+ , field16 :: !Int, field17 :: !Int, field18 :: !Int, field19 :: !Int, field20 :: !Int
14+ , field21 :: !Int, field22 :: !Int, field23 :: !Int, field24 :: !Int, field25 :: !Int
15+ } deriving (Show, Eq)
16+
17+instance NFData BigRecord where
18+ rnf a = a `seq` ()
19+
20+deriveJSON opts ''BigRecord
21+
22+bigRecord :: BigRecord
23+bigRecord = BigRecord 1 2 3 4 5
24+ 6 7 8 9 10
25+ 11 12 13 14 15
26+ 16 17 18 19 20
27+ 21 22 23 24 25
benchmarks/Auto/T/BigSum.hsnew file+22
@@ -0,0 +1,22 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+
3+module Auto.T.BigSum where
4+
5+import Control.DeepSeq
6+import Data.Aeson.TH
7+import Options
8+
9+data BigSum = F01 | F02 | F03 | F04 | F05
10+ | F06 | F07 | F08 | F09 | F10
11+ | F11 | F12 | F13 | F14 | F15
12+ | F16 | F17 | F18 | F19 | F20
13+ | F21 | F22 | F23 | F24 | F25
14+ deriving (Show, Eq)
15+
16+instance NFData BigSum where
17+ rnf a = a `seq` ()
18+
19+deriveJSON opts ''BigSum
20+
21+bigSum :: BigSum
22+bigSum = F25
benchmarks/Auto/T/D.hsnew file+38
@@ -0,0 +1,38 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+
3+module Auto.T.D where
4+
5+import Control.DeepSeq
6+import Data.Aeson.TH
7+import Options
8+
9+data D a = Nullary
10+ | Unary Int
11+ | Product String Char a
12+ | Record { testOne :: Double
13+ , testTwo :: Bool
14+ , testThree :: D a
15+ }
16+ deriving (Show, Eq)
17+
18+instance NFData a => NFData (D a) where
19+ rnf Nullary = ()
20+ rnf (Unary n) = rnf n
21+ rnf (Product s c x) = s `deepseq` c `deepseq` rnf x
22+ rnf (Record a b y) = a `deepseq` b `deepseq` rnf y
23+
24+deriveJSON opts ''D
25+
26+type T = D (D (D ()))
27+
28+d :: T
29+d = Record
30+ { testOne = 1234.56789
31+ , testTwo = True
32+ , testThree = Product "Hello World!" 'a'
33+ Record
34+ { testOne = 9876.54321
35+ , testTwo = False
36+ , testThree = Product "Yeehaa!!!" '\n' Nullary
37+ }
38+ }
benchmarks/AutoCompare.hsnew file+73
@@ -0,0 +1,73 @@
1+{-# LANGUAGE RankNTypes #-}
2+{-# LANGUAGE ScopedTypeVariables #-}
3+
4+module Main (main) where
5+
6+import Control.DeepSeq
7+import Control.Monad
8+import Criterion.Main
9+import Data.Aeson
10+
11+import qualified Auto.T.D as T
12+import qualified Auto.T.BigRecord as T
13+import qualified Auto.T.BigProduct as T
14+import qualified Auto.T.BigSum as T
15+import qualified Auto.G.D as G
16+import qualified Auto.G.BigRecord as G
17+import qualified Auto.G.BigProduct as G
18+import qualified Auto.G.BigSum as G
19+
20+--------------------------------------------------------------------------------
21+
22+runBench :: IO ()
23+runBench = defaultMain
24+ [ compareBench "D" T.d G.d
25+ , compareBench "BigRecord" T.bigRecord G.bigRecord
26+ , compareBench "BigProduct" T.bigProduct G.bigProduct
27+ , compareBench "BigSum" T.bigSum G.bigSum
28+ ]
29+
30+group :: String -> Benchmarkable -> Benchmarkable -> Benchmark
31+group n th gen = bgroup n [ bench "th" th
32+ , bench "generic" gen
33+ ]
34+
35+compareBench
36+ :: forall a b
37+ . (ToJSON a, FromJSON a, NFData a, ToJSON b, FromJSON b, NFData b)
38+ => String -> a -> b -> Benchmark
39+compareBench name a b = v `deepseq` bgroup name
40+ [ group "toJSON" (nf toJSON a)
41+ (nf toJSON b)
42+ , group "encode" (nf encode a)
43+ (nf encode b)
44+ , group "fromJSON" (nf (fromJSON :: Value -> Result a) v)
45+ (nf (fromJSON :: Value -> Result b) v)
46+ ] where
47+ v = toJSON a -- == toJSON b
48+
49+sanityCheck :: IO ()
50+sanityCheck = do
51+ check T.d
52+ check G.d
53+ check T.bigRecord
54+ check G.bigRecord
55+ check T.bigProduct
56+ check G.bigProduct
57+ check T.bigSum
58+ check G.bigSum
59+
60+check :: (Show a, Eq a, FromJSON a, ToJSON a)
61+ => a -> IO ()
62+check x = do
63+ unless (Success x == (fromJSON . toJSON) x) $ fail $ "toJSON: " ++ show x
64+ unless (Success x == (decode_ . encode) x) $ fail $ "encode: " ++ show x
65+ where
66+ decode_ s = case decode s of
67+ Just v -> fromJSON v
68+ Nothing -> fail ""
69+
70+main :: IO ()
71+main = do
72+ sanityCheck
73+ runBench
benchmarks/Options.hs−3
@@ -1,8 +1,5 @@
1module Options (opts) where
1module Options (opts) where
2
2
3−import Prelude ()
4−import Prelude.Compat
5−
6import Data.Aeson.Types
3import Data.Aeson.Types
7
4
8opts :: Options
5opts :: Options
benchmarks/aeson-benchmarks.cabal+22
@@ -80,6 +80,28 @@ library
80 ghc-options: -O2 -Wall
80 ghc-options: -O2 -Wall
81 cpp-options: -DGENERICS
81 cpp-options: -DGENERICS
82
82
83+executable aeson-benchmark-auto-compare
84+ default-language: Haskell2010
85+ main-is: AutoCompare.hs
86+ hs-source-dirs: .
87+ ghc-options: -Wall -O2 -rtsopts
88+ other-modules:
89+ Auto.T.D
90+ Auto.T.BigRecord
91+ Auto.T.BigProduct
92+ Auto.T.BigSum
93+ Auto.G.D
94+ Auto.G.BigRecord
95+ Auto.G.BigProduct
96+ Auto.G.BigSum
97+ Options
98+ build-depends:
99+ aeson-benchmarks,
100+ base,
101+ criterion,
102+ deepseq,
103+ template-haskell
104+
83executable aeson-benchmark-escape
105executable aeson-benchmark-escape
84 default-language: Haskell2010
106 default-language: Haskell2010
85 main-is: Escape.hs
107 main-is: Escape.hs