{-# 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.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.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.Typeable as Typeable
import qualified Data.Word as Word
import qualified Numeric.Natural as Natural

class 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
basicCodec 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 = Value -> Schema
Schema.fromValue (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object (Object Value -> Schema) -> Object Value -> Schema
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                      ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"type"
                      , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"null"
                      )
                ]
        in
            Schema -> (Null -> Value) -> (Value -> Maybe Null) -> Value Null
forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec 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 = Value -> Schema
Schema.fromValue (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object (Object Value -> Schema) -> Object Value -> Schema
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                      ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"type"
                      , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"boolean"
                      )
                ]
        in
            Schema
-> (Boolean -> Value) -> (Value -> Maybe Boolean) -> Value Boolean
forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec 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 = Value -> Schema
Schema.fromValue (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object (Object Value -> Schema) -> Object Value -> Schema
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                      ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"type"
                      , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"number"
                      )
                ]
        in
            Schema
-> (Number -> Value) -> (Value -> Maybe Number) -> Value Number
forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec 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 = Value -> Schema
Schema.fromValue (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object (Object Value -> Schema) -> Object Value -> Schema
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                      ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"type"
                      , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"string"
                      )
                ]
        in
            Schema
-> (String -> Value) -> (Value -> Maybe String) -> Value String
forall a.
Typeable a =>
Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec 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, Typeable.Typeable 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
            Either Schema Identifier
ref <- Value a
-> AccumT
     (Map Identifier Schema) Identity (Either Schema Identifier)
forall a.
Value a
-> AccumT
     (Map Identifier Schema) Identity (Either Schema Identifier)
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))
-> (Object Value -> (Maybe Identifier, Schema))
-> Object Value
-> 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))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                (Object Value
 -> AccumT
      (Map Identifier Schema) Identity (Maybe Identifier, Schema))
-> Object Value
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                      [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                          ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                              String
"type"
                          , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"array"
                          )
                      , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                          ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                              String
"items"
                          , Either Schema Identifier -> Value
Codec.ref Either Schema Identifier
ref
                          )
                      ]
        }

instance (HasCodec a, Typeable.Typeable 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
            Either Schema Identifier
ref <- Value a
-> AccumT
     (Map Identifier Schema) Identity (Either Schema Identifier)
forall a.
Value a
-> AccumT
     (Map Identifier Schema) Identity (Either Schema Identifier)
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))
-> (Object Value -> (Maybe Identifier, Schema))
-> Object Value
-> 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))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                (Object Value
 -> AccumT
      (Map Identifier Schema) Identity (Maybe Identifier, Schema))
-> Object Value
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                      [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                          ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                              String
"type"
                          , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack String
"object"
                          )
                      , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                          ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                              String
"additionalProperties"
                          , Either Schema Identifier -> Value
Codec.ref Either Schema Identifier
ref
                          )
                      ]
        }

