{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Argo.Internal.Class.HasCodec where

import Control.Applicative ((<|>))

import qualified Argo.Internal.Codec.Array as Codec
import qualified Argo.Internal.Codec.Codec as Codec
import qualified Argo.Internal.Codec.Object as Codec
import qualified Argo.Internal.Codec.Value as Codec
import qualified Argo.Internal.Json.Array as Array
import qualified Argo.Internal.Json.Boolean as Boolean
import qualified Argo.Internal.Json.Member as Member
import qualified Argo.Internal.Json.Name as Name
import qualified Argo.Internal.Json.Null as Null
import qualified Argo.Internal.Json.Number as Number
import qualified Argo.Internal.Json.Object as Object
import qualified Argo.Internal.Json.String as String
import qualified Argo.Internal.Json.Value as Value
import qualified Argo.Internal.Pointer.Pointer as Pointer
import qualified Argo.Internal.Schema.Identifier as Identifier
import qualified Argo.Internal.Schema.Schema as Schema
import qualified Argo.Internal.Type.Config as Config
import qualified Argo.Internal.Type.Decimal as Decimal
import qualified Argo.Internal.Type.Decoder as Decoder
import qualified Argo.Internal.Type.Encoder as Encoder
import qualified Argo.Internal.Type.Nullable as Nullable
import qualified Argo.Internal.Type.Optional as Optional
import qualified Argo.Internal.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.Maybe as Maybe
import qualified Data.Typeable as Typeable
import qualified Data.Word as Word
import qualified Numeric.Natural as Natural

class Typeable.Typeable a => HasCodec a where
    codec :: Codec.Value a

instance HasCodec Value.Value where
    codec :: Value Value
codec = forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
valueCodec Schema
Schema.true forall a. a -> a
id forall a. a -> Maybe a
Just

instance HasCodec Null.Null where
    codec :: Value Null
codec =
        let schema :: Schema
schema = Schema
Schema.Null
        in
            forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
valueCodec Schema
schema Null -> Value
Value.Null forall a b. (a -> b) -> a -> b
$ \Value
value -> case Value
value of
                Value.Null Null
null_ -> forall a. a -> Maybe a
Just Null
null_
                Value
_ -> forall a. Maybe a
Nothing

instance HasCodec Boolean.Boolean where
    codec :: Value Boolean
codec =
        let schema :: Schema
schema = Schema
Schema.Boolean
        in
            forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
valueCodec Schema
schema Boolean -> Value
Value.Boolean forall a b. (a -> b) -> a -> b
$ \Value
value -> case Value
value of
                Value.Boolean Boolean
boolean -> forall a. a -> Maybe a
Just Boolean
boolean
                Value
_ -> forall a. Maybe a
Nothing

instance HasCodec Number.Number where
    codec :: Value Number
codec =
        let schema :: Schema
schema = Schema
Schema.Number
        in
            forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
valueCodec Schema
schema Number -> Value
Value.Number forall a b. (a -> b) -> a -> b
$ \Value
value -> case Value
value of
                Value.Number Number
number -> forall a. a -> Maybe a
Just Number
number
                Value
_ -> forall a. Maybe a
Nothing

instance HasCodec String.String where
    codec :: Value String
codec =
        let schema :: Schema
schema = Maybe Natural -> Maybe Natural -> Schema
Schema.String forall a. Maybe a
Nothing forall a. Maybe a
Nothing
        in
            forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
valueCodec Schema
schema String -> Value
Value.String forall a b. (a -> b) -> a -> b
$ \Value
value -> case Value
value of
                Value.String String
string -> forall a. a -> Maybe a
Just String
string
                Value
_ -> forall a. Maybe a
Nothing

instance HasCodec a => HasCodec (Array.Array a) where
    codec :: Value (Array a)
codec = forall a. Typeable a => Value a -> Value a
Codec.identified Codec.Codec
        { decode :: ReaderT Value (ExceptT String Identity) (Array a)
Codec.decode = do
            Array Value
array <- forall a.
String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue String
"Array" forall a b. (a -> b) -> a -> b
$ \Value
value -> case Value
value of
                Value.Array Array Value
array -> forall a. a -> Maybe a
Just Array Value
array
                Value
_ -> forall a. Maybe a
Nothing
            forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (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 :: * -> *) e a. Monad m => e -> ExceptT e m a
Trans.throwE) (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. [value] -> Array value
Array.fromList)
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall a. Value a -> Value -> Either String a
Codec.decodeWith forall a. HasCodec a => Value a
codec)
                forall a b. (a -> b) -> a -> b
