{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveLift #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskellQuotes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Data.Morpheus.Types.Internal.AST.Value
  ( Value (..),
    ScalarValue (..),
    Object,
    replaceValue,
    decodeScientific,
    RawValue,
    ValidValue,
    RawObject,
    ValidObject,
    Variable (..),
    ResolvedValue,
    ResolvedObject,
    VariableContent (..),
    ObjectEntry (..),
    VariableDefinitions,
  )
where

-- MORPHEUS
import qualified Data.Aeson as A
  ( FromJSON (..),
    ToJSON (..),
    Value (..),
    object,
    pairs,
    (.=),
  )
import Data.Foldable (foldr')
import Data.Mergeable
  ( NameCollision (..),
    OrdMap,
  )
import Data.Morpheus.Internal.Utils
  ( KeyOf (..),
    toAssoc,
    unsafeFromList,
  )
import Data.Morpheus.Rendering.RenderGQL
  ( RenderGQL (..),
    fromText,
    render,
    renderInputSeq,
    space,
  )
import Data.Morpheus.Types.Internal.AST.Base
  ( Position,
    Ref (..),
  )
import Data.Morpheus.Types.Internal.AST.Error
  ( GQLError,
    Msg (..),
    at,
  )
import Data.Morpheus.Types.Internal.AST.Name
  ( FieldName,
    TypeName,
    packName,
    unpackName,
  )
import Data.Morpheus.Types.Internal.AST.Stage
  ( CONST,
    CONST_OR_VALID,
    RAW,
    Stage,
    VALID,
  )
import Data.Morpheus.Types.Internal.AST.Type (TypeRef (..))
import Data.Scientific
  ( Scientific,
    floatingOrInteger,
  )
import qualified Data.Text as T
import qualified Data.Vector as V
import Instances.TH.Lift ()
import Language.Haskell.TH.Syntax (Lift (..))
import Relude

-- | Primitive Values for GQLScalar: 'Int', 'Float', 'String', 'Boolean'.
-- for performance reason type 'Text' represents GraphQl 'String' value
data ScalarValue
  = Int Int
  | Float Double
  | String Text
  | Boolean Bool
  | Value A.Value
  deriving (Int -> ScalarValue -> ShowS
[ScalarValue] -> ShowS
ScalarValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScalarValue] -> ShowS
$cshowList :: [ScalarValue] -> ShowS
show :: ScalarValue -> String
$cshow :: ScalarValue -> String
showsPrec :: Int -> ScalarValue -> ShowS
$cshowsPrec :: Int -> ScalarValue -> ShowS
Show, ScalarValue -> ScalarValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScalarValue -> ScalarValue -> Bool
$c/= :: ScalarValue -> ScalarValue -> Bool
== :: ScalarValue -> ScalarValue -> Bool
$c== :: ScalarValue -> ScalarValue -> Bool
Eq, forall x. Rep ScalarValue x -> ScalarValue
forall x. ScalarValue -> Rep ScalarValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ScalarValue x -> ScalarValue
$cfrom :: forall x. ScalarValue -> Rep ScalarValue x
Generic, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => ScalarValue -> m Exp
forall (m :: * -> *). Quote m => ScalarValue -> Code m ScalarValue
liftTyped :: forall (m :: * -> *). Quote m => ScalarValue -> Code m ScalarValue
$cliftTyped :: forall (m :: * -> *). Quote m => ScalarValue -> Code m ScalarValue
lift :: forall (m :: * -> *). Quote m => ScalarValue -> m Exp
$clift :: forall (m :: * -> *). Quote m => ScalarValue -> m Exp
Lift)

instance IsString ScalarValue where
  fromString :: String -> ScalarValue
fromString = Text -> ScalarValue
String forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

instance RenderGQL ScalarValue where
  renderGQL :: ScalarValue -> Rendering
renderGQL (Int Int
x) = forall a. RenderGQL a => a -> Rendering
renderGQL Int
x
  renderGQL (Float Double
x) = forall a. RenderGQL a => a -> Rendering
renderGQL Double
x
  renderGQL (String Text
x) = forall a. RenderGQL a => a -> Rendering
renderGQL Text
x
  renderGQL (Boolean Bool
x) = forall a. RenderGQL a => a -> Rendering
renderGQL Bool
x
  renderGQL (Value Value
x) = forall a. RenderGQL a => a -> Rendering
renderGQL Value
x

instance A.ToJSON ScalarValue where
  toJSON :: ScalarValue -> Value
toJSON (Float Double
x) = forall a. ToJSON a => a -> Value
A.toJSON Double
x
  toJSON (Int Int
x) = forall a. ToJSON a => a -> Value
A.toJSON Int
x
  toJSON (Boolean Bool
x) = forall a. ToJSON a => a -> Value
A.toJSON Bool
x
  toJSON (String Text
x) = forall a. ToJSON a => a -> Value
A.toJSON Text
x
  toJSON (Value Value
x) = forall a. ToJSON a => a -> Value
A.toJSON Value
x

instance A.FromJSON ScalarValue where
  parseJSON :: Value -> Parser ScalarValue
parseJSON (A.Bool Bool
v) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Bool -> ScalarValue
Boolean Bool
v
  parseJSON (A.Number Scientific
v) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Scientific -> ScalarValue
decodeScientific Scientific
v
  parseJSON (A.String Text
v) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> ScalarValue
String Text
v
  parseJSON Value
notScalar = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Expected Scalar got :" forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show Value
notScalar

data VariableContent (stage :: Stage) where
  DefaultValue :: Maybe ResolvedValue -> VariableContent CONST
  ValidVariableValue :: {VariableContent VALID -> ValidValue
validVarContent :: ValidValue} -> VariableContent VALID

instance Lift (VariableContent a) where
  lift :: forall (m :: * -> *). Quote m => VariableContent a -> m Exp
lift (DefaultValue Maybe ResolvedValue
x) = [|DefaultValue x|]
  lift (ValidVariableValue ValidValue
x) = [|ValidVariableValue x|]

#if MIN_VERSION_template_haskell(2,16,0)
  liftTyped :: forall (m :: * -> *).
Quote m =>
VariableContent a -> Code m (VariableContent a)
liftTyped (DefaultValue Maybe ResolvedValue
x) = [||DefaultValue x||]
  liftTyped (ValidVariableValue ValidValue
x) = [||ValidVariableValue x||]
#endif
deriving instance Show (VariableContent a)

deriving instance Eq (VariableContent a)

data Variable (stage :: Stage) = Variable
  { forall (stage :: Stage). Variable stage -> Position
variablePosition :: Position,
    forall (stage :: Stage). Variable stage -> FieldName
variableName :: FieldName,
    forall (stage :: Stage). Variable stage -> TypeRef
variableType :: TypeRef,
    forall (stage :: Stage).
Variable stage -> VariableContent (CONST_OR_VALID stage)
variableValue :: VariableContent (CONST_OR_VALID stage)
  }
  deriving (Int -> Variable stage -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (stage :: Stage). Int -> Variable stage -> ShowS
forall (stage :: Stage). [Variable stage] -> ShowS
forall (stage :: Stage). Variable stage -> String
showList :: [Variable stage] -> ShowS
$cshowList :: forall (stage :: Stage). [Variable stage] -> ShowS
show :: Variable stage -> String
$cshow :: forall (stage :: Stage). Variable stage -> String
showsPrec :: Int -> Variable stage -> ShowS
$cshowsPrec :: forall (stage :: Stage). Int -> Variable stage -> ShowS
Show, Variable stage -> Variable stage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (stage :: Stage). Variable stage -> Variable stage -> Bool
/= :: Variable stage -> Variable stage -> Bool
$c/= :: forall (stage :: Stage). Variable stage -> Variable stage -> Bool
== :: Variable stage -> Variable stage -> Bool
$c== :: forall (stage :: Stage). Variable stage -> Variable stage -> Bool
Eq, forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (stage :: Stage) (m :: * -> *).
Quote m =>
Variable stage -> m Exp
forall (stage :: Stage) (m :: * -> *).
Quote m =>
Variable stage -> Code m (Variable stage)
forall (m :: * -> *). Quote m => Variable stage -> m Exp
forall (m :: * -> *).
Quote m =>
Variable stage -> Code m (Variable stage)
liftTyped :: forall (m :: * -> *).
Quote m =>
Variable stage -> Code m (Variable stage)
$cliftTyped :: forall (stage :: Stage) (m :: * -> *).
Quote m =>
Variable stage -> Code m (Variable stage)
lift :: forall (m :: * -> *). Quote m => Variable stage -> m Exp
$clift :: forall (stage :: Stage) (m :: * -> *).
Quote m =>
Variable stage -> m Exp
Lift)

instance KeyOf FieldName (Variable s) where
  keyOf :: Variable s -> FieldName
keyOf = forall (stage :: Stage). Variable stage -> FieldName
variableName

instance NameCollision GQLError (Variable s) where
  nameCollision :: Variable s -> GQLError
nameCollision Variable {FieldName
variableName :: FieldName
variableName :: forall (stage :: Stage). Variable stage -> FieldName
variableName, Position
variablePosition :: Position
variablePosition :: forall (stage :: Stage). Variable stage -> Position
variablePosition} =
    (GQLError
"There can Be only One Variable Named " forall a. Semigroup a => a -> a -> a
<> forall a. Msg a => a -> GQLError
msg FieldName
variableName)
      GQLError -> Position -> GQLError
`at` Position
variablePosition

type VariableDefinitions s = OrdMap FieldName (Variable s)

data Value (stage :: Stage) where
  ResolvedVariable :: Ref FieldName -> Variable VALID -> Value CONST
  VariableValue :: Ref FieldName -> Value RAW
  Object :: Object stage -> Value stage
  List :: [Value stage] -> Value stage
  Enum :: TypeName -> Value stage
  Scalar :: ScalarValue -> Value stage
  Null :: Value stage

instance IsString (Value stage) where
  fromString :: String -> Value stage
fromString = forall (stage :: Stage). ScalarValue -> Value stage
Scalar forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => String -> a
fromString

deriving instance Show (Value a)

deriving instance Eq (Value s)

data ObjectEntry (s :: Stage) = ObjectEntry
  { forall (s :: Stage). ObjectEntry s -> FieldName
entryName :: FieldName,
    forall (s :: Stage). ObjectEntry s -> Value s
entryValue :: Value s
  }
  deriving (ObjectEntry s -> ObjectEntry s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (s :: Stage). ObjectEntry s -> ObjectEntry s -> Bool
/= :: ObjectEntry s -> ObjectEntry s -> Bool
$c/= :: forall (s :: Stage). ObjectEntry s -> ObjectEntry s -> Bool
== :: ObjectEntry s -> ObjectEntry s -> Bool
$c== :: forall (s :: Stage). ObjectEntry s -> ObjectEntry s -> Bool
Eq, Int -> ObjectEntry s -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (s :: Stage). Int -> ObjectEntry s -> ShowS
forall (s :: Stage). [ObjectEntry s] -> ShowS
forall (s :: Stage). ObjectEntry s -> String
showList :: [ObjectEntry s] -> ShowS
$cshowList :: forall (s :: Stage). [ObjectEntry s] -> ShowS
show :: ObjectEntry s -> String
$cshow :: forall (s :: Stage). ObjectEntry s -> String
showsPrec :: Int -> ObjectEntry s -> ShowS
$cshowsPrec :: forall (s :: Stage). Int -> ObjectEntry s -> ShowS
Show)

instance RenderGQL (ObjectEntry a) where
  renderGQL :: ObjectEntry a -> Rendering
renderGQL (ObjectEntry FieldName
name Value a
value) = Text -> Rendering
fromText (forall a (t :: NAME). NamePacking a => Name t -> a
unpackName FieldName
name) forall a. Semigroup a => a -> a -> a
<> Rendering
": " forall a. Semigroup a => a -> a -> a
<> forall a. RenderGQL a => a -> Rendering
renderGQL Value a
value

instance NameCollision GQLError (ObjectEntry s) where
  nameCollision :: ObjectEntry s -> GQLError
nameCollision ObjectEntry {FieldName
entryName :: FieldName
entryName :: forall (s :: Stage). ObjectEntry s -> FieldName
entryName} =
    GQLError
"There can Be only One field Named "
      forall a. Semigroup a => a -> a -> a
<> forall a. Msg a => a -> GQLError
msg FieldName
entryName

instance KeyOf FieldName (ObjectEntry s) where
  keyOf :: ObjectEntry s -> FieldName
keyOf = forall (s :: Stage). ObjectEntry s -> FieldName
entryName

type Object a = OrdMap FieldName (ObjectEntry a)

type ValidObject = Object VALID

type RawObject = Object RAW

type ResolvedObject = Object CONST

type RawValue = Value RAW

type ValidValue = Value VALID

type ResolvedValue = Value CONST

deriving instance Lift (Value a)

deriving instance Lift (ObjectEntry a)

instance RenderGQL (Value a) where
  renderGQL :: Value a -> Rendering
renderGQL (ResolvedVariable Ref {FieldName
refName :: forall name. Ref name -> name
refName :: FieldName
refName} Variable VALID
_) = Rendering
"$" forall a. Semigroup a => a -> a -> a
<> forall a. RenderGQL a => a -> Rendering
renderGQL FieldName
refName
  renderGQL (VariableValue Ref {FieldName
refName :: FieldName
refName :: forall name. Ref name -> name
refName}) = Rendering
"$" forall a. Semigroup a => a -> a -> a
<> forall a. RenderGQL a => a -> Rendering
renderGQL FieldName
refName forall a. Semigroup a => a -> a -> a
<> Rendering
" "
  renderGQL Value a
Null = Rendering
"null"
  renderGQL (Enum TypeName
x) = forall a. RenderGQL a => a -> Rendering
renderGQL TypeName
x
  renderGQL (Scalar ScalarValue
x) = forall a. RenderGQL a => a -> Rendering
renderGQL ScalarValue
x
  renderGQL (Object Object a
xs) = Rendering
"{" forall a. Semigroup a => a -> a -> a
<> Rendering
entries forall a. Semigroup a => a -> a -> a
<> Rendering
"}"
    where
      entries :: Rendering
entries
        | forall (t :: * -> *) a. Foldable t => t a -> Bool
null Object a
xs = Rendering
""
        | Bool
otherwise = Rendering
space forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) a.
(Foldable t, RenderGQL a) =>
t a -> Rendering
renderInputSeq (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Object a
xs) forall a. Semigroup a => a -> a -> a
<> Rendering
space
  renderGQL (List [Value a]
list) = Rendering
"[" forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) a.
(Foldable t, RenderGQL a) =>
t a -> Rendering
renderInputSeq [Value a]
list forall a. Semigroup a => a -> a -> a
<> Rendering
"]"

