{-# LANGUAGE FlexibleInstances #-}

module Argo.Class.HasCodec where

import Control.Applicative ((<|>))

import qualified Argo.Json.Array as Array
import qualified Argo.Json.Boolean as Boolean
import qualified Argo.Json.Member as Member
import qualified Argo.Json.Name as Name
import qualified Argo.Json.Null as Null
import qualified Argo.Json.Number as Number
import qualified Argo.Json.Object as Object
import qualified Argo.Json.String as String
import qualified Argo.Json.Value as Value
import qualified Argo.Pointer.Pointer as Pointer
import qualified Argo.Type.Codec as Codec
import qualified Argo.Type.Config as Config
import qualified Argo.Type.Decimal as Decimal
import qualified Argo.Type.Decoder as Decoder
import qualified Argo.Type.Encoder as Encoder
import qualified Argo.Type.Permission as Permission
import qualified Argo.Vendor.Builder as Builder
import qualified Argo.Vendor.ByteString as ByteString
import qualified Argo.Vendor.Map as Map
import qualified Argo.Vendor.Text as Text
import qualified Argo.Vendor.Transformers as Trans
import qualified Data.Bits as Bits
import qualified Data.Functor.Identity as Identity
import qualified Data.Int as Int
import qualified Data.List.NonEmpty as NonEmpty
import qualified Data.Word as Word

class HasCodec a where
    codec :: Codec.ValueCodec a

instance HasCodec Value.Value where
    codec :: ValueCodec Value
codec = Codec :: forall (r :: * -> *) (w :: * -> *) i o.
r o -> (i -> w o) -> CodecOf r w i o
Codec.Codec
        { decode :: ReaderT Value (ExceptT String Identity) Value
Codec.decode = ReaderT Value (ExceptT String Identity) Value
forall (m :: * -> *) r. Monad m => ReaderT r m r
Trans.ask
        , encode :: Value -> MaybeT (StateT Value Identity) Value
Codec.encode = (Value -> MaybeT (StateT Value Identity) ())
-> Value -> MaybeT (StateT Value Identity) Value
forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap ((Value -> MaybeT (StateT Value Identity) ())
 -> Value -> MaybeT (StateT Value Identity) Value)
-> (Value -> MaybeT (StateT Value Identity) ())
-> Value
-> MaybeT (StateT Value Identity) Value
forall a b. (a -> b) -> a -> b
$ StateT Value Identity () -> MaybeT (StateT Value Identity) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (StateT Value Identity () -> MaybeT (StateT Value Identity) ())
-> (Value -> StateT Value Identity ())
-> Value
-> MaybeT (StateT Value Identity) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> StateT Value Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put
        }

instance HasCodec Null.Null where
    codec :: ValueCodec Null
codec = String
-> (Null -> Value) -> (Value -> Maybe Null) -> ValueCodec Null
forall a.
String -> (a -> Value) -> (Value -> Maybe a) -> ValueCodec a
basicCodec String
"Null" Null -> Value
Value.Null ((Value -> Maybe Null) -> ValueCodec Null)
-> (Value -> Maybe Null) -> ValueCodec Null
forall a b. (a -> b) -> a -> b
$ \ Value
value -> case Value
value of
        Value.Null Null
null_ -> Null -> Maybe Null
forall a. a -> Maybe a
Just Null
null_
        Value
_ -> Maybe Null
forall a. Maybe a
Nothing

instance HasCodec Boolean.Boolean where
    codec :: ValueCodec Boolean
codec = String
-> (Boolean -> Value)
-> (Value -> Maybe Boolean)
-> ValueCodec Boolean
forall a.
String -> (a -> Value) -> (Value -> Maybe a) -> ValueCodec a
basicCodec String
"Boolean" Boolean -> Value
Value.Boolean ((Value -> Maybe Boolean) -> ValueCodec Boolean)
-> (Value -> Maybe Boolean) -> ValueCodec Boolean
forall a b. (a -> b) -> a -> b
$ \ Value
value -> case Value
value of
        Value.Boolean Boolean
boolean -> Boolean -> Maybe Boolean
forall a. a -> Maybe a
Just Boolean
boolean
        Value
_ -> Maybe Boolean
forall a. Maybe a
Nothing

instance HasCodec Number.Number where
    codec :: ValueCodec Number
codec = String
-> (Number -> Value)
-> (Value -> Maybe Number)
-> ValueCodec Number
forall a.
String -> (a -> Value) -> (Value -> Maybe a) -> ValueCodec a
basicCodec String
"Number" Number -> Value
Value.Number ((Value -> Maybe Number) -> ValueCodec Number)
-> (Value -> Maybe Number) -> ValueCodec Number
forall a b. (a -> b) -> a -> b
$ \ Value
value -> case Value
value of
        Value.Number Number
number -> Number -> Maybe Number
forall a. a -> Maybe a
Just Number
number
        Value
_ -> Maybe Number
forall a. Maybe a
Nothing

instance HasCodec String.String where
    codec :: ValueCodec String
codec = String
-> (String -> Value)
-> (Value -> Maybe String)
-> ValueCodec String
forall a.
String -> (a -> Value) -> (Value -> Maybe a) -> ValueCodec a
basicCodec String
"String" String -> Value
Value.String ((Value -> Maybe String) -> ValueCodec String)
-> (Value -> Maybe String) -> ValueCodec String
forall a b. (a -> b) -> a -> b
$ \ Value
value -> case Value
value of
        Value.String String
string -> String -> Maybe String
forall a. a -> Maybe a
Just String
string
        Value
_ -> Maybe String
forall a. Maybe a
Nothing

instance HasCodec a => HasCodec (Array.ArrayOf a) where
    codec :: ValueCodec (ArrayOf a)
codec = Codec :: forall (r :: * -> *) (w :: * -> *) i o.
r o -> (i -> w o) -> CodecOf r w i o
Codec.Codec
        { decode :: ReaderT Value (ExceptT String Identity) (ArrayOf a)
Codec.decode = do
            ArrayOf Value
array <- String
-> (Value -> Maybe (ArrayOf Value))
-> ReaderT Value (ExceptT String Identity) (ArrayOf Value)
forall a.
String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue String
"Array" ((Value -> Maybe (ArrayOf Value))
 -> ReaderT Value (ExceptT String Identity) (ArrayOf Value))
-> (Value -> Maybe (ArrayOf Value))
-> ReaderT Value (ExceptT String Identity) (ArrayOf Value)
forall a b. (a -> b) -> a -> b
$ \ Value
value -> case Value
value of
                Value.Array ArrayOf Value
array -> ArrayOf Value -> Maybe (ArrayOf Value)
forall a. a -> Maybe a
Just ArrayOf Value
array
                Value
_ -> Maybe (ArrayOf Value)
forall a. Maybe a
Nothing
            (String -> ReaderT Value (ExceptT String Identity) (ArrayOf a))
-> ([a] -> ReaderT Value (ExceptT String Identity) (ArrayOf a))
-> Either String [a]
-> ReaderT Value (ExceptT String Identity) (ArrayOf a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (ExceptT String Identity (ArrayOf a)
-> ReaderT Value (ExceptT String Identity) (ArrayOf a)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (ExceptT String Identity (ArrayOf a)
 -> ReaderT Value (ExceptT String Identity) (ArrayOf a))
-> (String -> ExceptT String Identity (ArrayOf a))
-> String
-> ReaderT Value (ExceptT String Identity) (ArrayOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ExceptT String Identity (ArrayOf a)
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
Trans.throwE) (ArrayOf a -> ReaderT Value (ExceptT String Identity) (ArrayOf a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArrayOf a -> ReaderT Value (ExceptT String Identity) (ArrayOf a))
-> ([a] -> ArrayOf a)
-> [a]
-> ReaderT Value (ExceptT String Identity) (ArrayOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> ArrayOf a
forall value. [value] -> ArrayOf value
Array.fromList)
                (Either String [a]
 -> ReaderT Value (ExceptT String Identity) (ArrayOf a))
-> ([Value] -> Either String [a])
-> [Value]
-> ReaderT Value (ExceptT String Identity) (ArrayOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Either String a) -> [Value] -> Either String [a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (ValueCodec a -> Value -> Either String a
forall a. ValueCodec a -> Value -> Either String a
Codec.decodeWith ValueCodec a
forall a. HasCodec a => ValueCodec a
codec)
                ([Value] -> ReaderT Value (ExceptT String Identity) (ArrayOf a))
-> [Value] -> ReaderT Value (ExceptT String Identity) (ArrayOf a)
forall a b. (a -> b) -> a -> b
$ ArrayOf Value -> [Value]
forall value. ArrayOf value -> [value]
Array.toList ArrayOf Value
array
        , encode :: ArrayOf a -> MaybeT (StateT Value Identity) (ArrayOf a)
Codec.encode = (ArrayOf a -> MaybeT (StateT Value Identity) ())
-> ArrayOf a -> MaybeT (StateT Value Identity) (ArrayOf a)
forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap
            ((ArrayOf a -> MaybeT (StateT Value Identity) ())
 -> ArrayOf a -> MaybeT (StateT Value Identity) (ArrayOf a))
-> (ArrayOf a -> MaybeT (StateT Value Identity) ())
-> ArrayOf a
-> MaybeT (StateT Value Identity) (ArrayOf a)
forall a b. (a -> b) -> a -> b
$ StateT Value Identity () -> MaybeT (StateT Value Identity) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift
            (StateT Value Identity () -> MaybeT (StateT Value Identity) ())
-> (ArrayOf a -> StateT Value Identity ())
-> ArrayOf a
-> MaybeT (StateT Value Identity) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> StateT Value Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put
            (Value -> StateT Value Identity ())
-> (ArrayOf a -> Value) -> ArrayOf a -> StateT Value Identity ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ArrayOf Value -> Value
Value.Array
            (ArrayOf Value -> Value)
-> (ArrayOf a -> ArrayOf Value) -> ArrayOf a -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Value] -> ArrayOf Value
forall value. [value] -> ArrayOf value
Array.fromList
            ([Value] -> ArrayOf Value)
-> (ArrayOf a -> [Value]) -> ArrayOf a -> ArrayOf Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Value) -> [a] -> [Value]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ValueCodec a -> a -> Value
forall a. ValueCodec a -> a -> Value
Codec.encodeWith ValueCodec a
forall a. HasCodec a => ValueCodec a
codec)
            ([a] -> [Value]) -> (ArrayOf a -> [a]) -> ArrayOf a -> [Value]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ArrayOf a -> [a]
forall value. ArrayOf value -> [value]
Array.toList
        }

instance HasCodec a => HasCodec (Object.ObjectOf a) where
    codec :: ValueCodec (ObjectOf a)
codec = Codec :: forall (r :: * -> *) (w :: * -> *) i o.
r o -> (i -> w o) -> CodecOf r w i o
Codec.Codec
        { decode :: ReaderT Value (ExceptT String Identity) (ObjectOf a)
Codec.decode = do
            ObjectOf Value
object <- String
-> (Value -> Maybe (ObjectOf Value))
-> ReaderT Value (ExceptT String Identity) (ObjectOf Value)
forall a.
String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue String
"Object" ((Value -> Maybe (ObjectOf Value))
 -> ReaderT Value (ExceptT String Identity) (ObjectOf Value))
-> (Value -> Maybe (ObjectOf Value))
-> ReaderT Value (ExceptT String Identity) (ObjectOf Value)
forall a b. (a -> b) -> a -> b
$ \ Value
value -> case Value
value of
                Value.Object ObjectOf Value
object -> ObjectOf Value -> Maybe (ObjectOf Value)
forall a. a -> Maybe a
Just ObjectOf Value
object
                Value
_ -> Maybe (ObjectOf Value)
forall a. Maybe a
Nothing
            (String -> ReaderT Value (ExceptT String Identity) (ObjectOf a))
-> ([MemberOf a]
    -> ReaderT Value (ExceptT String Identity) (ObjectOf a))
-> Either String [MemberOf a]
-> ReaderT Value (ExceptT String Identity) (ObjectOf a)
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (ExceptT String Identity (ObjectOf a)
-> ReaderT Value (ExceptT String Identity) (ObjectOf a)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (ExceptT String Identity (ObjectOf a)
 -> ReaderT Value (ExceptT String Identity) (ObjectOf a))
-> (String -> ExceptT String Identity (ObjectOf a))
-> String
-> ReaderT Value (ExceptT String Identity) (ObjectOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ExceptT String Identity (ObjectOf a)
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
Trans.throwE) (ObjectOf a -> ReaderT Value (ExceptT String Identity) (ObjectOf a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ObjectOf a
 -> ReaderT Value (ExceptT String Identity) (ObjectOf a))
-> ([MemberOf a] -> ObjectOf a)
-> [MemberOf a]
-> ReaderT Value (ExceptT String Identity) (ObjectOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [MemberOf a] -> ObjectOf a
forall value. [MemberOf value] -> ObjectOf value
Object.fromList)
                (Either String [MemberOf a]
 -> ReaderT Value (ExceptT String Identity) (ObjectOf a))
-> ([MemberOf Value] -> Either String [MemberOf a])
-> [MemberOf Value]
-> ReaderT Value (ExceptT String Identity) (ObjectOf a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MemberOf Value -> Either String (MemberOf a))
-> [MemberOf Value] -> Either String [MemberOf a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (\ (Member.Member Name
k Value
v) -> Name -> a -> MemberOf a
forall value. Name -> value -> MemberOf value
Member.Member Name
k (a -> MemberOf a) -> Either String a -> Either String (MemberOf a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ValueCodec a -> Value -> Either String a
forall a. ValueCodec a -> Value -> Either String a
Codec.decodeWith ValueCodec a
forall a. HasCodec a => ValueCodec a
codec Value
v)
                ([MemberOf Value]
 -> ReaderT Value (ExceptT String Identity) (ObjectOf a))
-> [MemberOf Value]
-> ReaderT Value (ExceptT String Identity) (ObjectOf a)
forall a b. (a -> b) -> a -> b
$ ObjectOf Value -> [MemberOf Value]
forall value. ObjectOf value -> [MemberOf value]
Object.toList ObjectOf Value
object
        , encode :: ObjectOf a -> MaybeT (StateT Value Identity) (ObjectOf a)
Codec.encode = (ObjectOf a -> MaybeT (StateT Value Identity) ())
-> ObjectOf a -> MaybeT (StateT Value Identity) (ObjectOf a)
forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap
            ((ObjectOf a -> MaybeT (StateT Value Identity) ())
 -> ObjectOf a -> MaybeT (StateT Value Identity) (ObjectOf a))
-> (ObjectOf a -> MaybeT (StateT Value Identity) ())
-> ObjectOf a
-> MaybeT (StateT Value Identity) (ObjectOf a)
forall a b. (a -> b) -> a -> b
$ StateT Value Identity () -> MaybeT (StateT Value Identity) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift
            (StateT Value Identity () -> MaybeT (StateT Value Identity) ())
-> (ObjectOf a -> StateT Value Identity ())
-> ObjectOf a
-> MaybeT (StateT Value Identity) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> StateT Value Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put
            (Value -> StateT Value Identity ())
-> (ObjectOf a -> Value) -> ObjectOf a -> StateT Value Identity ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectOf Value -> Value
Value.Object
            (ObjectOf Value -> Value)
-> (ObjectOf a -> ObjectOf Value) -> ObjectOf a -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [MemberOf Value] -> ObjectOf Value
forall value. [MemberOf value] -> ObjectOf value
Object.fromList
            ([MemberOf Value] -> ObjectOf Value)
-> (ObjectOf a -> [MemberOf Value]) -> ObjectOf a -> ObjectOf Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MemberOf a -> MemberOf Value) -> [MemberOf a] -> [MemberOf Value]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\ (Member.Member Name
k a
v) -> Name -> Value -> MemberOf Value
forall value. Name -> value -> MemberOf value
Member.Member Name
k (Value -> MemberOf Value) -> Value -> MemberOf Value
forall a b. (a -> b) -> a -> b
$ ValueCodec a -> a -> Value
forall a. ValueCodec a -> a -> Value
Codec.encodeWith ValueCodec a
forall a. HasCodec a => ValueCodec a
codec a
v)
            ([MemberOf a] -> [MemberOf Value])
-> (ObjectOf a -> [MemberOf a]) -> ObjectOf a -> [MemberOf Value]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectOf a -> [MemberOf a]
forall value. ObjectOf value -> [MemberOf value]
Object.toList
        }

instance HasCodec a => HasCodec (Maybe a) where
    codec :: ValueCodec (Maybe a)
codec = (a -> Maybe (Maybe a))
-> (Maybe a -> Maybe a)
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     a
     a
-> ValueCodec (Maybe a)
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe (Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just (Maybe a -> Maybe (Maybe a))
-> (a -> Maybe a) -> a -> Maybe (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe a
forall a. a -> Maybe a
Just) Maybe a -> Maybe a
forall a. a -> a
id CodecOf
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  a
  a
forall a. HasCodec a => ValueCodec a
codec
        ValueCodec (Maybe a)
-> ValueCodec (Maybe a) -> ValueCodec (Maybe a)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Null -> Maybe a)
-> (Maybe a -> Null) -> ValueCodec Null -> ValueCodec (Maybe a)
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap (Maybe a -> Null -> Maybe a
forall a b. a -> b -> a
const Maybe a
forall a. Maybe a
Nothing) (Null -> Maybe a -> Null
forall a b. a -> b -> a
const (Null -> Maybe a -> Null) -> Null -> Maybe a -> Null
forall a b. (a -> b) -> a -> b
$ () -> Null
Null.fromUnit ()) ValueCodec Null
forall a. HasCodec a => ValueCodec a
codec

instance (HasCodec a, HasCodec b) => HasCodec (Either a b) where
    codec :: ValueCodec (Either a b)
codec = (a -> Maybe (Either a b))
-> (Either a b -> Maybe a)
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     a
     a
-> ValueCodec (Either a b)
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe (Either a b -> Maybe (Either a b)
forall a. a -> Maybe a
Just (Either a b -> Maybe (Either a b))
-> (a -> Either a b) -> a -> Maybe (Either a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either a b
forall a b. a -> Either a b
Left) ((a -> Maybe a) -> (b -> Maybe a) -> Either a b -> Maybe a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either a -> Maybe a
forall a. a -> Maybe a
Just ((b -> Maybe a) -> Either a b -> Maybe a)
-> (b -> Maybe a) -> Either a b -> Maybe a
forall a b. (a -> b) -> a -> b
$ Maybe a -> b -> Maybe a
forall a b. a -> b -> a
const Maybe a
forall a. Maybe a
Nothing) (String
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     a
     a
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     a
     a
forall a. String -> ValueCodec a -> ValueCodec a
Codec.tagged String
"Left" CodecOf
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  a
  a
forall a. HasCodec a => ValueCodec a
codec)
        ValueCodec (Either a b)
-> ValueCodec (Either a b) -> ValueCodec (Either a b)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (b -> Maybe (Either a b))
-> (Either a b -> Maybe b)
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     b
     b
-> ValueCodec (Either a b)
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe (Either a b -> Maybe (Either a b)
forall a. a -> Maybe a
Just (Either a b -> Maybe (Either a b))
-> (b -> Either a b) -> b -> Maybe (Either a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Either a b
forall a b. b -> Either a b
Right) ((a -> Maybe b) -> (b -> Maybe b) -> Either a b -> Maybe b
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe b -> a -> Maybe b
forall a b. a -> b -> a
const Maybe b
forall a. Maybe a
Nothing) b -> Maybe b
forall a. a -> Maybe a
Just) (String
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     b
     b
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     b
     b
forall a. String -> ValueCodec a -> ValueCodec a
Codec.tagged String
"Right" CodecOf
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  b
  b
forall a. HasCodec a => ValueCodec a
codec)

instance HasCodec () where
    codec :: ValueCodec ()
codec = Permission -> ArrayCodec () -> ValueCodec ()
forall a. Permission -> ArrayCodec a -> ValueCodec a
Codec.fromArrayCodec Permission
Permission.Forbid (ArrayCodec () -> ValueCodec ()) -> ArrayCodec () -> ValueCodec ()
forall a b. (a -> b) -> a -> b
$ () -> ArrayCodec ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

instance (HasCodec a, HasCodec b) => HasCodec (a, b) where
    codec :: ValueCodec (a, b)
codec = Permission -> ArrayCodec (a, b) -> ValueCodec (a, b)
forall a. Permission -> ArrayCodec a -> ValueCodec a
Codec.fromArrayCodec Permission
Permission.Forbid (ArrayCodec (a, b) -> ValueCodec (a, b))
-> ArrayCodec (a, b) -> ValueCodec (a, b)
forall a b. (a -> b) -> a -> b
$ (,)
        (a -> b -> (a, b))
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (a, b)
     a
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (a, b)
     (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b) -> a)
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     a
     a
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (a, b)
     a
forall i f (r :: * -> *) (w :: * -> *) o.
(i -> f) -> CodecOf r w f o -> CodecOf r w i o
Codec.project (a, b) -> a
forall a b. (a, b) -> a
fst (ValueCodec a
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     a
     a
forall a. ValueCodec a -> ArrayCodec a
Codec.element ValueCodec a
forall a. HasCodec a => ValueCodec a
codec)
        CodecOf
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (a, b)
  (b -> (a, b))
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (a, b)
     b
-> ArrayCodec (a, b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b) -> b)
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     b
     b
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (a, b)
     b
forall i f (r :: * -> *) (w :: * -> *) o.
(i -> f) -> CodecOf r w f o -> CodecOf r w i o
Codec.project (a, b) -> b
forall a b. (a, b) -> b
snd (ValueCodec b
-> CodecOf
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     b
     b
forall a. ValueCodec a -> ArrayCodec a
Codec.element ValueCodec b
forall a. HasCodec a => ValueCodec a
codec)

instance HasCodec Bool where
    codec :: ValueCodec Bool
codec = (Boolean -> Bool)
-> (Bool -> Boolean) -> ValueCodec Boolean -> ValueCodec Bool
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap Boolean -> Bool
Boolean.toBool Bool -> Boolean
Boolean.fromBool ValueCodec Boolean
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Decimal.Decimal where
    codec :: ValueCodec Decimal
codec = (Number -> Decimal)
-> (Decimal -> Number) -> ValueCodec Number -> ValueCodec Decimal
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap Number -> Decimal
Number.toDecimal Decimal -> Number
Number.fromDecimal ValueCodec Number
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Text.Text where
    codec :: ValueCodec Text
codec = (String -> Text)
-> (Text -> String) -> ValueCodec String -> ValueCodec Text
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap String -> Text
String.toText Text -> String
String.fromText ValueCodec String
forall a. HasCodec a => ValueCodec a
codec

instance {-# OVERLAPPABLE #-} HasCodec a => HasCodec [a] where
    codec :: ValueCodec [a]
codec = (ArrayOf a -> [a])
-> ([a] -> ArrayOf a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (ArrayOf a)
-> ValueCodec [a]
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap ArrayOf a -> [a]
forall value. ArrayOf value -> [value]
Array.toList [a] -> ArrayOf a
forall value. [value] -> ArrayOf value
Array.fromList Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (ArrayOf a)
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec a => HasCodec (Map.Map Name.Name a) where
    codec :: ValueCodec (Map Name a)
codec = (ObjectOf a -> Map Name a)
-> (Map Name a -> ObjectOf a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (ObjectOf a)
-> ValueCodec (Map Name a)
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap
        ([(Name, a)] -> Map Name a
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Name, a)] -> Map Name a)
-> (ObjectOf a -> [(Name, a)]) -> ObjectOf a -> Map Name a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MemberOf a -> (Name, a)) -> [MemberOf a] -> [(Name, a)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MemberOf a -> (Name, a)
forall value. MemberOf value -> (Name, value)
Member.toTuple ([MemberOf a] -> [(Name, a)])
-> (ObjectOf a -> [MemberOf a]) -> ObjectOf a -> [(Name, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ObjectOf a -> [MemberOf a]
forall value. ObjectOf value -> [MemberOf value]
Object.toList)
        ([MemberOf a] -> ObjectOf a
forall value. [MemberOf value] -> ObjectOf value
Object.fromList ([MemberOf a] -> ObjectOf a)
-> (Map Name a -> [MemberOf a]) -> Map Name a -> ObjectOf a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Name, a) -> MemberOf a) -> [(Name, a)] -> [MemberOf a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Name, a) -> MemberOf a
forall value. (Name, value) -> MemberOf value
Member.fromTuple ([(Name, a)] -> [MemberOf a])
-> (Map Name a -> [(Name, a)]) -> Map Name a -> [MemberOf a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Name a -> [(Name, a)]
forall k a. Map k a -> [(k, a)]
Map.toList)
        Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (ObjectOf a)
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec String where
    codec :: ValueCodec String
codec = (Text -> String)
-> (String -> Text) -> ValueCodec Text -> ValueCodec String
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap Text -> String
Text.unpack String -> Text
Text.pack ValueCodec Text
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Char where
    codec :: ValueCodec Char
codec = (Text -> Maybe Char)
-> (Char -> Maybe Text) -> ValueCodec Text -> ValueCodec Char
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe (\ Text
x -> case Text -> Maybe (Char, Text)
Text.uncons Text
x of
        Just (Char
y, Text
z) | Text -> Bool
Text.null Text
z -> Char -> Maybe Char
forall a. a -> Maybe a
Just Char
y
        Maybe (Char, Text)
_ -> Maybe Char
forall a. Maybe a
Nothing) (Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> (Char -> Text) -> Char -> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Text
Text.singleton) ValueCodec Text
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Text.LazyText where
    codec :: ValueCodec LazyText
codec = (Text -> LazyText)
-> (LazyText -> Text) -> ValueCodec Text -> ValueCodec LazyText
forall (r :: * -> *) (w :: * -> *) a b.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w a -> Codec r w b
Codec.dimap Text -> LazyText
Text.fromStrict LazyText -> Text
Text.toStrict ValueCodec Text
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec a => HasCodec (NonEmpty.NonEmpty a) where
    codec :: ValueCodec (NonEmpty a)
codec = ([a] -> Maybe (NonEmpty a))
-> (NonEmpty a -> Maybe [a])
-> CodecOf
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     [a]
     [a]
-> ValueCodec (NonEmpty a)
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe [a] -> Maybe (NonEmpty a)
forall a. [a] -> Maybe (NonEmpty a)
NonEmpty.nonEmpty ([a] -> Maybe [a]
forall a. a -> Maybe a
Just ([a] -> Maybe [a])
-> (NonEmpty a -> [a]) -> NonEmpty a -> Maybe [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NonEmpty.toList) CodecOf
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  [a]
  [a]
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Integer where
    codec :: ValueCodec Integer
codec = (Decimal -> Maybe Integer)
-> (Integer -> Maybe Decimal)
-> ValueCodec Decimal
-> ValueCodec Integer
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Decimal -> Maybe Integer
Decimal.toInteger (Decimal -> Maybe Decimal
forall a. a -> Maybe a
Just (Decimal -> Maybe Decimal)
-> (Integer -> Decimal) -> Integer -> Maybe Decimal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger) ValueCodec Decimal
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Int where
    codec :: ValueCodec Int
codec = let
        from :: Integer -> Maybe Int
from = Integer -> Maybe Int
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int
        into :: Int -> Integer
into = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int -> Integer
        in (Integer -> Maybe Int)
-> (Int -> Maybe Integer) -> ValueCodec Integer -> ValueCodec Int
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Int
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int -> Integer) -> Int -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Int.Int8 where
    codec :: ValueCodec Int8
codec = let
        from :: Integer -> Maybe Int8
from = Integer -> Maybe Int8
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int8
        into :: Int8 -> Integer
into = Int8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int8 -> Integer
        in (Integer -> Maybe Int8)
-> (Int8 -> Maybe Integer) -> ValueCodec Integer -> ValueCodec Int8
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Int8
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int8 -> Integer) -> Int8 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int8 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Int.Int16 where
    codec :: ValueCodec Int16
codec = let
        from :: Integer -> Maybe Int16
from = Integer -> Maybe Int16
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int16
        into :: Int16 -> Integer
into = Int16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int16 -> Integer
        in (Integer -> Maybe Int16)
-> (Int16 -> Maybe Integer)
-> ValueCodec Integer
-> ValueCodec Int16
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Int16
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int16 -> Integer) -> Int16 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Int.Int32 where
    codec :: ValueCodec Int32
codec = let
        from :: Integer -> Maybe Int32
from = Integer -> Maybe Int32
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int32
        into :: Int32 -> Integer
into = Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int32 -> Integer
        in (Integer -> Maybe Int32)
-> (Int32 -> Maybe Integer)
-> ValueCodec Integer
-> ValueCodec Int32
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Int32
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int32 -> Integer) -> Int32 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Int.Int64 where
    codec :: ValueCodec Int64
codec = let
        from :: Integer -> Maybe Int64
from = Integer -> Maybe Int64
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int64
        into :: Int64 -> Integer
into = Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int64 -> Integer
        in (Integer -> Maybe Int64)
-> (Int64 -> Maybe Integer)
-> ValueCodec Integer
-> ValueCodec Int64
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Int64
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int64 -> Integer) -> Int64 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Word where
    codec :: ValueCodec Word