$ forall value. Array value -> [value]
Array.toList Array Value
array
        , encode :: Array a -> MaybeT (StateT Value Identity) (Array a)
Codec.encode =
            forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap
            forall a b. (a -> b) -> a -> b
$ 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 :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array Value -> Value
Value.Array
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. [value] -> Array value
Array.fromList
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Value a -> a -> Value
Codec.encodeWith forall a. HasCodec a => Value a
codec)
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. Array value -> [value]
Array.toList
        , schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = do
            Schema
ref <- forall a. Value a -> AccumT (Map Identifier Schema) Identity Schema
Codec.getRef (forall a. HasCodec a => Value a
codec :: Codec.Value a)
            forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. Schema -> (Maybe Identifier, Schema)
Schema.unidentified forall a b. (a -> b) -> a -> b
$ Maybe Natural
-> Maybe Natural
-> Either Schema (NonEmpty Schema)
-> Maybe Schema
-> Schema
Schema.Array
                forall a. Maybe a
Nothing
                forall a. Maybe a
Nothing
                (forall a b. a -> Either a b
Left Schema
ref)
                forall a. Maybe a
Nothing
        }

instance HasCodec a => HasCodec (Object.Object a) where
    codec :: Value (Object a)
codec = forall a. Typeable a => Value a -> Value a
Codec.identified Codec.Codec
        { decode :: ReaderT Value (ExceptT String Identity) (Object a)
Codec.decode = do
            Object Value
object <- forall a.
String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue String
"Object" forall a b. (a -> b) -> a -> b
$ \Value
value -> case Value
value of
                Value.Object Object Value
object -> forall a. a -> Maybe a
Just Object Value
object
                Value
_ -> forall a. Maybe a
Nothing
            forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (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 :: * -> *) e a. Monad m => e -> ExceptT e m a
Trans.throwE) (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. [Member value] -> Object value
Object.fromList)
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
                      (\(Member.Member Name
k Value
v) ->
                          forall value. Name -> value -> Member value
Member.Member Name
k forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Value a -> Value -> Either String a
Codec.decodeWith forall a. HasCodec a => Value a
codec Value
v
                      )
                forall a b. (a -> b) -> a -> b
$ forall value. Object value -> [Member value]
Object.toList Object Value
object
        , encode :: Object a -> MaybeT (StateT Value Identity) (Object a)
Codec.encode =
            forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap
            forall a b. (a -> b) -> a -> b
$ 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 :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. [Member value] -> Object value
Object.fromList
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
                  (\(Member.Member Name
k a
v) ->
                      forall value. Name -> value -> Member value
Member.Member Name
k forall a b. (a -> b) -> a -> b
$ forall a. Value a -> a -> Value
Codec.encodeWith forall a. HasCodec a => Value a
codec a
v
                  )
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. Object value -> [Member value]
Object.toList
        , schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = do
            Schema
ref <- forall a. Value a -> AccumT (Map Identifier Schema) Identity Schema
Codec.getRef (forall a. HasCodec a => Value a
codec :: Codec.Value a)
            forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. Schema -> (Maybe Identifier, Schema)
Schema.unidentified forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Name, Schema)] -> [Name] -> Maybe Schema -> Schema
Schema.Object [] [] forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Schema
ref
        }

instance HasCodec a => HasCodec (Nullable.Nullable a) where
    codec :: Value (Nullable a)
codec = forall a. Typeable a => Value a -> Value (Nullable a)
nullable forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Maybe a) where
    codec :: Value (Maybe a)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map forall a. Nullable a -> Maybe a
Nullable.toMaybe forall a. Maybe a -> Nullable a
Nullable.fromMaybe forall a. HasCodec a => Value a
codec

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

instance HasCodec () where
    codec :: Value ()
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

instance
    ( HasCodec a
    , HasCodec b
    ) => HasCodec (a, b) where
    codec :: Value (a, b)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            forall a b. (a -> b) -> a -> b
