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

module Argo.Class.HasCodec where

import Control.Applicative ((<|>))

import qualified Argo.Codec.Array as Codec
import qualified Argo.Codec.Codec as Codec
import qualified Argo.Codec.Object as Codec
import qualified Argo.Codec.Value as Codec
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.Schema.Identifier as Identifier
import qualified Argo.Schema.Schema as Schema
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.Nullable as Nullable
import qualified Argo.Type.Optional as Optional
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.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 = Schema -> (Value -> Value) -> (Value -> Maybe Value) -> Value Value
forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
valueCodec Schema
Schema.true Value -> Value
forall a. a -> a
id Value -> Maybe Value
forall a. a -> Maybe a
Just

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

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

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

instance HasCodec a => HasCodec (Maybe a) where
    codec :: Value (Maybe a)
codec =
        Value (Maybe a) -> Value (Maybe a)
forall a. Typeable a => Value a -> Value a
Codec.identified (Value (Maybe a) -> Value (Maybe a))
-> Value (Maybe a) -> Value (Maybe a)
forall a b. (a -> b) -> a -> b
$ (Nullable a -> Maybe a)
-> (Maybe a -> Nullable a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     (Nullable a)
     (Nullable a)
-> Value (Maybe 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 Nullable a -> Maybe a
forall a. Nullable a -> Maybe a
Nullable.toMaybe Maybe a -> Nullable a
forall a. Maybe a -> Nullable a
Nullable.fromMaybe Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  (Nullable a)
  (Nullable a)
forall a. HasCodec a => Value a
codec

instance
    ( HasCodec a
    , HasCodec b
    ) => HasCodec (Either a b) where
    codec :: Value (Either a b)
codec =
        Value (Either a b) -> Value (Either a b)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (Either a b) -> Value (Either a b))
-> Value (Either a b) -> Value (Either a b)
forall a b. (a -> b) -> a -> b
$ (a -> Maybe (Either a b))
-> (Either a b -> Maybe a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     a
     a
-> Value (Either 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
                  (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
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     a
     a
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     a
     a
forall a. String -> Value a -> Value a
Codec.tagged String
"Left" Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  a
  a
forall a. HasCodec a => Value a
codec)
            Value (Either a b) -> Value (Either a b) -> Value (Either a b)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (b -> Maybe (Either a b))
-> (Either a b -> Maybe b)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     b
     b
-> Value (Either 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
                    (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
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     b
     b
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     b
     b
forall a. String -> Value a -> Value a
Codec.tagged String
"Right" Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  b
  b
forall a. HasCodec a => Value a
codec)

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

instance
    ( HasCodec a
    , HasCodec b
    ) => HasCodec (a, b) where
    codec :: Value (a, b)
codec =
        Value (a, b) -> Value (a, b)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (a, b) -> Value (a, b))
-> (Array (a, b) -> Value (a, b)) -> Array (a, b) -> Value (a, b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permission -> Array (a, b) -> Value (a, b)
forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            (Array (a, b) -> Value (a, b)) -> Array (a, b) -> Value (a, b)
forall a b. (a -> b) -> a -> b
$ (,)
            (a -> b -> (a, b))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b)
     (b -> (a, b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b) -> a)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b)
     a
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) -> a
forall a b. (a, b) -> a
fst (Value a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
forall a. Value a -> Array a
Codec.element Value a
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b)
  (b -> (a, b))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b)
     b
-> Array (a, b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b) -> b)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b)
     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
forall a b. (a, b) -> b
snd (Value b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
forall a. Value a -> Array a
Codec.element Value b
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 =
        Value (a, b, c) -> Value (a, b, c)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (a, b, c) -> Value (a, b, c))
-> (Array (a, b, c) -> Value (a, b, c))
-> Array (a, b, c)
-> Value (a, b, c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permission -> Array (a, b, c) -> Value (a, b, c)
forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            (Array (a, b, c) -> Value (a, b, c))
-> Array (a, b, c) -> Value (a, b, c)
forall a b. (a -> b) -> a -> b
$ (,,)
            (a -> b -> c -> (a, b, c))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     (b -> c -> (a, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b, c) -> a)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     a
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) (Value a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
forall a. Value a -> Array a
Codec.element Value a
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c)
  (b -> c -> (a, b, c))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     (c -> (a, b, c))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c) -> b)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     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) (Value b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
forall a. Value a -> Array a
Codec.element Value b
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c)
  (c -> (a, b, c))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     c