codec = let
        from :: Integer -> Maybe Word
from = Integer -> Maybe Word
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word
        into :: Word -> Integer
into = Word -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word -> Integer
        in (Integer -> Maybe Word)
-> (Word -> Maybe Integer) -> ValueCodec Integer -> ValueCodec Word
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Word
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word -> Integer) -> Word -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Word.Word8 where
    codec :: ValueCodec Word8
codec = let
        from :: Integer -> Maybe Word8
from = Integer -> Maybe Word8
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word8
        into :: Word8 -> Integer
into = Word8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word8 -> Integer
        in (Integer -> Maybe Word8)
-> (Word8 -> Maybe Integer)
-> ValueCodec Integer
-> ValueCodec Word8
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Word8
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word8 -> Integer) -> Word8 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Word.Word16 where
    codec :: ValueCodec Word16
codec = let
        from :: Integer -> Maybe Word16
from = Integer -> Maybe Word16
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word16
        into :: Word16 -> Integer
into = Word16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word16 -> Integer
        in (Integer -> Maybe Word16)
-> (Word16 -> Maybe Integer)
-> ValueCodec Integer
-> ValueCodec Word16
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Word16
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word16 -> Integer) -> Word16 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Word.Word32 where
    codec :: ValueCodec Word32
codec = let
        from :: Integer -> Maybe Word32