$ (,)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project forall a b. (a, b) -> a
fst (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project forall a b. (a, b) -> b
snd (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)

instance
    ( HasCodec a
    , HasCodec b
    , HasCodec c
    ) => HasCodec (a, b, c) where
    codec :: Value (a, b, c)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            forall a b. (a -> b) -> a -> b
$ (,,)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
a, b
_, c
_) -> a
a) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
b, c
_) -> b
b) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
c) -> c
c) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)

instance
    ( HasCodec a
    , HasCodec b
    , HasCodec c
    , HasCodec d
    ) => HasCodec (a, b, c, d) where
    codec :: Value (a, b, c, d)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            forall a b. (a -> b) -> a -> b
$ (,,,)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
a, b
_, c
_, d
_) -> a
a) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
b, c
_, d
_) -> b
b) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
c, d
_) -> c
c) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
_, d
d) -> d
d) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)

instance
    ( HasCodec a
    , HasCodec b
    , HasCodec c
    , HasCodec d
    , HasCodec e
    ) => HasCodec (a, b, c, d, e) where
    codec :: Value (a, b, c, d, e)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            forall a b. (a -> b) -> a -> b
$ (,,,,)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
a, b
_, c
_, d
_, e
_) -> a
a) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
b, c
_, d
_, e
_) -> b
b) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
c, d
_, e
_) -> c
c) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
_, d
d, e
_) -> d
d) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
_, d
_, e
e) -> e
e) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)

instance
    ( HasCodec a
    , HasCodec b
    , HasCodec c
    , HasCodec d
    , HasCodec e
    , HasCodec f
    ) => HasCodec (a, b, c, d, e, f) where
    codec :: Value (a, b, c, d, e, f)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            forall a b. (a -> b) -> a -> b
$ (,,,,,)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
a, b
_, c
_, d
_, e
_, f
_) -> a
a) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
b, c
_, d
_, e
_, f
_) -> b
b) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
c, d
_, e
_, f
_) -> c
c) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
_, d
d, e
_, f
_) -> d
d) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
_, d
_, e
e, f
_) -> e
e) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project (\(a
_, b
_, c
_, d
_, e
_, f
f) -> f
f) (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)

instance
    ( HasCodec a
    , HasCodec b
    , HasCodec c
    , HasCodec d
    , HasCodec e
    , HasCodec f
    , HasCodec g
    ) => HasCodec (a, b, c, d, e, f, g) where
    codec :: Value (a, b, c, d, e, f, g)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            forall a b. (a -> b) -> a -> b
$ (,,,,,,)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
a, b
_, c
_, d
_, e
_, f
_, g
_) -> a
a)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
b, c
_, d
_, e
_, f
_, g
_) -> b
b)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
c, d
_, e
_, f
_, g
_) -> c
c)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
d, e
_, f
_, g
_) -> d
d)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
_, e
e, f
_, g
_) -> e
e)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
_, e
_, f
f, g
_) -> f
f)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
_, e
_, f
_, g
g) -> g
g)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)

instance
    ( HasCodec a
    , HasCodec b
    , HasCodec c
    , HasCodec d
    , HasCodec e
    , HasCodec f
    , HasCodec g
    , HasCodec h
    ) => HasCodec (a, b, c, d, e, f, g, h) where
    codec :: Value (a, b, c, d, e, f, g, h)
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            forall a b. (a -> b) -> a -> b
$ (,,,,,,,)
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
a, b
_, c
_, d
_, e
_, f
_, g
_, h
_) -> a
a)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
b, c
_, d
_, e
_, f
_, g
_, h
_) -> b
b)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
c, d
_, e
_, f
_, g
_, h
_) -> c
c)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
d, e
_, f
_, g
_, h
_) -> d
d)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
_, e
e, f
_, g
_, h
_) -> e
e)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
_, e
_, f
f, g
_, h
_) -> f
f)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
_, e
_, f
_, g
g, h
_) -> g
g)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                    (\(a
_, b
_, c
_, d
_, e
_, f
_, g
_, h
h) -> h
h)
                    (forall a. Value a -> Array a
Codec.element forall a. HasCodec a => Value a
codec)

instance HasCodec Bool where
    codec :: Value Bool
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map Boolean -> Bool
Boolean.toBool Bool -> Boolean
Boolean.fromBool forall a. HasCodec a => Value a
codec