instance Msg (Value a) where
  msg :: Value a -> GQLError
msg = forall a. Msg a => a -> GQLError
msg forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. RenderGQL a => a -> ByteString
render

instance A.ToJSON (Value a) where
  toJSON :: Value a -> Value
toJSON (ResolvedVariable Ref FieldName
_ Variable {variableValue :: forall (stage :: Stage).
Variable stage -> VariableContent (CONST_OR_VALID stage)
variableValue = ValidVariableValue ValidValue
x}) =
    forall a. ToJSON a => a -> Value
A.toJSON ValidValue
x
  toJSON (VariableValue Ref {FieldName
refName :: FieldName
refName :: forall name. Ref name -> name
refName}) =
    Text -> Value
A.String forall a b. (a -> b) -> a -> b
$ Text
"($ref:" forall a. Semigroup a => a -> a -> a
<> forall a (t :: NAME). NamePacking a => Name t -> a
unpackName FieldName
refName forall a. Semigroup a => a -> a -> a
<> Text
")"
  toJSON Value a
Null = Value
A.Null
  toJSON (Enum TypeName
x) = Text -> Value
A.String (forall a (t :: NAME). NamePacking a => Name t -> a
unpackName TypeName
x)
  toJSON (Scalar ScalarValue
x) = forall a. ToJSON a => a -> Value
A.toJSON ScalarValue
x
  toJSON (List [Value a]
x) = forall a. ToJSON a => a -> Value
A.toJSON [Value a]
x
  toJSON (Object Object a
fields) = [Pair] -> Value
A.object forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {kv} {s :: Stage}. KeyValue kv => ObjectEntry s -> kv
toEntry (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Object a
fields)
    where
      toEntry :: ObjectEntry s -> kv