instance (HasCodec a, Typeable.Typeable 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
$ (a -> Maybe (Maybe a))
-> (Maybe a -> Maybe a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     (AccumT
        (Map Identifier Schema) Identity (Maybe Identifier, Schema))
     a
     a
-> Value (Maybe 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 (Maybe a -> Maybe (Maybe a)
forall a. a -> Maybe a
Just (Maybe a -> Maybe (Maybe a))
-> (a -> Maybe a) -> a -> Maybe (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe a
forall a. a -> Maybe a
Just) Maybe a -> Maybe a
forall a. a -> a
id 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 (Maybe a) -> Value (Maybe a) -> Value (Maybe a)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Null -> Maybe a)
-> (Maybe a -> Null) -> Value Null -> 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 (Maybe a -> Null -> Maybe a
forall a b. a -> b -> a
const Maybe a
forall a. Maybe a
Nothing) (Null -> Maybe a -> Null
forall a b. a -> b -> a
const (Null -> Maybe a -> Null) -> Null -> Maybe a -> Null
forall a b. (a -> b) -> a -> b
$ () -> Null
Null.fromUnit ()) Value Null
forall a. HasCodec a => Value a
codec

instance
    ( HasCodec a
    , HasCodec b
    , Typeable.Typeable a
    , Typeable.Typeable 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
    , Typeable.Typeable a
    , Typeable.Typeable 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
    , Typeable.Typeable a
    , Typeable.Typeable b
    , Typeable.Typeable 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
    , Typeable.Typeable a
    , Typeable.Typeable b
    , Typeable.Typeable c
    , Typeable.Typeable 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
    , Typeable.Typeable a
    , Typeable.Typeable b
    , Typeable.Typeable c
    , Typeable.Typeable d
    , Typeable.Typeable 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
    , Typeable.Typeable a
    , Typeable.Typeable b
    , Typeable.Typeable c
    , Typeable.Typeable d
    , Typeable.Typeable e
    , Typeable.Typeable 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
    , Typeable.Typeable a
    , Typeable.Typeable b
    , Typeable.Typeable c
    , Typeable.Typeable d
    , Typeable.Typeable e
    , Typeable.Typeable f
    , Typeable.Typeable 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
    , Typeable.Typeable a
    , Typeable.Typeable b
    , Typeable.Typeable c
    , Typeable.Typeable d
    , Typeable.Typeable e
    , Typeable.Typeable f
    , Typeable.Typeable g
    , Typeable.Typeable 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, Typeable.Typeable 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, Typeable.Typeable 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, Typeable.Typeable 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, Typeable.Typeable 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, Typeable.Typeable 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, Typeable.Typeable 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))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"string"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minLength"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Decimal -> Number) -> Decimal -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Value) -> Decimal -> Value
forall a b. (a -> b) -> a -> b
$ Integer -> Decimal
Decimal.fromInteger Integer
1
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maxLength"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Decimal -> Number) -> Decimal -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Value) -> Decimal -> Value
forall a b. (a -> b) -> a -> b
$ Integer -> Decimal
Decimal.fromInteger Integer
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, Typeable.Typeable 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))
-> (Object Value -> (Maybe Identifier, Schema))
-> Object Value
-> 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))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value
 -> AccumT
      (Map Identifier Schema) Identity (Maybe Identifier, Schema))
-> Object Value
-> AccumT
     (Map Identifier Schema) Identity (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"array"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"items"
                              , Schema -> Value
Schema.toValue Schema
itemSchema
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minItems"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Decimal -> Number) -> Decimal -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Value) -> Decimal -> Value
forall a b. (a -> b) -> a -> b
$ Integer -> Decimal
Decimal.fromInteger Integer
1
                              )
                          ]
        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))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                                ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                    String
"type"
                                , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                    String
"integer"
                                )
                          ]
        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 =
        let
            from :: Integer -> Maybe Int
from = Integer -> Maybe Int
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int
            into :: Int -> Integer
into = Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int
forall a. Bounded a => a
minBound :: Int)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int
forall a. Bounded a => a
maxBound :: Int)
                              )
                          ]
        in Value Int -> Value Int
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Int -> Value Int) -> Value Int -> Value Int
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Int)
-> (Int -> Maybe Integer) -> Value Integer -> Value Int
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 Int
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int -> Integer) -> Int -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
into)
            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 Int.Int8 where
    codec :: Value Int8
codec =
        let
            from :: Integer -> Maybe Int8
from = Integer -> Maybe Int8
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int8
            into :: Int8 -> Integer
into = Int8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int8 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int8
forall a. Bounded a => a
minBound :: Int.Int8)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int8
forall a. Bounded a => a
maxBound :: Int.Int8)
                              )
                          ]
        in Value Int8 -> Value Int8
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Int8 -> Value Int8) -> Value Int8 -> Value Int8
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Int8)
-> (Int8 -> Maybe Integer) -> Value Integer -> Value Int8
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 Int8
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int8 -> Integer) -> Int8 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int8 -> Integer
into)
            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 Int.Int16 where
    codec :: Value Int16
codec =
        let
            from :: Integer -> Maybe Int16
from = Integer -> Maybe Int16
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int16
            into :: Int16 -> Integer