instance HasCodec Decimal.Decimal where
    codec :: Value Decimal
codec =
        forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map Number -> Decimal
Number.toDecimal Decimal -> Number
Number.fromDecimal forall a. HasCodec a => Value a
codec

instance HasCodec Text.Text where
    codec :: Value Text
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map String -> Text
String.toText Text -> String
String.fromText forall a. HasCodec a => Value a
codec

instance {-# OVERLAPPABLE #-} HasCodec a => HasCodec [a] where
    codec :: Value [a]
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map forall value. Array value -> [value]
Array.toList forall value. [value] -> Array value
Array.fromList forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map Name.Name a) where
    codec :: Value (Map Name a)
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map
        (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall value. Member value -> (Name, value)
Member.toTuple forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. Object value -> [Member value]
Object.toList)
        (forall value. [Member value] -> Object value
Object.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall value. (Name, value) -> Member value
Member.fromTuple forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
Map.toList)
        forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map String.String a) where
    codec :: Value (Map String a)
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map
        (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Name -> String
Name.toString)
        (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys String -> Name
Name.fromString)
        forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map Text.Text a) where
    codec :: Value (Map Text a)
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map
        (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys String -> Text
String.toText)
        (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Text -> String
String.fromText)
        forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map Text.LazyText a) where
    codec :: Value (Map LazyText a)
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map
        (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Text -> LazyText
Text.fromStrict)
        (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys LazyText -> Text
Text.toStrict)
        forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map String a) where
    codec :: Value (Map String a)
codec = forall a. Typeable a => Value a -> Value a
Codec.identified
        forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Text -> String
Text.unpack) (forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys String -> Text
Text.pack) forall a. HasCodec a => Value a
codec

instance HasCodec String where
    codec :: Value String
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map Text -> String
Text.unpack String -> Text
Text.pack forall a. HasCodec a => Value a
codec

instance HasCodec Char where
    codec :: Value Char
codec =
        let schema :: (Maybe Identifier, Schema)
schema = Schema -> (Maybe Identifier, Schema)
Schema.unidentified forall a b. (a -> b) -> a -> b
$ Maybe Natural -> Maybe Natural -> Schema
Schema.String (forall a. a -> Maybe a
Just Natural
1) (forall a. a -> Maybe a
Just Natural
1)
        in
            forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s 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 -> forall a. a -> Maybe a
Just Char
y
                    Maybe (Char, Text)
_ -> forall a. Maybe a
Nothing
                )
                (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Text
Text.singleton)
                forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Identifier, Schema)
schema }

instance HasCodec Text.LazyText where
    codec :: Value LazyText
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map Text -> LazyText
Text.fromStrict LazyText -> Text
Text.toStrict forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (NonEmpty.NonEmpty a) where
    codec :: Value (NonEmpty a)
codec =
        let
            schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
schema = do
                (Maybe Identifier, Schema)
itemSchema <- forall (r :: * -> *) (w :: * -> *) s i o. Codec r w s i o -> s
Codec.schema (forall a. HasCodec a => Value a
codec :: Codec.Value a)
                forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. Schema -> (Maybe Identifier, Schema)
Schema.unidentified forall a b. (a -> b) -> a -> b
$ Maybe Natural
-> Maybe Natural
-> Either Schema (NonEmpty Schema)
-> Maybe Schema
-> Schema
Schema.Array
                    (forall a. a -> Maybe a
Just Natural
1)
                    forall a. Maybe a
Nothing
                    (forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ (Maybe Identifier, Schema) -> Schema
Schema.maybeRef (Maybe Identifier, Schema)
itemSchema)
                    forall a. Maybe a
Nothing
        in
            forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                forall a. [a] -> Maybe (NonEmpty a)
NonEmpty.nonEmpty
                (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NonEmpty a -> [a]
NonEmpty.toList)
                forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
schema }

instance HasCodec Integer where
    codec :: Value Integer
codec =
        let schema :: (Maybe Identifier, Schema)
schema = Schema -> (Maybe Identifier, Schema)
Schema.unidentified forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Integer -> Schema
Schema.Integer forall a. Maybe a
Nothing forall a. Maybe a
Nothing
        in
            forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                Decimal -> Maybe Integer
Decimal.toInteger
                (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger)
                forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Identifier, Schema)