from = Integer -> Maybe Word32
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word32
        into :: Word32 -> Integer
into = Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word32 -> Integer
        in (Integer -> Maybe Word32)
-> (Word32 -> Maybe Integer)
-> ValueCodec Integer
-> ValueCodec Word32
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Word32
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word32 -> Integer) -> Word32 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Word.Word64 where
    codec :: ValueCodec Word64
codec = let
        from :: Integer -> Maybe Word64
from = Integer -> Maybe Word64
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word64
        into :: Word64 -> Integer
into = Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word64 -> Integer
        in (Integer -> Maybe Word64)
-> (Word64 -> Maybe Integer)
-> ValueCodec Integer
-> ValueCodec Word64
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe Integer -> Maybe Word64
from (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word64 -> Integer) -> Word64 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Integer
into) ValueCodec Integer
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Float where
    codec :: ValueCodec Float
codec = (Decimal -> Maybe Float)
-> (Float -> Maybe Decimal)
-> ValueCodec Decimal
-> ValueCodec Float
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe (Float -> Maybe Float
forall a. a -> Maybe a
Just (Float -> Maybe Float)
-> (Decimal -> Float) -> Decimal -> Maybe Float
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Float
forall a. RealFloat a => Decimal -> a
Decimal.toRealFloat) Float -> Maybe Decimal
forall a. RealFloat a => a -> Maybe Decimal
Decimal.fromRealFloat ValueCodec Decimal
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Double where
    codec :: ValueCodec Double
