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

module Argo.Json.Boolean where

import Control.Applicative ((<|>))

import qualified Argo.Decoder as Decoder
import qualified Argo.Encoder as Encoder
import qualified Argo.Literal as Literal
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)

encode :: Boolean -> Encoder.Encoder ()
encode :: Boolean -> Encoder ()
encode (Boolean Bool
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 Bool
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
Boolean Bool
False Boolean -> Decoder () -> Decoder Boolean
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> Decoder ()
Decoder.byteString ByteString
Literal.false Decoder Boolean -> Decoder () -> Decoder Boolean
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Decoder ()
Decoder.spaces

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