schema }

instance HasCodec Int where
    codec :: Value Int
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Int.Int8 where
    codec :: Value Int8
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Int.Int16 where
    codec :: Value Int16
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Int.Int32 where
    codec :: Value Int32
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Int.Int64 where
    codec :: Value Int64
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Natural.Natural where
    codec :: Value Natural
codec =
        let
            from :: Integer -> Maybe Natural
from = forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Natural.Natural
            into :: Natural -> Integer
into = forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Natural.Natural -> Integer
            schema :: (Maybe Identifier, Schema)
schema = Schema -> (Maybe Identifier, Schema)
Schema.unidentified forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Integer -> Schema
Schema.Integer (forall a. a -> Maybe a
Just Integer
0) forall a. Maybe a
Nothing
        in forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
            Integer -> Maybe Natural
from
            (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Integer
into)
            forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Identifier, Schema)
schema }

instance HasCodec Word where
    codec :: Value Word
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Word.Word8 where
    codec :: Value Word8
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Word.Word16 where
    codec :: Value Word16
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Word.Word32 where
    codec :: Value Word32
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

instance HasCodec Word.Word64 where
    codec :: Value Word64
codec = forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec

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

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

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

instance HasCodec Identifier.Identifier where
    codec :: Value Identifier
codec =
        let prefix :: Text
prefix = String -> Text
Text.pack String
"#/definitions/"
        in
            forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Identifier
Identifier.fromText forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
Text.stripPrefix Text
prefix)
                (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Monoid a => a -> a -> a
mappend Text
prefix forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Text
Identifier.toText)
                forall a. HasCodec a => Value a
codec

instance HasCodec Name.Name where
    codec :: Value Name
codec = forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map String -> Name
Name.fromString Name -> String
Name.toString forall a. HasCodec a => Value a
codec

instance HasCodec Schema.Schema where
    codec :: Value Schema
codec =
        let
            trueCodec :: Value Schema
trueCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Schema
Schema.True)
                        (\Schema
x -> case Schema
x of
                            Schema
Schema.True -> forall a. a -> Maybe a
Just ()
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Boolean -> Value
Value.Boolean
                    forall a b. (a -> b) -> a -> b
$ Bool -> Boolean
Boolean.fromBool Bool
True
            falseCodec :: Value Schema
falseCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Schema
Schema.False)
                        (\Schema
x -> case Schema
x of
                            Schema
Schema.False -> forall a. a -> Maybe a
Just ()
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Boolean -> Value
Value.Boolean
                    forall a b. (a -> b) -> a -> b
$ Bool -> Boolean
Boolean.fromBool Bool
False
            constCodec :: Value Schema
constCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.Const)
                        (\Schema
x -> case Schema
x of
                            Schema.Const Value
y -> forall a. a -> Maybe a
Just Value
y
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall a b. (a -> b) -> a -> b
$ forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"const") forall a. HasCodec a => Value a
codec
            nullCodec :: Value Schema
nullCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Schema
Schema.Null)
                        (\Schema
x -> case Schema
x of
                            Schema
Schema.Null -> forall a. a -> Maybe a
Just ()
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"type")
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
Value.String
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText
                    forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"null"
            booleanCodec :: Value Schema
booleanCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Schema
Schema.Boolean)
                        (\Schema
x -> case Schema
x of
                            Schema
Schema.Boolean -> forall a. a -> Maybe a
Just ()
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"type")
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
Value.String
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText
                    forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"boolean"
            numberCodec :: Value Schema
numberCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Schema
Schema.Number)
                        (\Schema
x -> case Schema
x of
                            Schema
Schema.Number -> forall a. a -> Maybe a
Just ()
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"type")
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
Value.String
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText
                    forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"number"
            integerCodec :: Value Schema
integerCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (\(()
_, Optional Integer
y, Optional Integer
z) -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Integer -> Schema
Schema.Integer
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Integer
y)
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Integer
z)
                        )
                        (\Schema
x -> case Schema
x of
                            Schema.Integer Maybe Integer
y Maybe Integer
z ->
                                forall a. a -> Maybe a
Just
                                    ( ()
                                    , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Integer
y
                                    , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Integer
z
                                    )
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall a b. (a -> b) -> a -> b
$ (,,)
                    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
a, Optional Integer
_, Optional Integer
_) -> ()
a)
                            (forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"type")
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
Value.String
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText
                            forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"integer"
                            )
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Integer
b, Optional Integer
_) -> Optional Integer
b)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"minimum") forall a. HasCodec a => Value a
codec)
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Integer
_, Optional Integer
c) -> Optional Integer
c)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"maximum") forall a. HasCodec a => Value a
codec)
            stringCodec :: Value Schema
stringCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (\(()
_, Optional Natural
y, Optional Natural
z) -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Maybe Natural -> Maybe Natural -> Schema
Schema.String
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Natural
y)
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Natural
z)
                        )
                        (\Schema
x -> case Schema
x of
                            Schema.String Maybe Natural
y Maybe Natural
z ->
                                forall a. a -> Maybe a
Just
                                    ( ()
                                    , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Natural
y
                                    , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Natural
z
                                    )
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall a b. (a -> b) -> a -> b
$ (,,)
                    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
a, Optional Natural
_, Optional Natural
_) -> ()
a)
                            (forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"type")
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
Value.String
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText
                            forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"string"
                            )
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Natural
b, Optional Natural
_) -> Optional Natural
b)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"minLength") forall a. HasCodec a => Value a
codec)
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Natural
_, Optional Natural
c) -> Optional Natural
c)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"maxLength") forall a. HasCodec a => Value a
codec)
            arrayCodec :: Value Schema
arrayCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (\(()
_, Optional Natural
lo, Optional Natural
hi, Either Schema (NonEmpty Schema)
e, Optional Schema
m) -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Maybe Natural
-> Maybe Natural
-> Either Schema (NonEmpty Schema)
-> Maybe Schema
-> Schema
Schema.Array
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Natural
lo)
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Natural
hi)
                            Either Schema (NonEmpty Schema)
e
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Schema
m)
                        )
                        (\Schema
x -> case Schema
x of
                            Schema.Array Maybe Natural
lo Maybe Natural
hi Either Schema (NonEmpty Schema)
e Maybe Schema
m -> forall a. a -> Maybe a
Just
                                ( ()
                                , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Natural
lo
                                , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Natural
hi
                                , Either Schema (NonEmpty Schema)
e
                                , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Schema
m
                                )
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall a b. (a -> b) -> a -> b
$ (,,,,)
                    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
a, Optional Natural
_, Optional Natural
_, Either Schema (NonEmpty Schema)
_, Optional Schema
_) -> ()
a)
                            (forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"type")
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
Value.String
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText
                            forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"array"
                            )
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Natural
b, Optional Natural
_, Either Schema (NonEmpty Schema)
_, Optional Schema
_) -> Optional Natural
b)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"minItems") forall a. HasCodec a => Value a
codec)
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Natural
_, Optional Natural
c, Either Schema (NonEmpty Schema)
_, Optional Schema
_) -> Optional Natural
c)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"maxItems") forall a. HasCodec a => Value a
codec)
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Natural
_, Optional Natural
_, Either Schema (NonEmpty Schema)
d, Optional Schema
_) -> Either Schema (NonEmpty Schema)
d)
                            (forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"items")
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Identifier -> Value a -> Value a
Codec.withIdentifier
                                  (Text -> Identifier
Identifier.fromText
                                  forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"OneOf Schema [Schema]"
                                  )
                            forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                                  (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> Either a b
Left)
                                  (forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a b. a -> b -> a
const forall a. Maybe a
Nothing)
                                  forall a. HasCodec a => Value a
codec
                            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                                    (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. b -> Either a b
Right)
                                    (forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const forall a. Maybe a
Nothing) forall a. a -> Maybe a
Just)
                                    forall a. HasCodec a => Value a
codec
                            )
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional Natural
_, Optional Natural
_, Either Schema (NonEmpty Schema)
_, Optional Schema
e) -> Optional Schema
e)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"additionalItems") forall a. HasCodec a => Value a
codec)
            objectCodec :: Value Schema
objectCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (\(()
_, Optional (Object Schema)
ps, Optional [Name]
rs, Optional Schema
m) -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ [(Name, Schema)] -> [Name] -> Maybe Schema -> Schema
Schema.Object
                            (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall value. Member value -> (Name, value)
Member.toTuple
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap forall value. Object value -> [Member value]
Object.toList
                            forall a b. (a -> b) -> a -> b
$ forall a. Optional a -> Maybe a
Optional.toMaybe Optional (Object Schema)
ps
                            )
                            (forall a. a -> Maybe a -> a
Maybe.fromMaybe [] forall a b. (a -> b) -> a -> b
$ forall a. Optional a -> Maybe a
Optional.toMaybe Optional [Name]
rs)
                            (forall a. Optional a -> Maybe a
Optional.toMaybe Optional Schema
m)
                        )
                        (\Schema
x -> case Schema
x of
                            Schema.Object [(Name, Schema)]
ps [Name]
rs Maybe Schema
m -> forall a. a -> Maybe a
Just
                                ( ()
                                , if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(Name, Schema)]
ps
                                    then forall a. Optional a
Optional.nothing
                                    else forall a. a -> Optional a
Optional.just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall value. [Member value] -> Object value
Object.fromList forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
                                        forall value. (Name, value) -> Member value
Member.fromTuple
                                        [(Name, Schema)]
ps
                                , if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Name]
rs
                                    then forall a. Optional a
Optional.nothing
                                    else forall a. a -> Optional a
Optional.just [Name]
rs
                                , forall a. Maybe a -> Optional a
Optional.fromMaybe Maybe Schema
m
                                )
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall a b. (a -> b) -> a -> b
$ (,,,)
                    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
a, Optional (Object Schema)
_, Optional [Name]
_, Optional Schema
_) -> ()
a)
                            (forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"type")
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Value ()
Codec.literalCodec
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Value
Value.String
                            forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText
                            forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"object"
                            )
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional (Object Schema)
b, Optional [Name]
_, Optional Schema
_) -> Optional (Object Schema)
b)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"properties") forall a. HasCodec a => Value a
codec)
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional (Object Schema)
_, Optional [Name]
c, Optional Schema
_) -> Optional [Name]
c)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"required") forall a. HasCodec a => Value a
codec)
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall i f (r :: * -> *) (w :: * -> *) s o.
(i -> f) -> Codec r w s f o -> Codec r w s i o
Codec.project
                            (\(()
_, Optional (Object Schema)
_, Optional [Name]
_, Optional Schema
d) -> Optional Schema
d)
                            (forall a. Name -> Value a -> Object (Optional a)
Codec.optional (String -> Name
name String
"additionalProperties") forall a. HasCodec a => Value a
codec
                            )
            refCodec :: Value Schema
refCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Schema
Schema.Ref)
                        (\Schema
x -> case Schema
x of
                            Schema.Ref Identifier
y -> forall a. a -> Maybe a
Just Identifier
y
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall a b. (a -> b) -> a -> b
$ forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"$ref") forall a. HasCodec a => Value a
codec
            oneOfCodec :: Value Schema
oneOfCodec =
                forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
                        (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Schema] -> Schema
Schema.OneOf)
                        (\Schema
x -> case Schema
x of
                            Schema.OneOf [Schema]
y -> forall a. a -> Maybe a
Just [Schema]
y
                            Schema
_ -> forall a. Maybe a
Nothing
                        )
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Permission -> Object a -> Value a
Codec.fromObjectCodec Permission
Permission.Forbid
                    forall a b. (a -> b) -> a -> b
$ forall a. Name -> Value a -> Object a
Codec.required (String -> Name
name String
"oneOf") forall a. HasCodec a => Value a
codec
        in
            forall a. Typeable a => Value a -> Value a
Codec.identified
            forall a b. (a -> b) -> a -> b
$ Value Schema
trueCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
falseCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
constCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
nullCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
booleanCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
numberCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
integerCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
stringCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
arrayCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
objectCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
refCodec
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value Schema
oneOfCodec

name :: String -> Name.Name
name :: String -> Name
name = String -> Name
Name.fromString forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
Text.pack

valueCodec
    :: forall a
     . Typeable.Typeable a
    => Schema.Schema
    -> (a -> Value.Value)
    -> (Value.Value -> Maybe a)
    -> Codec.Value a