-> Array (a, b, c)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c) -> c)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c)
     c
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) (Value c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
forall a. Value a -> Array a
Codec.element Value c
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 =
        Value (a, b, c, d) -> Value (a, b, c, d)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (a, b, c, d) -> Value (a, b, c, d))
-> (Array (a, b, c, d) -> Value (a, b, c, d))
-> Array (a, b, c, d)
-> Value (a, b, c, d)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permission -> Array (a, b, c, d) -> Value (a, b, c, d)
forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            (Array (a, b, c, d) -> Value (a, b, c, d))
-> Array (a, b, c, d) -> Value (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ (,,,)
            (a -> b -> c -> d -> (a, b, c, d))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     (b -> c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b, c, d) -> a)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     a
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) (Value a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
forall a. Value a -> Array a
Codec.element Value a
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d)
  (b -> c -> d -> (a, b, c, d))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     (c -> d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d) -> b)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     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) (Value b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
forall a. Value a -> Array a
Codec.element Value b
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d)
  (c -> d -> (a, b, c, d))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     (d -> (a, b, c, d))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d) -> c)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     c
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) (Value c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
forall a. Value a -> Array a
Codec.element Value c
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d)
  (d -> (a, b, c, d))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     d
-> Array (a, b, c, d)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d) -> d)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d)
     d
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) (Value d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
forall a. Value a -> Array a
Codec.element Value d
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 =
        Value (a, b, c, d, e) -> Value (a, b, c, d, e)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (a, b, c, d, e) -> Value (a, b, c, d, e))
-> (Array (a, b, c, d, e) -> Value (a, b, c, d, e))
-> Array (a, b, c, d, e)
-> Value (a, b, c, d, e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permission -> Array (a, b, c, d, e) -> Value (a, b, c, d, e)
forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            (Array (a, b, c, d, e) -> Value (a, b, c, d, e))
-> Array (a, b, c, d, e) -> Value (a, b, c, d, e)
forall a b. (a -> b) -> a -> b
$ (,,,,)
            (a -> b -> c -> d -> e -> (a, b, c, d, e))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     (b -> c -> d -> e -> (a, b, c, d, e))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b, c, d, e) -> a)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     a
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) (Value a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
forall a. Value a -> Array a
Codec.element Value a
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e)
  (b -> c -> d -> e -> (a, b, c, d, e))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     (c -> d -> e -> (a, b, c, d, e))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e) -> b)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     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) (Value b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
forall a. Value a -> Array a
Codec.element Value b
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e)
  (c -> d -> e -> (a, b, c, d, e))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     (d -> e -> (a, b, c, d, e))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e) -> c)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     c
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) (Value c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
forall a. Value a -> Array a
Codec.element Value c
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e)
  (d -> e -> (a, b, c, d, e))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     (e -> (a, b, c, d, e))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e) -> d)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     d
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) (Value d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
forall a. Value a -> Array a
Codec.element Value d
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e)
  (e -> (a, b, c, d, e))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     e
-> Array (a, b, c, d, e)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e) -> e)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e)
     e
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) (Value e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
forall a. Value a -> Array a
Codec.element Value e
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 =
        Value (a, b, c, d, e, f) -> Value (a, b, c, d, e, f)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (a, b, c, d, e, f) -> Value (a, b, c, d, e, f))
-> (Array (a, b, c, d, e, f) -> Value (a, b, c, d, e, f))
-> Array (a, b, c, d, e, f)
-> Value (a, b, c, d, e, f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permission -> Array (a, b, c, d, e, f) -> Value (a, b, c, d, e, f)
forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            (Array (a, b, c, d, e, f) -> Value (a, b, c, d, e, f))
-> Array (a, b, c, d, e, f) -> Value (a, b, c, d, e, f)
forall a b. (a -> b) -> a -> b
$ (,,,,,)
            (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b, c, d, e, f) -> a)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     a
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) (Value a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
forall a. Value a -> Array a
Codec.element Value a
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f)
  (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     (c -> d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f) -> b)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, 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) (Value b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
forall a. Value a -> Array a
Codec.element Value b
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f)
  (c -> d -> e -> f -> (a, b, c, d, e, f))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     (d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f) -> c)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     c
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) (Value c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
forall a. Value a -> Array a
Codec.element Value c
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f)
  (d -> e -> f -> (a, b, c, d, e, f))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     (e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f) -> d)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     d
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) (Value d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
forall a. Value a -> Array a
Codec.element Value d
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f)
  (e -> f -> (a, b, c, d, e, f))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     (f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f) -> e)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     e
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) (Value e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
forall a. Value a -> Array a
Codec.element Value e
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f)
  (f -> (a, b, c, d, e, f))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     f
