yamlet-1.0.0.2: bench/Yamlet/Bench/Derive/Manual.hs
-- | The types of "Yamlet.Bench.Derive.Generic" with written instances.
module Yamlet.Bench.Derive.Manual
( A (..)
, B (..)
, C (..)
, X (..)
, F (..)
, D (..)
, P (..)
, O (..)
, E (..)
, mkX
, mkF
) where
import Control.DeepSeq
import Data.Text qualified as T
import Yamlet
import Yamlet.Bench.Derive.Fields
data A = A
{ a01 :: T.Text
, a02 :: Maybe Int
, a03 :: Int
, a04 :: T.Text
, a05 :: Maybe Int
, a06 :: Int
, a07 :: T.Text
, a08 :: Maybe Int
, a09 :: Int
, a10 :: T.Text
}
deriving stock (Generic)
deriving anyclass (NFData)
instance ToYaml A where
toYaml x =
mapping
[ "a01" .= x.a01
, "a02" .= x.a02
, "a03" .= x.a03
, "a04" .= x.a04
, "a05" .= x.a05
, "a06" .= x.a06
, "a07" .= x.a07
, "a08" .= x.a08
, "a09" .= x.a09
, "a10" .= x.a10
]
instance FromYaml A where
parseYaml = withMapping $ \o ->
A
<$> parseField o "a01"
<*> parseFieldMaybe o "a02"
<*> parseField o "a03"
<*> parseField o "a04"
<*> parseFieldMaybe o "a05"
<*> parseField o "a06"
<*> parseField o "a07"
<*> parseFieldMaybe o "a08"
<*> parseField o "a09"
<*> parseField o "a10"
data B = B
{ b01 :: T.Text
, b02 :: Maybe Int
, b03 :: Int
, b04 :: T.Text
, b05 :: Maybe Int
, b06 :: Int
, b07 :: T.Text
, b08 :: Maybe Int
, b09 :: Int
, b10 :: T.Text
}
deriving stock (Generic)
deriving anyclass (NFData)
instance ToYaml B where
toYaml x =
mapping
[ "b01" .= x.b01
, "b02" .= x.b02
, "b03" .= x.b03
, "b04" .= x.b04
, "b05" .= x.b05
, "b06" .= x.b06
, "b07" .= x.b07
, "b08" .= x.b08
, "b09" .= x.b09
, "b10" .= x.b10
]
instance FromYaml B where
parseYaml = withMapping $ \o ->
B
<$> parseField o "b01"
<*> parseFieldMaybe o "b02"
<*> parseField o "b03"
<*> parseField o "b04"
<*> parseFieldMaybe o "b05"
<*> parseField o "b06"
<*> parseField o "b07"
<*> parseFieldMaybe o "b08"
<*> parseField o "b09"
<*> parseField o "b10"
data C = C
{ c01 :: T.Text
, c02 :: Maybe Int
, c03 :: Int
, c04 :: T.Text
, c05 :: Maybe Int
, c06 :: Int
, c07 :: T.Text
, c08 :: Maybe Int
, c09 :: Int
, c10 :: T.Text
}
deriving stock (Generic)
deriving anyclass (NFData)
instance ToYaml C where
toYaml x =
mapping
[ "c01" .= x.c01
, "c02" .= x.c02
, "c03" .= x.c03
, "c04" .= x.c04
, "c05" .= x.c05
, "c06" .= x.c06
, "c07" .= x.c07
, "c08" .= x.c08
, "c09" .= x.c09
, "c10" .= x.c10
]
instance FromYaml C where
parseYaml = withMapping $ \o ->
C
<$> parseField o "c01"
<*> parseFieldMaybe o "c02"
<*> parseField o "c03"
<*> parseField o "c04"
<*> parseFieldMaybe o "c05"
<*> parseField o "c06"
<*> parseField o "c07"
<*> parseFieldMaybe o "c08"
<*> parseField o "c09"
<*> parseField o "c10"
data D = D
{ d01 :: T.Text
, d02 :: Maybe Int
, d03 :: Int
, d04 :: T.Text
, d05 :: Maybe Int
, d06 :: Int
, d07 :: T.Text
, d08 :: Maybe Int
, d09 :: Int
, d10 :: T.Text
}
deriving stock (Generic)
deriving anyclass (NFData)
instance ToYaml D where
toYaml x =
mapping
[ "d01" .= x.d01
, "d02" .= x.d02
, "d03" .= x.d03
, "d04" .= x.d04
, "d05" .= x.d05
, "d06" .= x.d06
, "d07" .= x.d07
, "d08" .= x.d08
, "d09" .= x.d09
, "d10" .= x.d10
]
instance FromYaml D where
parseYaml = withMapping $ \o ->
D
<$> parseField o "d01"
<*> parseFieldMaybe o "d02"
<*> parseFieldDefault o "d03" 0
<*> parseField o "d04"
<*> parseFieldMaybe o "d05"
<*> parseFieldDefault o "d06" 0
<*> parseField o "d07"
<*> parseFieldMaybe o "d08"
<*> parseFieldDefault o "d09" 0
<*> parseField o "d10"
data P a = P
{ p01 :: T.Text
, p02 :: Maybe a
, p03 :: a
, p04 :: T.Text
, p05 :: Maybe a
, p06 :: a
, p07 :: T.Text
, p08 :: Maybe a
, p09 :: a
, p10 :: T.Text
}
deriving stock (Generic)
deriving anyclass (NFData)
instance ToYaml a => ToYaml (P a) where
toYaml x =
mapping
[ "p01" .= x.p01
, "p02" .= x.p02
, "p03" .= x.p03
, "p04" .= x.p04
, "p05" .= x.p05
, "p06" .= x.p06
, "p07" .= x.p07
, "p08" .= x.p08
, "p09" .= x.p09
, "p10" .= x.p10
]
instance (FromYaml a, Num a) => FromYaml (P a) where
parseYaml = withMapping $ \o ->
P
<$> parseField o "p01"
<*> parseFieldMaybe o "p02"
<*> parseFieldDefault o "p03" 0
<*> parseField o "p04"
<*> parseFieldMaybe o "p05"
<*> parseFieldDefault o "p06" 0
<*> parseField o "p07"
<*> parseFieldMaybe o "p08"
<*> parseFieldDefault o "p09" 0
<*> parseField o "p10"
-- | A record that leaves out its null fields.
data O = O
{ o01 :: T.Text
, o02 :: Maybe Int
, o03 :: Int
, o04 :: T.Text
, o05 :: Maybe Int
, o06 :: Int
, o07 :: T.Text
, o08 :: Maybe Int
, o09 :: Int
, o10 :: T.Text
}
instance ToYaml O where
toYaml x =
mapping $
["o01" .= x.o01]
++ present "o02" x.o02
++ ["o03" .= x.o03, "o04" .= x.o04]
++ present "o05" x.o05
++ ["o06" .= x.o06, "o07" .= x.o07]
++ present "o08" x.o08
++ ["o09" .= x.o09, "o10" .= x.o10]
-- | 'O' with a default. Only the generic encoder uses it.
data E = E
{ e01 :: T.Text
, e02 :: Maybe Int
, e03 :: Int
, e04 :: T.Text
, e05 :: Maybe Int
, e06 :: Int
, e07 :: T.Text
, e08 :: Maybe Int
, e09 :: Int
, e10 :: T.Text
}
instance ToYaml E where
toYaml x =
mapping $
["e01" .= x.e01]
++ present "e02" x.e02
++ ["e03" .= x.e03, "e04" .= x.e04]
++ present "e05" x.e05
++ ["e06" .= x.e06, "e07" .= x.e07]
++ present "e08" x.e08
++ ["e09" .= x.e09, "e10" .= x.e10]
-- | The entry of a field that is not 'Nothing'.
present :: ToYaml a => T.Text -> Maybe a -> [(Node, Node)]
present key = maybe [] (\v -> [key .= v])
-- | A sum of records with the default encoding.
data X = X1 A | X2 B | X3 C
deriving stock (Generic)
deriving anyclass (NFData)
instance ToYaml X where
toYaml = \case
X1 a -> tagged "X1" a
X2 b -> tagged "X2" b
X3 c -> tagged "X3" c
where
tagged :: ToYaml a => T.Text -> a -> Node
tagged t a = mapping ["tag" .= t, "contents" .= a]
instance FromYaml X where
parseYaml = withMapping $ \o -> do
tag <- parseField o "tag"
case tag :: T.Text of
"X1" -> X1 <$> parseField o "contents"
"X2" -> X2 <$> parseField o "contents"
"X3" -> X3 <$> parseField o "contents"
_ -> fail ("unknown tag " ++ show tag)
-- | The same sum with flat fields.
data F = F1 A | F2 B | F3 C
deriving stock (Generic)
deriving anyclass (NFData)
instance ToYaml F where
toYaml = \case
F1 a -> tagged "F1" (toYaml a)
F2 b -> tagged "F2" (toYaml b)
F3 c -> tagged "F3" (toYaml c)
where
tagged :: T.Text -> Node -> Node
tagged t n = case view n of
MappingView kvs -> mapping (("tag" .= t) : kvs)
_ -> mapping ["tag" .= t, "contents" .= n]
instance FromYaml F where
parseYaml = withMapping $ \o -> do
tag <- parseField o "tag"
case tag :: T.Text of
"F1" -> F1 <$> parseYaml (objectNode o)
"F2" -> F2 <$> parseYaml (objectNode o)
"F3" -> F3 <$> parseYaml (objectNode o)
_ -> fail ("unknown tag " ++ show tag)
mkX :: Int -> X
mkX i = case i `mod` 3 of
0 -> X1 (fields A i)
1 -> X2 (fields B i)
_ -> X3 (fields C i)
mkF :: Int -> F
mkF i = case i `mod` 3 of
0 -> F1 (fields A i)
1 -> F2 (fields B i)
_ -> F3 (fields C i)