packages feed

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)