{-# LANGUAGE DeriveLift #-}

module Argo.Internal.Json.Boolean where

import Control.Applicative ((<|>))

import qualified Argo.Internal.Literal as Literal
import qualified Argo.Internal.Type.Decoder as Decoder
import qualified Argo.Internal.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

newtype Boolean
    = Boolean Bool
    deriving (Boolean -> Boolean -> Bool
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 t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Boolean -> m Exp
forall (m :: * -> *). Quote m => Boolean -> Code m Boolean
liftTyped :: forall (m :: * -> *). Quote m => Boolean -> Code m Boolean
$cliftTyped :: forall (m :: * -> *). Quote m => Boolean -> Code m Boolean
lift :: forall (m :: * -> *). Quote m => Boolean -> m Exp
$clift :: forall (m :: * -> *). Quote m => Boolean -> m Exp
TH.Lift, Int -> Boolean -> ShowS
[Boolean] -> ShowS
Boolean -> String
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)

instance DeepSeq.NFData Boolean where
    rnf :: Boolean -> ()
rnf = forall a. NFData a => a -> ()
DeepSeq.rnf forall b c a. (b -> c) -> (a -> b) -> a -> c
. Boolean -> Bool
toBool

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 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
Trans.tell forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Builder
Builder.byteString 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 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 forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> Decoder ()
Decoder.byteString ByteString
Literal.false 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
fromBool Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> Decoder ()
Decoder.byteString ByteString
Literal.true forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Decoder ()
Decoder.spaces