codec = (Decimal -> Maybe Double)
-> (Double -> Maybe Decimal)
-> ValueCodec Decimal
-> ValueCodec Double
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe (Double -> Maybe Double
forall a. a -> Maybe a
Just (Double -> Maybe Double)
-> (Decimal -> Double) -> Decimal -> Maybe Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Double
forall a. RealFloat a => Decimal -> a
Decimal.toRealFloat) Double -> Maybe Decimal
forall a. RealFloat a => a -> Maybe Decimal
Decimal.fromRealFloat ValueCodec Decimal
forall a. HasCodec a => ValueCodec a
codec

instance HasCodec Pointer.Pointer where
    codec :: ValueCodec Pointer
codec = (Text -> Maybe Pointer)
-> (Pointer -> Maybe Text) -> ValueCodec Text -> ValueCodec Pointer
forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> CodecOf r w i2 o2 -> CodecOf r w i1 o1
Codec.mapMaybe
        ( (String -> Maybe Pointer)
-> (Pointer -> Maybe Pointer)
-> Either String Pointer
-> Maybe Pointer
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe Pointer -> String -> Maybe Pointer
forall a b. a -> b -> a
const Maybe Pointer
forall a. Maybe a
Nothing) Pointer -> Maybe Pointer
forall a. a -> Maybe a
Just
        (Either String Pointer -> Maybe Pointer)