-> Array (a, b, c, d, e, f)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f) -> f)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     f
     f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f)
     f
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) (Value f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     f
     f
forall a. Value a -> Array a
Codec.element Value f
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 =
        Value (a, b, c, d, e, f, g) -> Value (a, b, c, d, e, f, g)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (a, b, c, d, e, f, g) -> Value (a, b, c, d, e, f, g))
-> (Array (a, b, c, d, e, f, g) -> Value (a, b, c, d, e, f, g))
-> Array (a, b, c, d, e, f, g)
-> Value (a, b, c, d, e, f, g)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permission
-> Array (a, b, c, d, e, f, g) -> Value (a, b, c, d, e, f, g)
forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            (Array (a, b, c, d, e, f, g) -> Value (a, b, c, d, e, f, g))
-> Array (a, b, c, d, e, f, g) -> Value (a, b, c, d, e, f, g)
forall a b. (a -> b) -> a -> b
$ (,,,,,,)
            (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b, c, d, e, f, g) -> a)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     a
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)
                    (Value a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
forall a. Value a -> Array a
Codec.element Value a
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g)
  (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g) -> b)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     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)
                    (Value b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
forall a. Value a -> Array a
Codec.element Value b
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g)
  (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     (d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g) -> c)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     c
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)
                    (Value c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
forall a. Value a -> Array a
Codec.element Value c
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g)
  (d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     (e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g) -> d)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     d
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)
                    (Value d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
forall a. Value a -> Array a
Codec.element Value d
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g)
  (e -> f -> g -> (a, b, c, d, e, f, g))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     (f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g) -> e)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     e
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)
                    (Value e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
forall a. Value a -> Array a
Codec.element Value e
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g)
  (f -> g -> (a, b, c, d, e, f, g))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     (g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g) -> f)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     f
     f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     f
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)
                    (Value f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     f
     f
forall a. Value a -> Array a
Codec.element Value f
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g)
  (g -> (a, b, c, d, e, f, g))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     g
-> Array (a, b, c, d, e, f, g)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g) -> g)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     g
     g
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g)
     g
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)
                    (Value g
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     g
     g
forall a. Value a -> Array a
Codec.element Value g
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 =
        Value (a, b, c, d, e, f, g, h) -> Value (a, b, c, d, e, f, g, h)
forall a. Typeable a => Value a -> Value a
Codec.identified
            (Value (a, b, c, d, e, f, g, h) -> Value (a, b, c, d, e, f, g, h))
-> (Array (a, b, c, d, e, f, g, h)
    -> Value (a, b, c, d, e, f, g, h))
-> Array (a, b, c, d, e, f, g, h)
-> Value (a, b, c, d, e, f, g, h)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Permission
-> Array (a, b, c, d, e, f, g, h) -> Value (a, b, c, d, e, f, g, h)
forall a. Permission -> Array a -> Value a
Codec.fromArrayCodec Permission
Permission.Forbid
            (Array (a, b, c, d, e, f, g, h) -> Value (a, b, c, d, e, f, g, h))
-> Array (a, b, c, d, e, f, g, h) -> Value (a, b, c, d, e, f, g, h)
forall a b. (a -> b) -> a -> b
$ (,,,,,,,)
            (a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, b, c, d, e, f, g, h) -> a)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     a
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)
                    (Value a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     a
     a
forall a. Value a -> Array a
Codec.element Value a
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g, h)
  (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g, h) -> b)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     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)
                    (Value b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     b
     b
forall a. Value a -> Array a
Codec.element Value b
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g, h)
  (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g, h) -> c)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     c
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)
                    (Value c
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     c
     c
forall a. Value a -> Array a
Codec.element Value c
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g, h)
  (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g, h) -> d)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     d
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)
                    (Value d
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     d
     d
forall a. Value a -> Array a
Codec.element Value d
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g, h)
  (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     (f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g, h) -> e)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     e
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)
                    (Value e
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     e
     e
forall a. Value a -> Array a
Codec.element Value e
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g, h)
  (f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     (g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g, h) -> f)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     f
     f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     f
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)
                    (Value f
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     f
     f
forall a. Value a -> Array a
Codec.element Value f
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g, h)
  (g -> h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     g
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     (h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g, h) -> g)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     g
     g
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     g
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)
                    (Value g
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     g
     g
forall a. Value a -> Array a
Codec.element Value g
forall a. HasCodec a => Value a
codec)
            Codec
  (StateT [Value] (ExceptT String Identity))
  (WriterT [Value] Identity)
  (AccumT
     (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
  (a, b, c, d, e, f, g, h)
  (h -> (a, b, c, d, e, f, g, h))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     h
-> Array (a, b, c, d, e, f, g, h)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((a, b, c, d, e, f, g, h) -> h)
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     h
     h
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     (a, b, c, d, e, f, g, h)
     h
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)
                    (Value h
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     (AccumT
        (Map Identifier Schema) Identity [(Maybe Identifier, Schema)])
     h
     h
forall a. Value a -> Array a
Codec.element Value h
forall a. HasCodec a => Value a
codec)

instance HasCodec Bool where
    codec :: Value Bool
codec = Value Bool -> Value Bool
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Bool -> Value Bool) -> Value Bool -> Value Bool
forall a b. (a -> b) -> a -> b
$ (Boolean -> Bool)
-> (Bool -> Boolean) -> Value Boolean -> Value Bool
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 Value Boolean
forall a. HasCodec a => Value a
codec

