{-# 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.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 = 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) Value
Codec.decode = ReaderT Value (ExceptT String Identity) Value
forall (m :: * -> *) r. Monad m => ReaderT r m r
Trans.ask
        , encode :: Value -> MaybeT (StateT Value Identity) Value
Codec.encode = (Value -> MaybeT (StateT Value Identity) ())
-> Value -> MaybeT (StateT Value Identity) Value
forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap ((Value -> MaybeT (StateT Value Identity) ())
 -> Value -> MaybeT (StateT Value Identity) Value)
-> (Value -> MaybeT (StateT Value Identity) ())
-> Value
-> MaybeT (StateT Value Identity) Value
forall a b. (a -> b) -> a -> b
$ StateT Value Identity () -> MaybeT (StateT Value Identity) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (StateT Value Identity () -> MaybeT (StateT Value Identity) ())
-> (Value -> StateT Value Identity ())
-> Value
-> MaybeT (StateT Value Identity) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> StateT Value Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put
        , schema :: Schema
Codec.schema = Schema
Schema.true
        }

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
            String
-> Schema -> (Null -> Value) -> (Value -> Maybe Null) -> Value Null
forall a.
String -> Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec String
"Null" 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
            String
-> Schema
-> (Boolean -> Value)
-> (Value -> Maybe Boolean)
-> Value Boolean
forall a.
String -> Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec String
"Boolean" 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
            String
-> Schema
-> (Number -> Value)
-> (Value -> Maybe Number)
-> Value Number
forall a.
String -> Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec String
"Number" 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
            String
-> Schema
-> (String -> Value)
-> (Value -> Maybe String)
-> Value String
forall a.
String -> Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec String
"String" Schema
schema String -> Value
Value.String ((Value -> Maybe String) -> Value String)
-> (Value -> Maybe String) -> Value String
forall a b. (a -> b) -> a -> b
$ \Value
value -> case Value
value of
                Value.String String
string -> String -> Maybe String
forall a. a -> Maybe a
Just String
string
                Value
_ -> Maybe String
forall a. Maybe a
Nothing

instance HasCodec a => HasCodec (Array.Array a) where
    codec :: Value (Array a)
codec = 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 :: Schema
Codec.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
"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 -> Value) -> Schema -> Value
forall a b. (a -> b) -> a -> b
$ Value a -> Schema
forall (r :: * -> *) (w :: * -> *) s i o. Codec r w s i o -> s
Codec.schema (Value a
forall a. HasCodec a => Value a
codec :: Codec.Value a)
                )
            ]
        }

instance HasCodec a => HasCodec (Object.Object a) where
    codec :: Value (Object a)
codec = 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 :: Schema
Codec.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
"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"
                , Schema -> Value
Schema.toValue (Schema -> Value) -> Schema -> Value
forall a b. (a -> b) -> a -> b
$ Value a -> Schema
forall (r :: * -> *) (w :: * -> *) s i o. Codec r w s i o -> s
Codec.schema (Value a
forall a. HasCodec a => Value a
codec :: Codec.Value a)
                )
            ]
        }

instance HasCodec a => HasCodec (Maybe a) where
    codec :: Value (Maybe a)
codec =
        (a -> Maybe (Maybe a))
-> (Maybe a -> Maybe a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     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))
  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) => HasCodec (Either a b) where
    codec :: Value (Either a b)
codec =
        (a -> Maybe (Either a b))
-> (Either a b -> Maybe a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     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))
     Schema
     a
     a
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     Schema
     a
     a
forall a. String -> Value a -> Value a
Codec.tagged String
"Left" Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  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))
     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))
     Schema
     b
     b
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     Schema
     b
     b
forall a. String -> Value a -> Value a
Codec.tagged String
"Right" Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  Schema
  b
  b
forall a. HasCodec a => Value a
codec)

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

instance (HasCodec a, HasCodec b) => HasCodec (a, b) where
    codec :: Value (a, b)
codec =
        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)
     [Schema]
     (a, b)
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     [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)
     [Schema]
     a
     a
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     [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)
     [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)
  [Schema]
  (a, b)
  (b -> (a, b))
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     [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)
     [Schema]
     b
     b