into = Int16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int16 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int16
forall a. Bounded a => a
minBound :: Int.Int16)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int16
forall a. Bounded a => a
maxBound :: Int.Int16)
                              )
                          ]
        in Value Int16 -> Value Int16
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Int16 -> Value Int16) -> Value Int16 -> Value Int16
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Int16)
-> (Int16 -> Maybe Integer) -> Value Integer -> Value Int16
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 Int16
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int16 -> Integer) -> Int16 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Integer
into)
            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 Int.Int32 where
    codec :: Value Int32
codec =
        let
            from :: Integer -> Maybe Int32
from = Integer -> Maybe Int32
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int32
            into :: Int32 -> Integer
into = Int32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int32 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int32
forall a. Bounded a => a
minBound :: Int.Int32)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int32
forall a. Bounded a => a
maxBound :: Int.Int32)
                              )
                          ]
        in Value Int32 -> Value Int32
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Int32 -> Value Int32) -> Value Int32 -> Value Int32
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Int32)
-> (Int32 -> Maybe Integer) -> Value Integer -> Value Int32
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 Int32
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int32 -> Integer) -> Int32 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> Integer
into)
            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 Int.Int64 where
    codec :: Value Int64
codec =
        let
            from :: Integer -> Maybe Int64
from = Integer -> Maybe Int64
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Int.Int64
            into :: Int64 -> Integer
into = Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Int.Int64 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int64
forall a. Bounded a => a
minBound :: Int.Int64)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int64
forall a. Bounded a => a
maxBound :: Int.Int64)
                              )
                          ]
        in Value Int64 -> Value Int64
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Int64 -> Value Int64) -> Value Int64 -> Value Int64
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Int64)
-> (Int64 -> Maybe Integer) -> Value Integer -> Value Int64
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 Int64
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Int64 -> Integer) -> Int64 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Integer
into)
            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 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))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Decimal -> Number) -> Decimal -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Value) -> Decimal -> Value
forall a b. (a -> b) -> a -> b
$ Integer -> Decimal
Decimal.fromInteger Integer
0
                              )
                          ]
        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 =
        let
            from :: Integer -> Maybe Word
from = Integer -> Maybe Word
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word
            into :: Word -> Integer
into = Word -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word -> Integer
forall a. Integral a => a -> Integer
toInteger (Word
forall a. Bounded a => a
minBound :: Word)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word -> Integer
forall a. Integral a => a -> Integer
toInteger (Word
forall a. Bounded a => a
maxBound :: Word)
                              )
                          ]
        in Value Word -> Value Word
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Word -> Value Word) -> Value Word -> Value Word
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Word)
-> (Word -> Maybe Integer) -> Value Integer -> Value Word
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 Word
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word -> Integer) -> Word -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Integer
into)
            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.Word8 where
    codec :: Value Word8
codec =
        let
            from :: Integer -> Maybe Word8
from = Integer -> Maybe Word8
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word8
            into :: Word8 -> Integer
into = Word8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word8 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word8
forall a. Bounded a => a
minBound :: Word.Word8)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word8
forall a. Bounded a => a
maxBound :: Word.Word8)
                              )
                          ]
        in Value Word8 -> Value Word8
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Word8 -> Value Word8) -> Value Word8 -> Value Word8
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Word8)
-> (Word8 -> Maybe Integer) -> Value Integer -> Value Word8
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 Word8
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word8 -> Integer) -> Word8 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Integer
into)
            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.Word16 where
    codec :: Value Word16
codec =
        let
            from :: Integer -> Maybe Word16
from = Integer -> Maybe Word16
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word16
            into :: Word16 -> Integer
into = Word16 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word16 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word16
forall a. Bounded a => a
minBound :: Word.Word16)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word16
forall a. Bounded a => a
maxBound :: Word.Word16)
                              )
                          ]
        in Value Word16 -> Value Word16
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Word16 -> Value Word16) -> Value Word16 -> Value Word16
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Word16)
-> (Word16 -> Maybe Integer) -> Value Integer -> Value Word16
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 Word16
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word16 -> Integer) -> Word16 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Integer
into)
            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.Word32 where
    codec :: Value Word32