-> (Text -> Either String Pointer) -> Text -> Maybe Pointer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decoder Pointer -> ByteString -> Either String Pointer
forall a. Decoder a -> ByteString -> Either String a
Decoder.run Decoder Pointer
Pointer.decode
        (ByteString -> Either String Pointer)
-> (Text -> ByteString) -> Text -> Either String Pointer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
Text.encodeUtf8
        )
        ( (UnicodeException -> Maybe Text)
-> (Text -> Maybe Text)
-> Either UnicodeException Text
-> Maybe Text
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe Text -> UnicodeException -> Maybe Text
forall a b. a -> b -> a
const Maybe Text
forall a. Maybe a
Nothing) Text -> Maybe Text
forall a. a -> Maybe a
Just
        (Either UnicodeException Text -> Maybe Text)
-> (Pointer -> Either UnicodeException Text)
-> Pointer
-> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either UnicodeException Text
Text.decodeUtf8'
        (ByteString -> Either UnicodeException Text)
-> (Pointer -> ByteString)
-> Pointer
-> Either UnicodeException Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
ByteString.toStrict
        (ByteString -> ByteString)
-> (Pointer -> ByteString) -> Pointer -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> ByteString
Builder.toLazyByteString
        (Builder -> ByteString)
-> (Pointer -> Builder) -> Pointer -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Config -> Encoder () -> Builder
forall a. Config -> Encoder a -> Builder
Encoder.run Config
Config.initial
        (Encoder () -> Builder)