-> Codec
     (StateT [Value] (ExceptT String Identity))
     (WriterT [Value] Identity)
     [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)
     [Schema]
     b
     b
forall a. Value a -> Array a
Codec.element Value b
forall a. HasCodec a => Value a
codec)

instance HasCodec Bool where
    codec :: Value Bool
codec = (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 = (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 = (String -> Text) -> (Text -> String) -> Value String -> Value Text
forall (r :: * -> *) (w :: * -> *) a b s.
(Functor r, Functor w) =>
(a -> b) -> (b -> a) -> Codec r w s a a -> Codec r w s b b
Codec.map String -> Text
String.toText Text -> String
String.fromText Value String
forall a. HasCodec a => Value a
codec

instance {-# OVERLAPPABLE #-} HasCodec a => HasCodec [a] where
    codec :: Value [a]
codec = (Array a -> [a])
-> ([a] -> Array a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     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))
  Schema
  (Array a)
  (Array a)
forall a. HasCodec a => Value a
codec

instance HasCodec a => HasCodec (Map.Map Name.Name a) where
    codec :: Value (Map Name a)
codec = (Object a -> Map Name a)
-> (Map Name a -> Object a)
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     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))
  Schema
  (Object a)
  (Object a)
forall a. HasCodec a => Value a
codec

instance HasCodec String where
    codec :: Value String
codec = (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 :: 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"
                    )
                , (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
            (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 :: Schema
Codec.schema = Schema
schema }

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

instance HasCodec a => HasCodec (NonEmpty.NonEmpty a) where
    codec :: Value (NonEmpty a)
codec =
        let
            schema :: 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
"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 -> Value) -> Schema -> Value
forall a b. (a -> b) -> a -> b
$ Codec
  (ReaderT Value (ExceptT String Identity))
  (MaybeT (StateT Value Identity))
  Schema
  a
  a
-> 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))
  Schema
  a
  a
forall a. HasCodec a => Value a
codec :: Codec.Value a)
                    )
                , (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
            ([a] -> Maybe (NonEmpty a))
-> (NonEmpty a -> Maybe [a])
-> Codec
     (ReaderT Value (ExceptT String Identity))
     (MaybeT (StateT Value Identity))
     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))
  Schema
  [a]
  [a]
forall a. HasCodec a => Value a
codec { schema :: Schema
Codec.schema = Schema
schema }

instance HasCodec Integer where
    codec :: Value Integer
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
"integer"
                      )
                ]
        in
            (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = 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 :: 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
"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 (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 :: Schema
Codec.schema = Schema
schema }

instance HasCodec Float where
    codec :: Value Float
codec =
        (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 =
        (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 = (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)
-> (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
    :: String
    -> Schema.Schema
    -> (a -> Value.Value)
    -> (Value.Value -> Maybe a)
    -> Codec.Value a
basicCodec :: String -> Schema -> (a -> Value) -> (Value -> Maybe a) -> Value a
basicCodec String
expected Schema
schema a -> Value
toValue Value -> Maybe a
fromValue = 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 String
expected Value -> Maybe a
fromValue
    , encode :: a -> MaybeT (StateT Value Identity) a
Codec.encode = (a -> MaybeT (StateT Value Identity) ())
-> a -> MaybeT (StateT Value Identity) a
forall (f :: * -> *) a b. Functor f => (a -> f b) -> a -> f a
Codec.tap ((a -> MaybeT (StateT Value Identity) ())
 -> a -> MaybeT (StateT Value Identity) a)
-> (a -> MaybeT (StateT Value Identity) ())
-> a
-> MaybeT (StateT Value Identity) a
forall a b. (a -> b) -> a -> b
$ StateT Value Identity () -> MaybeT (StateT Value Identity) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift (StateT Value Identity () -> MaybeT (StateT Value Identity) ())
-> (a -> StateT Value Identity ())
-> a
-> MaybeT (StateT Value Identity) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> StateT Value Identity ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Trans.put (Value -> StateT Value Identity ())
-> (a -> Value) -> a -> StateT Value Identity ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value
toValue
    , schema :: Schema
Codec.schema = 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