{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveLift #-}

module Argo.Json.Boolean where

import Control.Applicative ((<|>))

import qualified Argo.Literal as Literal
import qualified Argo.Type.Decoder as Decoder
import qualified Argo.Type.Encoder as Encoder
import qualified Argo.Vendor.Builder as Builder
import qualified Argo.Vendor.DeepSeq as DeepSeq
import qualified Argo.Vendor.TemplateHaskell as TH
import qualified Argo.Vendor.Transformers as Trans
import qualified GHC.Generics as Generics

newtype Boolean
    = Boolean Bool
    deriving (Boolean -> Boolean -> Bool
(Boolean -> Boolean -> Bool)
-> (Boolean -> Boolean -> Bool) -> Eq Boolean
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Boolean -> Boolean -> Bool
$c/= :: Boolean -> Boolean -> Bool
== :: Boolean -> Boolean -> Bool
$c== :: Boolean -> Boolean -> Bool
Eq, (forall x. Boolean -> Rep Boolean x)
-> (forall x. Rep Boolean x -> Boolean) -> Generic Boolean
forall x. Rep Boolean x -> Boolean
forall x. Boolean -> Rep Boolean x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Boolean x -> Boolean
$cfrom :: forall x. Boolean -> Rep Boolean x
Generics.Generic, Boolean -> Q Exp
Boolean -> Q (TExp Boolean)
(Boolean -> Q Exp) -> (Boolean -> Q (TExp Boolean)) -> Lift Boolean
forall t. (t -> Q Exp) -> (t -> Q (TExp t)) -> Lift t
liftTyped :: Boolean -> Q (TExp Boolean)
$cliftTyped :: Boolean -> Q (TExp Boolean)
lift :: Boolean -> Q Exp
$clift :: Boolean -> Q Exp
TH.Lift, Boolean -> ()
(Boolean -> ()) -> NFData Boolean
forall a. (a -> ()) -> NFData a
rnf :: Boolean -> ()
$crnf :: Boolean -> ()
DeepSeq.NFData, Int -> Boolean -> ShowS
[Boolean] -> ShowS
Boolean -> String
(Int -> Boolean -> ShowS)
-> (Boolean -> String) -> ([Boolean] -> ShowS) -> Show Boolean
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Boolean] -> ShowS
$cshowList :: [Boolean] -> ShowS
show :: Boolean -> String
$cshow :: Boolean -> String
showsPrec :: Int -> Boolean -> ShowS
$cshowsPrec :: Int -> Boolean -> ShowS
Show)

fromBool :: Bool -> Boolean
fromBool :: Bool -> Boolean
fromBool = Bool -> Boolean
Boolean

toBool :: Boolean -> Bool
toBool :: Boolean -> Bool
toBool (Boolean Bool
x) = Bool
x

encode :: Boolean -> Encoder.Encoder ()
encode :: Boolean -> Encoder ()
encode Boolean
x = WriterT Builder Identity () -> Encoder ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (WriterT Builder Identity () -> Encoder ())
-> (ByteString -> WriterT Builder Identity ())
-> ByteString
-> Encoder ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> WriterT Builder Identity ()
forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
Trans.tell (Builder -> WriterT Builder Identity ())
-> (ByteString -> Builder)
-> ByteString
-> WriterT Builder Identity ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Builder
Builder.byteString (ByteString -> Encoder ()) -> ByteString -> Encoder ()
forall a b. (a -> b) -> a -> b
$ if Boolean -> Bool
toBool Boolean
x
    then ByteString
Literal.true
    else ByteString
Literal.false

decode :: Decoder.Decoder Boolean
decode :: Decoder Boolean
decode = Decoder Boolean
decodeFalse Decoder Boolean -> Decoder Boolean -> Decoder Boolean
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Decoder Boolean
decodeTrue

decodeFalse :: Decoder.Decoder Boolean
decodeFalse :: Decoder Boolean
decodeFalse =
    Bool -> Boolean
fromBool Bool
False Boolean
-> StateT ByteString (ExceptT String Identity) ()
-> Decoder Boolean
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> StateT ByteString (ExceptT String Identity) ()
Decoder.byteString ByteString
Literal.false Decoder Boolean
-> StateT ByteString (ExceptT String Identity) ()
-> Decoder Boolean
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* StateT ByteString (ExceptT String Identity) ()
Decoder.spaces

decodeTrue :: Decoder.Decoder Boolean
decodeTrue :: Decoder Boolean
decodeTrue =
    Bool -> Boolean
fromBool Bool
True Boolean
-> StateT ByteString (ExceptT String Identity) ()
-> Decoder Boolean
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> StateT ByteString (ExceptT String Identity) ()
Decoder.byteString ByteString
Literal.true Decoder Boolean
-> StateT ByteString (ExceptT String Identity) ()
-> Decoder Boolean
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* StateT ByteString (ExceptT String Identity) ()
Decoder.spaces