-> (Pointer -> Encoder ()) -> Pointer -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pointer -> Encoder ()
Pointer.encode
        )
        ValueCodec Text
forall a. HasCodec a => ValueCodec a
codec

basicCodec :: String -> (a -> Value.Value) -> (Value.Value -> Maybe a) -> Codec.ValueCodec a
basicCodec :: String -> (a -> Value) -> (Value -> Maybe a) -> ValueCodec a
basicCodec String
expected a -> Value
toValue Value -> Maybe a
fromValue = Codec :: forall (r :: * -> *) (w :: * -> *) i o.
r o -> (i -> w o) -> CodecOf r w i o
Codec.Codec
    { decode :: ReaderT Value (ExceptT String Identity) a
Codec.decode = String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
forall a.
String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue String
expected Value -> Maybe a
fromValue
    , encode :: a -> MaybeT (StateT Value Identity) a
Codec.encode = (a -> MaybeT (StateT Value Identity) ())
-> a -> MaybeT (StateT Value Identity) a
forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap ((a -> MaybeT (StateT Value Identity) ())
 -> a -> MaybeT (StateT Value Identity) a)
-> (a -> MaybeT (StateT Value Identity) ())
-> a
-> MaybeT (StateT Value Identity) a
forall a b. (a -> b) -> a -> b
$ StateT Value Identity () -> MaybeT (StateT Value Identity) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (StateT Value Identity () -> MaybeT (StateT Value Identity) ())
-> (a -> StateT Value Identity ())
-> a
-> MaybeT (StateT Value Identity) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> StateT Value Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put (Value -> StateT Value Identity ())
-> (a -> Value) -> a -> StateT Value Identity ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value
toValue
    }