instance HasCodec Decimal.Decimal where
    codec :: Value Decimal
codec =
        Value Decimal -> Value Decimal
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Decimal -> Value Decimal) -> Value Decimal -> Value Decimal
forall a b. (a -> b) -> a -> b
$ (Number -> Decimal)
-> (Decimal -> Number) -> Value Number -> Value Decimal
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 Value Number
forall a. HasCodec a => Value a
codec

instance HasCodec Text.Text where
    codec :: Value Text
codec = Value Text -> Value Text
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Text -> Value Text) -> Value Text -> Value Text
forall a b. (a -> b) -> a -> b
$ (String -> Text) -> (Text -> String) -> Value String -> Value Text
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 Value String
forall a. HasCodec a => Value a
codec

instance {-# OVERLAPPABLE #-} HasCodec a => HasCodec [a] where
    codec :: Value [a]
codec = Value [a] -> Value [a]
forall a. Typeable a => Value a -> Value a
Codec.identified (Value [a] -> Value [a]) -> Value [a] -> Value [a]
forall a b. (a -> b) -> a -> b
$ (Array a -> [a])
-> ([a] -> Array a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     (Array a)
     (Array a)
-> Value [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 Array a -> [a]
forall value. Array value -> [value]
Array.toList [a] -> Array a
forall value. [value] -> Array value
Array.fromList Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  (Array a)
  (Array a)
forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map Name.Name a) where
    codec :: Value (Map Name a)
codec = Value (Map Name a) -> Value (Map Name a)
forall a. Typeable a => Value a -> Value a
Codec.identified (Value (Map Name a) -> Value (Map Name a))
-> Value (Map Name a) -> Value (Map Name a)
forall a b. (a -> b) -> a -> b
$ (Object a -> Map Name a)
-> (Map Name a -> Object a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     (Object a)
     (Object a)
-> Value (Map Name 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
        ([(Name, a)] -> Map Name a
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Name, a)] -> Map Name a)
-> (Object a -> [(Name, a)]) -> Object a -> Map Name a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Member a -> (Name, a)) -> [Member a] -> [(Name, a)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Member a -> (Name, a)
forall value. Member value -> (Name, value)
Member.toTuple ([Member a] -> [(Name, a)])
-> (Object a -> [Member a]) -> Object a -> [(Name, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object a -> [Member a]
forall value. Object value -> [Member value]
Object.toList)
        ([Member a] -> Object a
forall value. [Member value] -> Object value
Object.fromList ([Member a] -> Object a)
-> (Map Name a -> [Member a]) -> Map Name a -> Object a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Name, a) -> Member a) -> [(Name, a)] -> [Member a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Name, a) -> Member a
forall value. (Name, value) -> Member value
Member.fromTuple ([(Name, a)] -> [Member a])
-> (Map Name a -> [(Name, a)]) -> Map Name a -> [Member 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))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  (Object a)
  (Object a)
forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map String.String a) where
    codec :: Value (Map String a)