valueCodec :: forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
valueCodec Schema
schema a -> Value
toValue Value -> Maybe a
fromValue = forall a. Typeable a => Value a -> Value a
Codec.identified Codec.Codec
    { decode :: ReaderT Value (ExceptT String Identity) a
Codec.decode = forall a.
String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue
        (forall a. Typeable a => Proxy a -> String
Codec.typeName (forall {k} (t :: k). Proxy t
Typeable.Proxy :: Typeable.Proxy a))
        Value -> Maybe a
fromValue
    , encode :: a -> MaybeT (StateT Value Identity) a
Codec.encode = forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap forall a b. (a -> b) -> a -> b
$ 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 :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value
toValue
    , schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Schema -> (Maybe Identifier, Schema)
Schema.unidentified Schema
schema
    }

castValue
    :: String
    -> (Value.Value -> Maybe a)
    -> Trans.ReaderT
           Value.Value
           (Trans.ExceptT String Identity.Identity)
           a
castValue :: forall a.
String
-> (Value -> Maybe a) -> ReaderT Value (ExceptT String Identity) a
castValue String
expected Value -> Maybe a
fromValue = do
    Value
value <- forall (m :: * -> *) r. Monad m => ReaderT r m r
Trans.ask
    case Value -> Maybe a
fromValue Value
value of
        Maybe a
Nothing -> 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 :: * -> *) e a. Monad m => e -> ExceptT e m a
Trans.throwE forall a b. (a -> b) -> a -> b
$ String -> Value -> String
typeMismatch String
expected Value
value
        Just a
x -> 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 Array Value
_ -> String
"Array"
            Value.Object Object Value
_ -> String
"Object"
    in String
"expected " forall a. Semigroup a => a -> a -> a
<> String
expected forall a. Semigroup a => a -> a -> a
<> String
" but got " forall a. Semigroup a => a -> a -> a
<> String
actual

integralCodec
    :: forall a
     . (Bits.Bits a, Bounded a, Integral a, Typeable.Typeable a)
    => Codec.Value a
integralCodec :: forall a. (Bits a, Bounded a, Integral a, Typeable a) => Value a
integralCodec =
    let
        from :: Integer -> Maybe a
from = forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe a
        into :: a -> Integer
into = forall a b. (Integral a, Num b) => a -> b
fromIntegral :: a -> Integer
        schema :: (Maybe Identifier, Schema)
schema = Schema -> (Maybe Identifier, Schema)
Schema.unidentified forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Integer -> Schema
Schema.Integer
            (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger (forall a. Bounded a => a
minBound :: a))
            (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger (forall a. Bounded a => a
maxBound :: a))
    in forall a. Typeable a => Value a -> Value a
Codec.identified forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe
        Integer -> Maybe a
from
        (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Integer
into)
        forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Identifier, Schema)
schema }

optionalNullable
    :: Typeable.Typeable a
    => Name.Name
    -> Codec.Value a
    -> Codec.Object (Maybe a)
optionalNullable :: forall a. Typeable a => Name -> Value a -> Object (Maybe a)
optionalNullable Name
k =
    forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map
            (forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Maybe a
Nothing forall a. Nullable a -> Maybe a
Nullable.toMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Optional a -> Maybe a
Optional.toMaybe)
            (forall a. Maybe a -> Optional a
Optional.fromMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Nullable a
Nullable.just)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Name -> Value a -> Object (Optional a)
Codec.optional Name
k
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Typeable a => Value a -> Value (Nullable a)
nullable

nullable
    :: Typeable.Typeable a
    => Codec.Value a
    -> Codec.Value (Nullable.Nullable a)
nullable :: forall a. Typeable a => Value a -> Value (Nullable a)
nullable Value a
c =
    forall a. Typeable a => Value a -> Value a
Codec.identified
        forall a b. (a -> b) -> a -> b
$ forall (r :: * -> *) (w :: * -> *) o2 o1 i1 i2 s.
(Alternative r, Alternative w, Monad r, Monad w) =>
(o2 -> Maybe o1)
-> (i1 -> Maybe i2) -> Codec r w s i2 o2 -> Codec r w s i1 o1
Codec.mapMaybe (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Nullable a
Nullable.just) forall a. Nullable a -> Maybe a
Nullable.toMaybe Value a
c
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map (forall a b. a -> b -> a
const forall a. Nullable a
Nullable.nothing) (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ () -> Null
Null.fromUnit ()) forall a. HasCodec a => Value a
codec