toEntry (ObjectEntry FieldName
name Value s
value) = forall a (t :: NAME). NamePacking a => Name t -> a
unpackName FieldName
name forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
A..= forall a. ToJSON a => a -> Value
A.toJSON Value s
value

  -------------------------------------------
  toEncoding :: Value a -> Encoding
toEncoding (ResolvedVariable Ref FieldName
_ Variable {variableValue :: forall (stage :: Stage).
Variable stage -> VariableContent (CONST_OR_VALID stage)
variableValue = ValidVariableValue ValidValue
x}) =
    forall a. ToJSON a => a -> Encoding
A.toEncoding ValidValue
x
  toEncoding (VariableValue Ref {FieldName
refName :: FieldName
refName :: forall name. Ref name -> name
refName}) =
    forall a. ToJSON a => a -> Encoding
A.toEncoding forall a b. (a -> b) -> a -> b
$ FieldName
"($ref:" forall a. Semigroup a => a -> a -> a
<> FieldName
refName forall a. Semigroup a => a -> a -> a
<> FieldName
")"
  toEncoding Value a
Null = forall a. ToJSON a => a -> Encoding
A.toEncoding Value
A.Null
  toEncoding (Enum TypeName
x) = forall a. ToJSON a => a -> Encoding
A.toEncoding TypeName
x
  toEncoding (Scalar ScalarValue
x) = forall a. ToJSON a => a -> Encoding
A.toEncoding ScalarValue
x
  toEncoding (List [Value a]
x) = forall a. ToJSON a => a -> Encoding
A.toEncoding [Value a]
x
  toEncoding (Object Object a
ordMap) = Series -> Encoding
A.pairs forall a b. (a -> b) -> a -> b
$ forall p e. (Semigroup p, Monoid p) => (e -> p) -> [e] -> p
renderSeries forall {kv} {s :: Stage}. KeyValue kv => ObjectEntry s -> kv
encodeField (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Object a
ordMap)
    where
      encodeField :: ObjectEntry s -> kv