codec = Value (Map String a) -> Value (Map String a)
forall a. Typeable a => Value a -> Value a
Codec.identified (Value (Map String a) -> Value (Map String a))
-> Value (Map String a) -> Value (Map String a)
forall a b. (a -> b) -> a -> b
$ (Map Name a -> Map String a)
-> (Map String a -> Map Name a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     (Map Name a)
     (Map Name a)
-> Value (Map String 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
        ((Name -> String) -> Map Name a -> Map String a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Name -> String
Name.toString)
        ((String -> Name) -> Map String a -> Map Name a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys String -> Name
Name.fromString)
        Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  (Map Name a)
  (Map Name a)
forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map Text.Text a) where
    codec :: Value (Map Text a)
codec = Value (Map Text a) -> Value (Map Text a)
forall a. Typeable a => Value a -> Value a
Codec.identified (Value (Map Text a) -> Value (Map Text a))
-> Value (Map Text a) -> Value (Map Text a)
forall a b. (a -> b) -> a -> b
$ (Map String a -> Map Text a)
-> (Map Text a -> Map String a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     (Map String a)
     (Map String a)
-> Value (Map Text 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
        ((String -> Text) -> Map String a -> Map Text a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys String -> Text
String.toText)
        ((Text -> String) -> Map Text a -> Map String a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Text -> String
String.fromText)
        Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  (Map String a)
  (Map String a)
forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map Text.LazyText a) where
    codec :: Value (Map LazyText a)
codec = Value (Map LazyText a) -> Value (Map LazyText a)
forall a. Typeable a => Value a -> Value a
Codec.identified (Value (Map LazyText a) -> Value (Map LazyText a))
-> Value (Map LazyText a) -> Value (Map LazyText a)
forall a b. (a -> b) -> a -> b
$ (Map Text a -> Map LazyText a)
-> (Map LazyText a -> Map Text a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     (Map Text a)
     (Map Text a)
-> Value (Map LazyText 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
        ((Text -> LazyText) -> Map Text a -> Map LazyText a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Text -> LazyText
Text.fromStrict)
        ((LazyText -> Text) -> Map LazyText a -> Map Text a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys LazyText -> Text
Text.toStrict)
        Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  (Map Text a)
  (Map Text a)
forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map String a) where
    codec :: Value (Map String a)
codec = Value (Map String a) -> Value (Map String a)
forall a. Typeable a => Value a -> Value a
Codec.identified
        (Value (Map String a) -> Value (Map String a))
-> Value (Map String a) -> Value (Map String a)
forall a b. (a -> b) -> a -> b
$ (Map Text a -> Map String a)
-> (Map String a -> Map Text a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     (Map Text a)
     (Map Text a)
-> Value (Map String 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 ((Text -> String) -> Map Text a -> Map String a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys Text -> String
Text.unpack) ((String -> Text) -> Map String a -> Map Text a
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys String -> Text
Text.pack) Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  (Map Text a)
  (Map Text a)
forall a. HasCodec a => Value a
codec

instance HasCodec String where
    codec :: Value String
codec = Value String -> Value String
forall a. Typeable a => Value a -> Value a
Codec.identified (Value String -> Value String) -> Value String -> Value String
forall a b. (a -> b) -> a -> b
$ (Text -> String) -> (String -> Text) -> Value Text -> Value String
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 Value Text
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 (Schema -> (Maybe Identifier, Schema))
-> Schema -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ Maybe Natural -> Maybe Natural -> Schema
Schema.String (Natural -> Maybe Natural
forall a. a -> Maybe a
Just Natural
1) (Natural -> Maybe Natural
forall a. a -> Maybe a
Just Natural
1)
        in
            Value Char -> Value Char
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Char -> Value Char) -> Value Char -> Value Char
forall a b. (a -> b) -> a -> b
$ (Text -> Maybe Char)
-> (Char -> Maybe Text) -> Value Text -> Value Char
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 -> 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)
                Value Text
forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = (Maybe Identifier, Schema)
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Identifier, Schema)
schema }

instance HasCodec Text.LazyText where
    codec :: Value LazyText
codec = Value LazyText -> Value LazyText
forall a. Typeable a => Value a -> Value a
Codec.identified (Value LazyText -> Value LazyText)
-> Value LazyText -> Value LazyText
forall a b. (a -> b) -> a -> b
$ (Text -> LazyText)
-> (LazyText -> Text) -> Value Text -> Value LazyText
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 Value Text
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 <- Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  a
  a
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall (r :: * -> *) (w :: * -> *) s i o. Codec r w s i o -> s
Codec.schema (Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  a
  a
forall a. HasCodec a => Value a
codec :: Codec.Value a)
                (Maybe Identifier, Schema)
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Maybe Identifier, Schema)
 -> AccumT
      (Map Identifier Schema) Identity (Maybe Identifier, Schema))
