Schemas.Internal

Documentation

data TypedSchemaFlex from a where

TypedSchemaFlex enc dec is a schema for encoding to enc and decoding to dec. Usually we want enc and dec to be the same type but this flexibility comes in handy for composition.

• introduction forms: record, enum, schema
• operations: encodeTo, decodeFrom, extractSchema
• composition: dimap, union, stringMap, liftPrism

Constructors

TEnum :: NonEmpty (Text, a) -> (from -> Text) -> TypedSchemaFlex from a

TArray :: TypedSchema b -> (Vector b -> a) -> (from -> Vector b) -> TypedSchemaFlex from a

TMap :: TypedSchema b -> (HashMap Text b -> a) -> (from -> HashMap Text b) -> TypedSchemaFlex from a

TAllOf :: NonEmpty (TypedSchemaFlex from a) -> TypedSchemaFlex from a

Encoding and decoding support all alternatives

TOneOf :: NonEmpty (TypedSchemaFlex from a) -> TypedSchemaFlex from a

Decoding from all alternatives, but encoding only to one

TEmpty :: a -> TypedSchemaFlex from a

TPrim :: Text -> (Value -> Result a) -> (from -> Value) -> TypedSchemaFlex from a

TTry :: Text -> TypedSchemaFlex a b -> (a' -> Maybe a) -> TypedSchemaFlex a' b

RecordSchema :: RecordFields from a -> TypedSchemaFlex from a

Instances

Profunctor TypedSchemaFlex

Defined in Schemas.Internal

Methods

dimap :: (a -> b) -> (c -> d) -> TypedSchemaFlex b c -> TypedSchemaFlex a d

lmap :: (a -> b) -> TypedSchemaFlex b c -> TypedSchemaFlex a c

rmap :: (b -> c) -> TypedSchemaFlex a b -> TypedSchemaFlex a c

(#.) :: Coercible c b => q b c -> TypedSchemaFlex a b -> TypedSchemaFlex a c

(.#) :: Coercible b a => TypedSchemaFlex b c -> q a b -> TypedSchemaFlex a c

Functor (TypedSchemaFlex from)

Defined in Schemas.Internal

Methods

fmap :: (a -> b) -> TypedSchemaFlex from a -> TypedSchemaFlex from b

(<$) :: a -> TypedSchemaFlex from b -> TypedSchemaFlex from a

Semigroup (TypedSchemaFlex f a)

Defined in Schemas.Internal

Methods

(<>) :: TypedSchemaFlex f a -> TypedSchemaFlex f a -> TypedSchemaFlex f a

sconcat :: NonEmpty (TypedSchemaFlex f a) -> TypedSchemaFlex f a

stimes :: Integral b => b -> TypedSchemaFlex f a -> TypedSchemaFlex f a

Monoid a => Monoid (TypedSchemaFlex f a)

Defined in Schemas.Internal

Methods

mempty :: TypedSchemaFlex f a

mappend :: TypedSchemaFlex f a -> TypedSchemaFlex f a -> TypedSchemaFlex f a

mconcat :: [TypedSchemaFlex f a] -> TypedSchemaFlex f a

enum :: Eq a => (a -> Text) -> NonEmpty a -> TypedSchema a

enum values mapping construct a schema for a non empty set of values with a Text mapping

stringMap :: TypedSchema a -> TypedSchema (HashMap Text a)

stringMap sc is the schema for a stringmap where the values have schema sc

list :: IsList l => TypedSchema (Item l) -> TypedSchema l

list sc is the schema for a list of values with schema sc

vector :: TypedSchema a -> TypedSchema (Vector a)

vector sc is the schema for a vector of values with schema sc

viaJSON :: (FromJSON a, ToJSON a) => Text -> TypedSchema a

viaJson label constructs a schema reusing existing aeson instances. The resulting schema is opaque and cannot be subtyped and/or versioned, so this constructor should be used sparingly. The label is used to describe the extracted Schema.

viaIso :: Iso' a b -> TypedSchema a -> TypedSchema b

Apply an isomorphism to a schema

string :: TypedSchema String

The schema of String values

readShow :: (Read a, Show a) => TypedSchema a

A schema for types that can be parsed and pretty-printed. The resulting schema is opaque and cannot be subtyped/versioned, so this constructor is best used for primitive value

allOf :: NonEmpty (TypedSchemaFlex from a) -> TypedSchemaFlex from a

oneOf :: NonEmpty (TypedSchemaFlex from a) -> TypedSchemaFlex from a

The schema of undiscriminated unions. Prefer using union where possible

type TypedSchema a = TypedSchemaFlex a a

data RecordField from a where

Constructors

RequiredAp

Fields

• :: { fieldName :: Text

  Name of the field

•    , fieldTypedSchema :: TypedSchemaFlex from a
•    } -> RecordField from a

OptionalAp

Fields

• :: { fieldName :: Text

  Name of the field

•    , fieldTypedSchema :: TypedSchemaFlex from a
•    , fieldDefValue :: a
•    } -> RecordField from a

Instances

Profunctor RecordField

Defined in Schemas.Internal

Methods

dimap :: (a -> b) -> (c -> d) -> RecordField b c -> RecordField a d

lmap :: (a -> b) -> RecordField b c -> RecordField a c

rmap :: (b -> c) -> RecordField a b -> RecordField a c

(#.) :: Coercible c b => q b c -> RecordField a b -> RecordField a c

(.#) :: Coercible b a => RecordField b c -> q a b -> RecordField a c

fieldNameL :: Lens' (RecordField from a) Text

Lens for the fieldName attribute

newtype RecordFields from a

An Alternative profunctor for defining record schemas with versioning

 schemaPerson = Person
            <$> (field "name" name <|> field "full name" name)
            <*> (field "age" age <|> pure -1)

Constructors

RecordFields

Fields

• getRecordFields :: Alt (RecordField from) a

Instances

Profunctor RecordFields

Defined in Schemas.Internal

Methods

dimap :: (a -> b) -> (c -> d) -> RecordFields b c -> RecordFields a d

lmap :: (a -> b) -> RecordFields b c -> RecordFields a c

rmap :: (b -> c) -> RecordFields a b -> RecordFields a c

(#.) :: Coercible c b => q b c -> RecordFields a b -> RecordFields a c

(.#) :: Coercible b a => RecordFields b c -> q a b -> RecordFields a c

Functor (RecordFields from)

Defined in Schemas.Internal

Methods

fmap :: (a -> b) -> RecordFields from a -> RecordFields from b

(<$) :: a -> RecordFields from b -> RecordFields from a

Applicative (RecordFields from)

Defined in Schemas.Internal

Methods

pure :: a -> RecordFields from a

(<*>) :: RecordFields from (a -> b) -> RecordFields from a -> RecordFields from b

liftA2 :: (a -> b -> c) -> RecordFields from a -> RecordFields from b -> RecordFields from c

(*>) :: RecordFields from a -> RecordFields from b -> RecordFields from b

(<*) :: RecordFields from a -> RecordFields from b -> RecordFields from a

Alternative (RecordFields from)

Defined in Schemas.Internal

Methods

empty :: RecordFields from a

(<|>) :: RecordFields from a -> RecordFields from a -> RecordFields from a

some :: RecordFields from a -> RecordFields from [a]

many :: RecordFields from a -> RecordFields from [a]

Semigroup (RecordFields from a)

Defined in Schemas.Internal

Methods

(<>) :: RecordFields from a -> RecordFields from a -> RecordFields from a

sconcat :: NonEmpty (RecordFields from a) -> RecordFields from a

stimes :: Integral b => b -> RecordFields from a -> RecordFields from a

Monoid (RecordFields from a)

Defined in Schemas.Internal

Methods

mempty :: RecordFields from a

mappend :: RecordFields from a -> RecordFields from a -> RecordFields from a

mconcat :: [RecordFields from a] -> RecordFields from a

overFieldNames :: (Text -> Text) -> RecordFields from a -> RecordFields from a

Map a function over all the field names

record :: RecordFields from a -> TypedSchemaFlex from a

Wrap an applicative record schema

fieldWith :: TypedSchema a -> Text -> (from -> a) -> RecordFields from a

fieldWith sc n get introduces a field

fieldWith' :: TypedSchemaFlex from a -> Text -> RecordFields from a

Generalised version of fieldWith

liftPrism :: Text -> Prism s t a b -> TypedSchemaFlex a b -> TypedSchemaFlex s t

Project a schema through a Prism. Returns a partial schema. When encoding/decoding a value that doesn't fit the prism, an optional field will be omitted, and a required field will cause this alternative to be aborted.

liftJust :: TypedSchemaFlex a b -> TypedSchemaFlex (Maybe a) (Maybe b)

liftJust = liftPrism _Just

liftRight :: TypedSchemaFlex a b -> TypedSchemaFlex (Either c a) (Either c b)

liftRight = liftPrism _Right

optFieldWith :: forall a from. TypedSchemaFlex from (Maybe a) -> Text -> RecordFields from (Maybe a)

A generalized version of optField. Does not handle infinite/circular data.

optFieldGeneral :: forall a from. TypedSchemaFlex from a -> Text -> a -> RecordFields from a

The most general introduction form for optional fields

optFieldEitherWith :: TypedSchemaFlex from (Either e a) -> Text -> e -> RecordFields from (Either e a)

A generalized version of optFieldEither. Does not handle infinite/circular data

extractFields :: RecordFields from a -> NonDet [(Text, Field)]

Extract all the field groups (from alternatives) in the record

newtype NonDet a

Constructors

NonDet

Fields

• nonDet :: [a]

Instances

Monad NonDet

Defined in Schemas.Internal

Methods

(>>=) :: NonDet a -> (a -> NonDet b) -> NonDet b

(>>) :: NonDet a -> NonDet b -> NonDet b

return :: a -> NonDet a

fail :: String -> NonDet a

Functor NonDet

Defined in Schemas.Internal

Methods

fmap :: (a -> b) -> NonDet a -> NonDet b

(<$) :: a -> NonDet b -> NonDet a

Applicative NonDet

Defined in Schemas.Internal

Methods

pure :: a -> NonDet a

(<*>) :: NonDet (a -> b) -> NonDet a -> NonDet b

liftA2 :: (a -> b -> c) -> NonDet a -> NonDet b -> NonDet c

(*>) :: NonDet a -> NonDet b -> NonDet b

(<*) :: NonDet a -> NonDet b -> NonDet a

Foldable NonDet

Defined in Schemas.Internal

Methods

fold :: Monoid m => NonDet m -> m

foldMap :: Monoid m => (a -> m) -> NonDet a -> m

foldr :: (a -> b -> b) -> b -> NonDet a -> b

foldr' :: (a -> b -> b) -> b -> NonDet a -> b

foldl :: (b -> a -> b) -> b -> NonDet a -> b

foldl' :: (b -> a -> b) -> b -> NonDet a -> b

foldr1 :: (a -> a -> a) -> NonDet a -> a

foldl1 :: (a -> a -> a) -> NonDet a -> a

toList :: NonDet a -> [a]

null :: NonDet a -> Bool

length :: NonDet a -> Int

elem :: Eq a => a -> NonDet a -> Bool

maximum :: Ord a => NonDet a -> a

minimum :: Ord a => NonDet a -> a

sum :: Num a => NonDet a -> a

product :: Num a => NonDet a -> a

Traversable NonDet

Defined in Schemas.Internal

Methods

traverse :: Applicative f => (a -> f b) -> NonDet a -> f (NonDet b)

sequenceA :: Applicative f => NonDet (f a) -> f (NonDet a)

mapM :: Monad m => (a -> m b) -> NonDet a -> m (NonDet b)

sequence :: Monad m => NonDet (m a) -> m (NonDet a)

Alternative NonDet

Defined in Schemas.Internal

Methods

empty :: NonDet a

(<|>) :: NonDet a -> NonDet a -> NonDet a

some :: NonDet a -> NonDet [a]

many :: NonDet a -> NonDet [a]

extractFieldsHelper :: (forall a. RecordField from a -> b) -> RecordFields from a -> NonDet [b]

union :: NonEmpty (Text, TypedSchema a) -> TypedSchema a

The schema of discriminated unions

  import Schemas
  import "generic-lens" Data.Generics.Labels ()
  import GHC.Generics

  data Education = Degree Text | PhD Text | NoEducation

  schemaEducation = union'
    [ alt "NoEducation" #_NoEducation
    , alt "Degree"      #_Degree
    , alt "PhD"         #_PhD
    ]
  

Given a non empty set of tagged partial schemas, constructs the schema that applies them in order and selects the first successful match.

data UnionTag from where

Existential wrapper for convenient definition of discriminated unions

Constructors

UnionTag :: Text -> Prism' from b -> TypedSchema b -> UnionTag from

altWith :: TypedSchema a -> Text -> Prism' from a -> UnionTag from

altWith name prism schema introduces a discriminated union alternative

union' :: NonEmpty (UnionTag from) -> TypedSchema from

Given a non empty set of constructors, construct the schema that selects the first matching constructor

extractSchema :: TypedSchemaFlex from a -> Schema

Extract an untyped schema that can be serialized

extractValidators :: TypedSchemaFlex from a -> Validators

Returns all the primitive validators embedded in this typed schema

encodeWith :: TypedSchemaFlex from a -> from -> Value

Given a value and its typed schema, produce a JSON record using the RecordFields

encodeToWith :: TypedSchema a -> Schema -> Maybe (a -> Value)

data DecodeError

Constructors

VE Mismatch

TriedAndFailed

Instances

Eq DecodeError

Defined in Schemas.Internal

Methods

(==) :: DecodeError -> DecodeError -> Bool

(/=) :: DecodeError -> DecodeError -> Bool

Show DecodeError

Defined in Schemas.Internal

Methods

showsPrec :: Int -> DecodeError -> ShowS

show :: DecodeError -> String

showList :: [DecodeError] -> ShowS

runSchema :: TypedSchemaFlex enc dec -> enc -> Either [DecodeError] dec

Runs a schema as a function enc -> dec. Loops for infinite/circular data

decodeWith :: TypedSchemaFlex from a -> Value -> Either [(Trace, DecodeError)] a

Given a JSON Value and a typed schema, extract a Haskell value

decodeFromWith :: TypedSchema a -> Schema -> Maybe (Value -> Either [(Trace, DecodeError)] a)

runAlt_ :: (Alternative g, Monoid m) => (forall a. f a -> g m) -> Alt f b -> g m

(<.>) :: Functor f => (b -> c) -> (a -> f b) -> a -> f c infixr 9