{-# 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 #-}