encodeField (ObjectEntry FieldName
key Value s
value) = forall a (t :: NAME). NamePacking a => Name t -> a
unpackName FieldName
key forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
A..= Value s
value

-- fixes GHC 8.2.2, which can't deduce (Semigroup p) from context (Monoid p)
renderSeries :: (Semigroup p, Monoid p) => (e -> p) -> [e] -> p
renderSeries :: forall p e. (Semigroup p, Monoid p) => (e -> p) -> [e] -> p
renderSeries e -> p
_ [] = forall a. Monoid a => a
mempty
renderSeries e -> p
f (e
x : [e]
xs) = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr' (\e
e p
es -> p
es forall a. Semigroup a => a -> a -> a
<> e -> p
f e
e) (e -> p
f e
x) [e]
xs

decodeScientific :: Scientific -> ScalarValue
decodeScientific :: Scientific -> ScalarValue
decodeScientific Scientific
v = case forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
v of
  Left Double
float -> Double -> ScalarValue
Float Double
float
  Right Int
int -> Int -> ScalarValue
Int Int
int

replaceValue :: A.Value -> Value a
replaceValue :: forall (a :: Stage). Value -> Value a
replaceValue (A.Bool Bool
v) = forall (s :: Stage). Bool -> Value s
mkBoolean Bool
v
replaceValue (A.Number Scientific
v) = forall (stage :: Stage). ScalarValue -> Value stage
Scalar forall a b. (a -> b) -> a -> b
$ Scientific -> ScalarValue
decodeScientific Scientific
v
replaceValue (A.String Text
v) = forall (s :: Stage). Text -> Value s
mkString Text
v
replaceValue (A.Object Object
v) =
  forall (s :: Stage). [(FieldName, Value s)] -> Value s