-> (Schema -> (Maybe Identifier, Schema))
-> Schema
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Schema -> (Maybe Identifier, Schema)
Schema.unidentified (Schema
 -> AccumT
      (Map Identifier Schema) Identity (Maybe Identifier, Schema))
-> Schema
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ Maybe Natural
-> Maybe Natural
-> Either Schema (NonEmpty Schema)
-> Maybe Schema
-> Schema
Schema.Array
                    (Natural -> Maybe Natural
forall a. a -> Maybe a
Just Natural
1)
                    Maybe Natural
forall a. Maybe a
Nothing
                    (Schema -> Either Schema (NonEmpty Schema)
forall a b. a -> Either a b
Left (Schema -> Either Schema (NonEmpty Schema))
-> Schema -> Either Schema (NonEmpty Schema)
forall a b. (a -> b) -> a -> b
$ (Maybe Identifier, Schema) -> Schema
Schema.maybeRef (Maybe Identifier, Schema)
itemSchema)
                    Maybe Schema
forall a. Maybe a
Nothing
        in
            Value (NonEmpty a) -> Value (NonEmpty a)
forall a. Typeable a => Value a -> Value a
Codec.identified (Value (NonEmpty a) -> Value (NonEmpty a))
-> Value (NonEmpty a) -> Value (NonEmpty a)
forall a b. (a -> b) -> a -> b
$ ([a] -> Maybe (NonEmpty a))
-> (NonEmpty a -> Maybe [a])
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     [a]
     [a]
-> Value (NonEmpty 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
                [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)
                Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  (AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema))
  [a]
  [a]
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 (Schema -> (Maybe Identifier, Schema))
-> Schema -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Integer -> Schema
Schema.Integer Maybe Integer
forall a. Maybe a
Nothing Maybe Integer
forall a. Maybe a
Nothing
        in
            Value Integer -> Value Integer
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Integer -> Value Integer) -> Value Integer -> Value Integer
forall a b. (a -> b) -> a -> b
$ (Decimal -> Maybe Integer)
-> (Integer -> Maybe Decimal) -> Value Decimal -> Value Integer
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
                (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)
                Value Decimal
forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = (Maybe Identifier, Schema)
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Identifier, Schema)
schema }

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

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

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

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

instance HasCodec Int.Int64 where
    codec :: Value Int64
codec = Value Int64
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 = Integer -> Maybe Natural
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Natural.Natural
            into :: Natural -> Integer
into = Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Natural.Natural -> Integer
            schema :: (Maybe Identifier, Schema)
schema = Schema -> (Maybe Identifier, Schema)
Schema.unidentified (Schema -> (Maybe Identifier, Schema))
-> Schema -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Integer -> Schema
Schema.Integer (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0) Maybe Integer
forall a. Maybe a
Nothing
        in Value Natural -> Value Natural
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Natural -> Value Natural) -> Value Natural -> Value Natural
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Natural)
-> (Natural -> Maybe Integer) -> Value Integer -> Value Natural
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
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Natural -> Integer) -> Natural -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Integer
into)
            Value Integer
forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = (Maybe Identifier, Schema)
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe Identifier, Schema)
schema }

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

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

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

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

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

instance HasCodec Float where
    codec :: Value Float