castValue
    :: String
    -> (Value.Value -> Maybe a)
    -> Trans.ReaderT Value.Value (Trans.ExceptT String Identity.Identity) a
castValue :: String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue String
expected Value -> Maybe a
fromValue = do
    Value
value <- ReaderT Value (ExceptT String Identity) Value
forall (m :: * -> *) r. Monad m => ReaderT r m r
Trans.ask
    case Value -> Maybe a
fromValue Value
value of
        Maybe a
Nothing -> ExceptT String Identity a
-> ReaderT Value (ExceptT String Identity) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (ExceptT String Identity a
 -> ReaderT Value (ExceptT String Identity) a)
-> (String -> ExceptT String Identity a)
-> String
-> ReaderT Value (ExceptT String Identity) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ExceptT String Identity a
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
Trans.throwE (String -> ReaderT Value (ExceptT String Identity) a)
-> String -> ReaderT Value (ExceptT String Identity) a
forall a b. (a -> b) -> a -> b
$ String -> Value -> String
typeMismatch String
expected Value
value
        Just a
x -> a -> ReaderT Value (ExceptT String Identity) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x

typeMismatch :: String -> Value.Value -> String
typeMismatch :: String -> Value -> String
typeMismatch String
expected Value
value =
    let
        actual :: String
actual = case Value
value of
            Value.Null Null
_ -> String
"Null"
            Value.Boolean Boolean
_ -> String
"Boolean"
            Value.Number Number
_ -> String
"Number"
            Value.String String
_ -> String
"String"
            Value.Array ArrayOf Value
_ -> String
"Array"
            Value.Object ObjectOf Value
_ -> String
"Object"
    in String
"expected " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
expected String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" but got " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
actual