mkObject forall a b. (a -> b) -> a -> b
$
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      (forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap forall a (t :: NAME). NamePacking a => a -> Name t
packName forall (a :: Stage). Value -> Value a
replaceValue)
      (forall k (m :: * -> *) a. IsMap k m => m a -> [(k, a)]
toAssoc Object
v)
replaceValue (A.Array Array
li) = forall (stage :: Stage). [Value stage] -> Value stage
List (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (a :: Stage). Value -> Value a
replaceValue (forall a. Vector a -> [a]
V.toList Array
li))
replaceValue Value
A.Null = forall (stage :: Stage). Value stage
Null

instance A.FromJSON (Value a) where
  parseJSON :: Value -> Parser (Value a)
parseJSON = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (a :: Stage). Value -> Value a
replaceValue

-- DEFAULT VALUES

mkBoolean :: Bool -> Value s
mkBoolean :: forall (s :: Stage). Bool -> Value s
mkBoolean = forall (stage :: Stage). ScalarValue -> Value stage
Scalar forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> ScalarValue
Boolean

mkString :: Text -> Value s
mkString :: forall (s :: Stage). Text -> Value s
mkString = forall (stage :: Stage). ScalarValue -> Value stage
Scalar forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ScalarValue
String

mkObject :: [(FieldName, Value s)] -> Value s
mkObject :: forall (s :: Stage). [(FieldName, Value s)] -> Value s
mkObject = forall (stage :: Stage). Object stage -> Value stage
Object forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k (m :: * -> *) a. IsMap k m => [(k, a)] -> m a
unsafeFromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall {s :: Stage}.
(FieldName, Value s) -> (FieldName, ObjectEntry s)
toEntry
  where
    toEntry :: (FieldName, Value s) -> (FieldName, ObjectEntry s)