codec = Value Float -> Value Float
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Float -> Value Float) -> Value Float -> Value Float
forall a b. (a -> b) -> a -> b
$ (Decimal -> Maybe Float)
-> (Float -> Maybe Decimal) -> Value Decimal -> Value Float
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
        (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
        Value Decimal
forall a. HasCodec a => Value a
codec

instance HasCodec Double where
    codec :: Value Double
codec = Value Double -> Value Double
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Double -> Value Double) -> Value Double -> Value Double
forall a b. (a -> b) -> a -> b
$ (Decimal -> Maybe Double)
-> (Double -> Maybe Decimal) -> Value Decimal -> Value Double
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
        (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
        Value Decimal
forall a. HasCodec a => Value a
codec

instance HasCodec Pointer.Pointer where
    codec :: Value Pointer
codec = Value Pointer -> Value Pointer
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Pointer -> Value Pointer) -> Value Pointer -> Value Pointer
forall a b. (a -> b) -> a -> b
$ (Text -> Maybe Pointer)
-> (Pointer -> Maybe Text) -> Value Text -> Value Pointer
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
        ((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
        )
        Value Text
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
            Value Identifier -> Value Identifier
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Identifier -> Value Identifier)
-> Value Identifier -> Value Identifier
forall a b. (a -> b) -> a -> b
$ (Text -> Maybe Identifier)
-> (Identifier -> Maybe Text) -> Value Text -> Value Identifier
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 -> Identifier) -> Maybe Text -> Maybe Identifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Identifier
Identifier.fromText (Maybe Text -> Maybe Identifier)
-> (Text -> Maybe Text) -> Text -> Maybe Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Maybe Text
Text.stripPrefix Text
prefix)
                (Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text)
-> (Identifier -> Text) -> Identifier -> Maybe Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> Text
forall a. Monoid a => a -> a -> a
mappend Text
prefix (Text -> Text) -> (Identifier -> Text) -> Identifier -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Text
Identifier.toText)
                Value Text
forall a. HasCodec a => Value a
codec

instance HasCodec Name.Name where
    codec :: Value Name
codec = Value Name -> Value Name
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Name -> Value Name) -> Value Name -> Value Name
forall a b. (a -> b) -> a -> b
$ (String -> Name) -> (Name -> String) -> Value String -> Value Name
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 Value String
forall a. HasCodec a => Value a
codec

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

integralCodec
    :: forall a
     . (Bits.Bits a, Bounded a, Integral a, Typeable.Typeable a)
    => Codec.Value a
integralCodec :: Value a
integralCodec =
    let
        from :: Integer -> Maybe a
from = Integer -> Maybe a
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe a
        into :: a -> Integer
into = a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: a -> Integer
        schema :: (Maybe Identifier, Schema)
schema = Schema -> (Maybe Identifier, Schema)
Schema.unidentified (Schema -> (Maybe Identifier, Schema))
-> Schema -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ Maybe Integer -> Maybe Integer -> Schema
Schema.Integer
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer) -> Integer -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ a -> Integer
forall a. Integral a => a -> Integer
toInteger (a
forall a. Bounded a => a
minBound :: a))
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer) -> Integer -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ a -> Integer
forall a. Integral a => a -> Integer
toInteger (a
forall a. Bounded a => a
maxBound :: a))
    in Value a -> Value a
forall a. Typeable a => Value a -> Value a
Codec.identified (Value a -> Value a) -> Value a -> Value a
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe a)
-> (a -> Maybe Integer) -> Value Integer -> Value 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
        Integer -> Maybe a
from
        (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer) -> (a -> Integer) -> a -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Integer
into)
        Value Integer
