module Argo.QuasiQuoter where

import qualified Argo.Decode as Decode
import qualified Data.Text as Text
import qualified Data.Text.Encoding as Text
import qualified Language.Haskell.TH.Quote as QQ
import qualified Language.Haskell.TH.Syntax as TH

value :: QQ.QuasiQuoter
value :: QuasiQuoter
value = QuasiQuoter :: (String -> Q Exp)
-> (String -> Q Pat)
-> (String -> Q Type)
-> (String -> Q [Dec])
-> QuasiQuoter
QQ.QuasiQuoter
    { quoteDec :: String -> Q [Dec]
QQ.quoteDec = Q [Dec] -> String -> Q [Dec]
forall a b. a -> b -> a
const (Q [Dec] -> String -> Q [Dec]) -> Q [Dec] -> String -> Q [Dec]
forall a b. (a -> b) -> a -> b
$ String -> Q [Dec]
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"quoteDec"
    , quoteExp :: String -> Q Exp
QQ.quoteExp = Q Exp -> (Value -> Q Exp) -> Maybe Value -> Q Exp
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Q Exp
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid JSON") Value -> Q Exp
forall t. Lift t => t -> Q Exp
TH.lift
        (Maybe Value -> Q Exp)
-> (String -> Maybe Value) -> String -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Maybe Value) -> ByteString -> Maybe Value
forall a. (Value -> Maybe a) -> ByteString -> Maybe a
Decode.decodeWith Value -> Maybe Value
forall (f :: * -> *) a. Applicative f => a -> f a
pure
        (ByteString -> Maybe Value)
-> (String -> ByteString) -> String -> Maybe Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
Text.encodeUtf8
        (Text -> ByteString) -> (String -> Text) -> String -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack
    , quotePat :: String -> Q Pat
QQ.quotePat = Q Pat -> String -> Q Pat
forall a b. a -> b -> a
const (Q Pat -> String -> Q Pat) -> Q Pat -> String -> Q Pat
forall a b. (a -> b) -> a -> b
$ String -> Q Pat
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"quotePat"
    , quoteType :: String -> Q Type
QQ.quoteType = Q Type -> String -> Q Type
forall a b. a -> b -> a
const (Q Type -> String -> Q Type) -> Q Type -> String -> Q Type
forall a b. (a -> b) -> a -> b
$ String -> Q Type
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"quoteType"
    }