codec =
        let
            from :: Integer -> Maybe Word32
from = Integer -> Maybe Word32
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word32
            into :: Word32 -> Integer
into = Word32 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word32 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word32
forall a. Bounded a => a
minBound :: Word.Word32)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word32
forall a. Bounded a => a
maxBound :: Word.Word32)
                              )
                          ]
        in Value Word32 -> Value Word32
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Word32 -> Value Word32) -> Value Word32 -> Value Word32
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Word32)
-> (Word32 -> Maybe Integer) -> Value Integer -> Value Word32
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 Word32
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word32 -> Integer) -> Word32 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Integer
into)
            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.Word64 where
    codec :: Value Word64
codec =
        let
            from :: Integer -> Maybe Word64
from = Integer -> Maybe Word64
forall a b.
(Integral a, Integral b, Bits a, Bits b) =>
a -> Maybe b
Bits.toIntegralSized :: Integer -> Maybe Word.Word64
            into :: Word64 -> Integer
into = Word64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral :: Word.Word64 -> Integer
            schema :: (Maybe Identifier, Schema)
schema =
                Schema -> (Maybe Identifier, Schema)
Schema.unidentified
                    (Schema -> (Maybe Identifier, Schema))
-> (Object Value -> Schema)
-> Object Value
-> (Maybe Identifier, Schema)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Schema
Schema.fromValue
                    (Value -> Schema)
-> (Object Value -> Value) -> Object Value -> Schema
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object Value -> Value
Value.Object
                    (Object Value -> (Maybe Identifier, Schema))
-> Object Value -> (Maybe Identifier, Schema)
forall a b. (a -> b) -> a -> b
$ [Member Value] -> Object Value
forall value. [Member value] -> Object value
Object.fromList
                          [ (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"type"
                              , 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) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"integer"
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"minimum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word64
forall a. Bounded a => a
minBound :: Word.Word64)
                              )
                          , (Name, Value) -> Member Value
forall value. (Name, value) -> Member value
Member.fromTuple
                              ( String -> Name
Name.fromString (String -> Name) -> (Text -> String) -> Text -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
String.fromText (Text -> Name) -> Text -> Name
forall a b. (a -> b) -> a -> b
$ String -> Text
Text.pack
                                  String
"maximum"
                              , Number -> Value
Value.Number
                              (Number -> Value) -> (Integer -> Number) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Decimal -> Number
Number.fromDecimal
                              (Decimal -> Number) -> (Integer -> Decimal) -> Integer -> Number
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Decimal
Decimal.fromInteger
                              (Integer -> Value) -> Integer -> Value
forall a b. (a -> b) -> a -> b
$ Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word64
forall a. Bounded a => a
maxBound :: Word.Word64)
                              )
                          ]
        in Value Word64 -> Value Word64
forall a. Typeable a => Value a -> Value a
Codec.identified (Value Word64 -> Value Word64) -> Value Word64 -> Value Word64
forall a b. (a -> b) -> a -> b
$ (Integer -> Maybe Word64)
-> (Word64 -> Maybe Integer) -> Value Integer -> Value Word64
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 Word64
from
            (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer)
-> (Word64 -> Integer) -> Word64 -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Integer
into)
            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 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 Schema.Schema where
    codec :: Value Schema
codec = 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)
-> (Schema -> Value) -> Value Value -> Value Schema
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 Value -> Schema
Schema.fromValue Schema -> Value
Schema.toValue Value Value
forall a. HasCodec a => Value a
codec

basicCodec
    :: forall a
     . Typeable.Typeable a
    => Schema.Schema
    -> (a -> Value.Value)
    -> (Value.Value -> Maybe a)
    -> Codec.Value a
basicCodec :: Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec 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
        (TypeRep -> String
forall a. Show a => a -> String
show (TypeRep -> String) -> TypeRep -> String
forall a b. (a -> b) -> a -> b
$ Proxy a -> TypeRep
forall k (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> TypeRep
Typeable.typeRep (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