forall a. HasCodec a => Value a
codec { schema :: AccumT (Map Identifier Schema) Identity (Maybe Identifier, Schema)
Codec.schema = (Maybe Identifier, Schema)
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, 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 :: Name -> Value a -> Object (Maybe a)
optionalNullable Name
k =
    (Optional (Nullable a) -> Maybe a)
-> (Maybe a -> Optional (Nullable a))
-> Codec
     (StateT [Member Value] (ExceptT String Identity))
     (WriterT [Member Value] Identity)
     (AccumT
        (Map Identifier Schema)
        Identity
        [((Name, Bool), (Maybe Identifier, Schema))])
     (Optional (Nullable a))
     (Optional (Nullable a))
-> Object (Maybe 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
            (Maybe a -> (Nullable a -> Maybe a) -> Maybe (Nullable a) -> Maybe a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe a
forall a. Maybe a
Nothing Nullable a -> Maybe a
forall a. Nullable a -> Maybe a
Nullable.toMaybe (Maybe (Nullable a) -> Maybe a)
-> (Optional (Nullable a) -> Maybe (Nullable a))
-> Optional (Nullable a)
-> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Optional (Nullable a) -> Maybe (Nullable a)
forall a. Optional a -> Maybe a
Optional.toMaybe)
            (Maybe (Nullable a) -> Optional (Nullable a)
forall a. Maybe a -> Optional a
Optional.fromMaybe (Maybe (Nullable a) -> Optional (Nullable a))
-> (Maybe a -> Maybe (Nullable a))
-> Maybe a
-> Optional (Nullable a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Nullable a) -> Maybe a -> Maybe (Nullable a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Nullable a
forall a. a -> Nullable a
Nullable.just)
        (Codec
   (StateT [Member Value] (ExceptT String Identity))
   (WriterT [Member Value] Identity)
   (AccumT
      (Map Identifier Schema)
      Identity
      [((Name, Bool), (Maybe Identifier, Schema))])
   (Optional (Nullable a))
   (Optional (Nullable a))
 -> Object (Maybe a))
-> (Value a
    -> Codec
         (StateT [Member Value] (ExceptT String Identity))
         (WriterT [Member Value] Identity)
         (AccumT
            (Map Identifier Schema)
            Identity
            [((Name, Bool), (Maybe Identifier, Schema))])
         (Optional (Nullable a))
         (Optional (Nullable a)))
-> Value a
-> Object (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name
-> Value (Nullable a)
-> Codec
     (StateT [Member Value] (ExceptT String Identity))
     (WriterT [Member Value] Identity)
     (AccumT
        (Map Identifier Schema)
        Identity
        [((Name, Bool), (Maybe Identifier, Schema))])
     (Optional (Nullable a))
     (Optional (Nullable a))
forall a. Name -> Value a -> Object (Optional a)
Codec.optional Name
k
        (Value (Nullable a)
 -> Codec
      (StateT [Member Value] (ExceptT String Identity))
      (WriterT [Member Value] Identity)
      (AccumT
         (Map Identifier Schema)
         Identity
         [((Name, Bool), (Maybe Identifier, Schema))])
      (Optional (Nullable a))
      (Optional (Nullable a)))
-> (Value a -> Value (Nullable a))
-> Value a
-> Codec
     (StateT [Member Value] (ExceptT String Identity))
     (WriterT [Member Value] Identity)
     (AccumT
        (Map Identifier Schema)
        Identity
        [((Name, Bool), (Maybe Identifier, Schema))])
     (Optional (Nullable a))
     (Optional (Nullable a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value a -> Value (Nullable a)
forall a. Typeable a => Value a -> Value (Nullable a)
nullable

nullable
    :: Typeable.Typeable a
    => Codec.Value a
    -> Codec.Value (Nullable.Nullable a)
nullable :: Value a -> Value (Nullable a)
nullable Value a
c =
    Value (Nullable a) -> Value (Nullable a)
forall a. Typeable a => Value a -> Value a
Codec.identified
        (Value (Nullable a) -> Value (Nullable a))
-> Value (Nullable a) -> Value (Nullable a)
forall a b. (a -> b) -> a -> b
$ (a -> Maybe (Nullable a))
-> (Nullable a -> Maybe a) -> Value a -> Value (Nullable 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 (Nullable a -> Maybe (Nullable a)
forall a. a -> Maybe a
Just (Nullable a -> Maybe (Nullable a))
-> (a -> Nullable a) -> a -> Maybe (Nullable a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Nullable a
forall a. a -> Nullable a
Nullable.just) Nullable a -> Maybe a
forall a. Nullable a -> Maybe a
Nullable.toMaybe Value a
c
        Value (Nullable a) -> Value (Nullable a) -> Value (Nullable a)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Null -> Nullable a)
-> (Nullable a -> Null) -> Value Null -> Value (Nullable 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 (Nullable a -> Null -> Nullable a
forall a b. a -> b -> a
const Nullable a
forall a. Nullable a
Nullable.nothing) (Null -> Nullable a -> Null
forall a b. a -> b -> a
const (Null -> Nullable a -> Null) -> Null -> Nullable a -> Null
forall a b. (a -> b) -> a -> b
$ () -> Null
Null.fromUnit ()) Value Null
forall a. HasCodec a => Value a
codec