toEntry (FieldName
key, Value s
value) = (FieldName
key, forall (s :: Stage). FieldName -> Value s -> ObjectEntry s
ObjectEntry FieldName
key Value s
value)

instance Hashable (Value a) where
  hashWithSalt :: Int -> Value a -> Int
hashWithSalt Int
s (Object Object a
x) = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Int
0 :: Int, forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Object a
x)
  hashWithSalt Int
s (List [Value a]
x) = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Int
1 :: Int, [Value a]
x)
  hashWithSalt Int
s (Enum TypeName
x) = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Int
2 :: Int, TypeName
x)
  hashWithSalt Int
s (Scalar ScalarValue
x) = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Int
3 :: Int, forall b a. (Show a, IsString b) => a -> b
show ScalarValue
x :: String)
  hashWithSalt Int
s Value a
Null = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Int
4 :: Int)
  hashWithSalt Int
s (ResolvedVariable Ref FieldName
_ Variable VALID
_) = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Int
5 :: Int)
  hashWithSalt Int
s (VariableValue Ref {FieldName
refName :: FieldName
refName :: forall name. Ref name -> name
refName}) = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (Int
6 :: Int, FieldName
refName)

instance Hashable (ObjectEntry s) where
  hashWithSalt :: Int -> ObjectEntry s -> Int
hashWithSalt Int
s (ObjectEntry FieldName
name Value s
value) = forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
s (FieldName
name, Value s
value)