{-# LANGUAGE PatternSynonyms #-}

module Argo.Internal.Pattern where

import qualified Argo.Internal.Json.Array as Array
import qualified Argo.Internal.Json.Boolean as Boolean
import qualified Argo.Internal.Json.Member as Member
import qualified Argo.Internal.Json.Name as Name
import qualified Argo.Internal.Json.Null as Null
import qualified Argo.Internal.Json.Number as Number
import qualified Argo.Internal.Json.Object as Object
import qualified Argo.Internal.Json.String as String
import qualified Argo.Internal.Json.Value as Value
import qualified Argo.Internal.Type.Decimal as Decimal
import qualified Argo.Vendor.Text as Text

pattern Null :: Value.Value
pattern $bNull :: Value
$mNull :: forall {r}. Value -> ((# #) -> r) -> ((# #) -> r) -> r
Null = Value.Null (Null.Null ())

pattern Boolean :: Bool -> Value.Value
pattern $bBoolean :: Bool -> Value
$mBoolean :: forall {r}. Value -> (Bool -> r) -> ((# #) -> r) -> r
Boolean x = Value.Boolean (Boolean.Boolean x)

pattern Number :: Decimal.Decimal -> Value.Value
pattern $bNumber :: Decimal -> Value
$mNumber :: forall {r}. Value -> (Decimal -> r) -> ((# #) -> r) -> r
Number x = Value.Number (Number.Number x)

pattern String :: Text.Text -> Value.Value
pattern $bString :: Text -> Value
$mString :: forall {r}. Value -> (Text -> r) -> ((# #) -> r) -> r
String x = Value.String (String.String x)

pattern Array :: [Value.Value] -> Value.Value
pattern $bArray :: [Value] -> Value
$mArray :: forall {r}. Value -> ([Value] -> r) -> ((# #) -> r) -> r
Array x = Value.Array (Array.Array x)

pattern Object :: [Member.Member Value.Value] -> Value.Value
pattern $bObject :: [Member Value] -> Value
$mObject :: forall {r}. Value -> ([Member Value] -> r) -> ((# #) -> r) -> r
Object x = Value.Object (Object.Object x)

{-# COMPLETE Null, Boolean, Number, String, Array, Object #-}

pattern Name :: Text.Text -> Name.Name
pattern $bName :: Text -> Name
$mName :: forall {r}. Name -> (Text -> r) -> ((# #) -> r) -> r
Name x = Name.Name (String.String x)

{-# COMPLETE Name #-}

pattern Decimal :: Integer -> Integer -> Decimal.Decimal
pattern $bDecimal :: Integer -> Integer -> Decimal
$mDecimal :: forall {r}.
Decimal -> (Integer -> Integer -> r) -> ((# #) -> r) -> r
Decimal s e <- Decimal.Decimal s e where
    Decimal Integer
s Integer
e = Integer -> Integer -> Decimal
Decimal.decimal Integer
s Integer
e

{-# COMPLETE Decimal #-}