{-# LANGUAGE BlockArguments     #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE LambdaCase         #-}
{-# LANGUAGE NoStrict           #-}

module PlutusTx.Blueprint.Schema.Annotation (
  SchemaInfo (..),
  emptySchemaInfo,
  annotationsToSchemaInfo,
  SchemaAnn (..),
  SchemaTitle (..),
  SchemaDescription (..),
  SchemaComment (..),
) where

import Control.Monad.State (execStateT, get, lift, put)
import Data.Aeson (ToJSON (..))
import Data.Data (Data, Typeable)
import GHC.Generics (Generic)
import Language.Haskell.TH.Syntax (Lift)
import Prelude hiding (max, maximum, min, minimum)

-- | Additional information optionally attached to any datatype schema definition.
data SchemaInfo = MkSchemaInfo
  { SchemaInfo -> Maybe SchemaInfoError
title       :: Maybe String
  , SchemaInfo -> Maybe SchemaInfoError
description :: Maybe String
  , SchemaInfo -> Maybe SchemaInfoError
comment     :: Maybe String
  }
  deriving stock (SchemaInfo -> SchemaInfo -> Bool
(SchemaInfo -> SchemaInfo -> Bool)
-> (SchemaInfo -> SchemaInfo -> Bool) -> Eq SchemaInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaInfo -> SchemaInfo -> Bool
== :: SchemaInfo -> SchemaInfo -> Bool
$c/= :: SchemaInfo -> SchemaInfo -> Bool
/= :: SchemaInfo -> SchemaInfo -> Bool
Eq, Eq SchemaInfo
Eq SchemaInfo =>
(SchemaInfo -> SchemaInfo -> Ordering)
-> (SchemaInfo -> SchemaInfo -> Bool)
-> (SchemaInfo -> SchemaInfo -> Bool)
-> (SchemaInfo -> SchemaInfo -> Bool)
-> (SchemaInfo -> SchemaInfo -> Bool)
-> (SchemaInfo -> SchemaInfo -> SchemaInfo)
-> (SchemaInfo -> SchemaInfo -> SchemaInfo)
-> Ord SchemaInfo
SchemaInfo -> SchemaInfo -> Bool
SchemaInfo -> SchemaInfo -> Ordering
SchemaInfo -> SchemaInfo -> SchemaInfo
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SchemaInfo -> SchemaInfo -> Ordering
compare :: SchemaInfo -> SchemaInfo -> Ordering
$c< :: SchemaInfo -> SchemaInfo -> Bool
< :: SchemaInfo -> SchemaInfo -> Bool
$c<= :: SchemaInfo -> SchemaInfo -> Bool
<= :: SchemaInfo -> SchemaInfo -> Bool
$c> :: SchemaInfo -> SchemaInfo -> Bool
> :: SchemaInfo -> SchemaInfo -> Bool
$c>= :: SchemaInfo -> SchemaInfo -> Bool
>= :: SchemaInfo -> SchemaInfo -> Bool
$cmax :: SchemaInfo -> SchemaInfo -> SchemaInfo
max :: SchemaInfo -> SchemaInfo -> SchemaInfo
$cmin :: SchemaInfo -> SchemaInfo -> SchemaInfo
min :: SchemaInfo -> SchemaInfo -> SchemaInfo
Ord, Int -> SchemaInfo -> ShowS
[SchemaInfo] -> ShowS
SchemaInfo -> SchemaInfoError
(Int -> SchemaInfo -> ShowS)
-> (SchemaInfo -> SchemaInfoError)
-> ([SchemaInfo] -> ShowS)
-> Show SchemaInfo
forall a.
(Int -> a -> ShowS)
-> (a -> SchemaInfoError) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaInfo -> ShowS
showsPrec :: Int -> SchemaInfo -> ShowS
$cshow :: SchemaInfo -> SchemaInfoError
show :: SchemaInfo -> SchemaInfoError
$cshowList :: [SchemaInfo] -> ShowS
showList :: [SchemaInfo] -> ShowS
Show, (forall x. SchemaInfo -> Rep SchemaInfo x)
-> (forall x. Rep SchemaInfo x -> SchemaInfo) -> Generic SchemaInfo
forall x. Rep SchemaInfo x -> SchemaInfo
forall x. SchemaInfo -> Rep SchemaInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SchemaInfo -> Rep SchemaInfo x
from :: forall x. SchemaInfo -> Rep SchemaInfo x
$cto :: forall x. Rep SchemaInfo x -> SchemaInfo
to :: forall x. Rep SchemaInfo x -> SchemaInfo
Generic, Typeable SchemaInfo
Typeable SchemaInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SchemaInfo -> c SchemaInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SchemaInfo)
-> (SchemaInfo -> Constr)
-> (SchemaInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SchemaInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SchemaInfo))
-> ((forall b. Data b => b -> b) -> SchemaInfo -> SchemaInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> SchemaInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SchemaInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo)
-> Data SchemaInfo
SchemaInfo -> Constr
SchemaInfo -> DataType
(forall b. Data b => b -> b) -> SchemaInfo -> SchemaInfo
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SchemaInfo -> u
forall u. (forall d. Data d => d -> u) -> SchemaInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaInfo -> c SchemaInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaInfo -> c SchemaInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaInfo -> c SchemaInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaInfo
$ctoConstr :: SchemaInfo -> Constr
toConstr :: SchemaInfo -> Constr
$cdataTypeOf :: SchemaInfo -> DataType
dataTypeOf :: SchemaInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaInfo)
$cgmapT :: (forall b. Data b => b -> b) -> SchemaInfo -> SchemaInfo
gmapT :: (forall b. Data b => b -> b) -> SchemaInfo -> SchemaInfo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaInfo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaInfo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaInfo -> m SchemaInfo
Data, (forall (m :: * -> *). Quote m => SchemaInfo -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    SchemaInfo -> Code m SchemaInfo)
-> Lift SchemaInfo
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SchemaInfo -> m Exp
forall (m :: * -> *). Quote m => SchemaInfo -> Code m SchemaInfo
$clift :: forall (m :: * -> *). Quote m => SchemaInfo -> m Exp
lift :: forall (m :: * -> *). Quote m => SchemaInfo -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => SchemaInfo -> Code m SchemaInfo
liftTyped :: forall (m :: * -> *). Quote m => SchemaInfo -> Code m SchemaInfo
Lift)

emptySchemaInfo :: SchemaInfo
emptySchemaInfo :: SchemaInfo
emptySchemaInfo = Maybe SchemaInfoError
-> Maybe SchemaInfoError -> Maybe SchemaInfoError -> SchemaInfo
MkSchemaInfo Maybe SchemaInfoError
forall a. Maybe a
Nothing Maybe SchemaInfoError
forall a. Maybe a
Nothing Maybe SchemaInfoError
forall a. Maybe a
Nothing

type SchemaInfoError = String

annotationsToSchemaInfo :: [SchemaAnn] -> Either SchemaInfoError SchemaInfo
annotationsToSchemaInfo :: [SchemaAnn] -> Either SchemaInfoError SchemaInfo
annotationsToSchemaInfo =
  (StateT SchemaInfo (Either SchemaInfoError) [()]
-> SchemaInfo -> Either SchemaInfoError SchemaInfo
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
`execStateT` SchemaInfo
emptySchemaInfo) (StateT SchemaInfo (Either SchemaInfoError) [()]
 -> Either SchemaInfoError SchemaInfo)
-> ([SchemaAnn] -> StateT SchemaInfo (Either SchemaInfoError) [()])
-> [SchemaAnn]
-> Either SchemaInfoError SchemaInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SchemaAnn -> StateT SchemaInfo (Either SchemaInfoError) ())
-> [SchemaAnn] -> StateT SchemaInfo (Either SchemaInfoError) [()]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse \case
    MkSchemaAnnTitle (SchemaTitle SchemaInfoError
t) ->
      StateT SchemaInfo (Either SchemaInfoError) SchemaInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT SchemaInfo (Either SchemaInfoError) SchemaInfo
-> (SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ())
-> StateT SchemaInfo (Either SchemaInfoError) ()
forall a b.
StateT SchemaInfo (Either SchemaInfoError) a
-> (a -> StateT SchemaInfo (Either SchemaInfoError) b)
-> StateT SchemaInfo (Either SchemaInfoError) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SchemaInfo
info -> case SchemaInfo -> Maybe SchemaInfoError
title SchemaInfo
info of
        Maybe SchemaInfoError
Nothing -> SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ())
-> SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ()
forall a b. (a -> b) -> a -> b
$ SchemaInfo
info{title = Just t}
        Just SchemaInfoError
t' -> SchemaInfoError
-> SchemaInfoError
-> SchemaInfoError
-> StateT SchemaInfo (Either SchemaInfoError) ()
forall {t :: (* -> *) -> * -> *} {a} {a} {a}.
(MonadTrans t, Show a, Show a) =>
SchemaInfoError -> a -> a -> t (Either SchemaInfoError) a
failOverride SchemaInfoError
"SchemaTitle" SchemaInfoError
t' SchemaInfoError
t
    MkSchemaAnnDescription (SchemaDescription SchemaInfoError
d) ->
      StateT SchemaInfo (Either SchemaInfoError) SchemaInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT SchemaInfo (Either SchemaInfoError) SchemaInfo
-> (SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ())
-> StateT SchemaInfo (Either SchemaInfoError) ()
forall a b.
StateT SchemaInfo (Either SchemaInfoError) a
-> (a -> StateT SchemaInfo (Either SchemaInfoError) b)
-> StateT SchemaInfo (Either SchemaInfoError) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SchemaInfo
info -> case SchemaInfo -> Maybe SchemaInfoError
description SchemaInfo
info of
        Maybe SchemaInfoError
Nothing -> SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ())
-> SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ()
forall a b. (a -> b) -> a -> b
$ SchemaInfo
info{description = Just d}
        Just SchemaInfoError
d' -> SchemaInfoError
-> SchemaInfoError
-> SchemaInfoError
-> StateT SchemaInfo (Either SchemaInfoError) ()
forall {t :: (* -> *) -> * -> *} {a} {a} {a}.
(MonadTrans t, Show a, Show a) =>
SchemaInfoError -> a -> a -> t (Either SchemaInfoError) a
failOverride SchemaInfoError
"SchemaDescription" SchemaInfoError
d' SchemaInfoError
d
    MkSchemaAnnComment (SchemaComment SchemaInfoError
c) ->
      StateT SchemaInfo (Either SchemaInfoError) SchemaInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT SchemaInfo (Either SchemaInfoError) SchemaInfo
-> (SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ())
-> StateT SchemaInfo (Either SchemaInfoError) ()
forall a b.
StateT SchemaInfo (Either SchemaInfoError) a
-> (a -> StateT SchemaInfo (Either SchemaInfoError) b)
-> StateT SchemaInfo (Either SchemaInfoError) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SchemaInfo
info -> case SchemaInfo -> Maybe SchemaInfoError
comment SchemaInfo
info of
        Maybe SchemaInfoError
Nothing -> SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ())
-> SchemaInfo -> StateT SchemaInfo (Either SchemaInfoError) ()
forall a b. (a -> b) -> a -> b
$ SchemaInfo
info{comment = Just c}
        Just SchemaInfoError
c' -> SchemaInfoError
-> SchemaInfoError
-> SchemaInfoError
-> StateT SchemaInfo (Either SchemaInfoError) ()
forall {t :: (* -> *) -> * -> *} {a} {a} {a}.
(MonadTrans t, Show a, Show a) =>
SchemaInfoError -> a -> a -> t (Either SchemaInfoError) a
failOverride SchemaInfoError
"SchemaComment" SchemaInfoError
c' SchemaInfoError
c
 where
  failOverride :: SchemaInfoError -> a -> a -> t (Either SchemaInfoError) a
failOverride SchemaInfoError
label a
old a
new =
    Either SchemaInfoError a -> t (Either SchemaInfoError) a
forall (m :: * -> *) a. Monad m => m a -> t m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Either SchemaInfoError a -> t (Either SchemaInfoError) a)
-> (SchemaInfoError -> Either SchemaInfoError a)
-> SchemaInfoError
-> t (Either SchemaInfoError) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SchemaInfoError -> Either SchemaInfoError a
forall a b. a -> Either a b
Left (SchemaInfoError -> t (Either SchemaInfoError) a)
-> SchemaInfoError -> t (Either SchemaInfoError) a
forall a b. (a -> b) -> a -> b
$ [SchemaInfoError] -> SchemaInfoError
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [SchemaInfoError
label, SchemaInfoError
" annotation error: ", a -> SchemaInfoError
forall a. Show a => a -> SchemaInfoError
show a
old, SchemaInfoError
" is overridden with ", a -> SchemaInfoError
forall a. Show a => a -> SchemaInfoError
show a
new]

-- | Annotation that can be attached to a schema definition.
data SchemaAnn
  = MkSchemaAnnTitle SchemaTitle
  | MkSchemaAnnDescription SchemaDescription
  | MkSchemaAnnComment SchemaComment
  deriving stock (SchemaAnn -> SchemaAnn -> Bool
(SchemaAnn -> SchemaAnn -> Bool)
-> (SchemaAnn -> SchemaAnn -> Bool) -> Eq SchemaAnn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaAnn -> SchemaAnn -> Bool
== :: SchemaAnn -> SchemaAnn -> Bool
$c/= :: SchemaAnn -> SchemaAnn -> Bool
/= :: SchemaAnn -> SchemaAnn -> Bool
Eq, Eq SchemaAnn
Eq SchemaAnn =>
(SchemaAnn -> SchemaAnn -> Ordering)
-> (SchemaAnn -> SchemaAnn -> Bool)
-> (SchemaAnn -> SchemaAnn -> Bool)
-> (SchemaAnn -> SchemaAnn -> Bool)
-> (SchemaAnn -> SchemaAnn -> Bool)
-> (SchemaAnn -> SchemaAnn -> SchemaAnn)
-> (SchemaAnn -> SchemaAnn -> SchemaAnn)
-> Ord SchemaAnn
SchemaAnn -> SchemaAnn -> Bool
SchemaAnn -> SchemaAnn -> Ordering
SchemaAnn -> SchemaAnn -> SchemaAnn
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SchemaAnn -> SchemaAnn -> Ordering
compare :: SchemaAnn -> SchemaAnn -> Ordering
$c< :: SchemaAnn -> SchemaAnn -> Bool
< :: SchemaAnn -> SchemaAnn -> Bool
$c<= :: SchemaAnn -> SchemaAnn -> Bool
<= :: SchemaAnn -> SchemaAnn -> Bool
$c> :: SchemaAnn -> SchemaAnn -> Bool
> :: SchemaAnn -> SchemaAnn -> Bool
$c>= :: SchemaAnn -> SchemaAnn -> Bool
>= :: SchemaAnn -> SchemaAnn -> Bool
$cmax :: SchemaAnn -> SchemaAnn -> SchemaAnn
max :: SchemaAnn -> SchemaAnn -> SchemaAnn
$cmin :: SchemaAnn -> SchemaAnn -> SchemaAnn
min :: SchemaAnn -> SchemaAnn -> SchemaAnn
Ord, Int -> SchemaAnn -> ShowS
[SchemaAnn] -> ShowS
SchemaAnn -> SchemaInfoError
(Int -> SchemaAnn -> ShowS)
-> (SchemaAnn -> SchemaInfoError)
-> ([SchemaAnn] -> ShowS)
-> Show SchemaAnn
forall a.
(Int -> a -> ShowS)
-> (a -> SchemaInfoError) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaAnn -> ShowS
showsPrec :: Int -> SchemaAnn -> ShowS
$cshow :: SchemaAnn -> SchemaInfoError
show :: SchemaAnn -> SchemaInfoError
$cshowList :: [SchemaAnn] -> ShowS
showList :: [SchemaAnn] -> ShowS
Show, (forall x. SchemaAnn -> Rep SchemaAnn x)
-> (forall x. Rep SchemaAnn x -> SchemaAnn) -> Generic SchemaAnn
forall x. Rep SchemaAnn x -> SchemaAnn
forall x. SchemaAnn -> Rep SchemaAnn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SchemaAnn -> Rep SchemaAnn x
from :: forall x. SchemaAnn -> Rep SchemaAnn x
$cto :: forall x. Rep SchemaAnn x -> SchemaAnn
to :: forall x. Rep SchemaAnn x -> SchemaAnn
Generic, Typeable, Typeable SchemaAnn
Typeable SchemaAnn =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SchemaAnn -> c SchemaAnn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SchemaAnn)
-> (SchemaAnn -> Constr)
-> (SchemaAnn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SchemaAnn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaAnn))
-> ((forall b. Data b => b -> b) -> SchemaAnn -> SchemaAnn)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r)
-> (forall u. (forall d. Data d => d -> u) -> SchemaAnn -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SchemaAnn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn)
-> Data SchemaAnn
SchemaAnn -> Constr
SchemaAnn -> DataType
(forall b. Data b => b -> b) -> SchemaAnn -> SchemaAnn
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SchemaAnn -> u
forall u. (forall d. Data d => d -> u) -> SchemaAnn -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaAnn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaAnn -> c SchemaAnn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaAnn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaAnn)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaAnn -> c SchemaAnn
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaAnn -> c SchemaAnn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaAnn
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaAnn
$ctoConstr :: SchemaAnn -> Constr
toConstr :: SchemaAnn -> Constr
$cdataTypeOf :: SchemaAnn -> DataType
dataTypeOf :: SchemaAnn -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaAnn)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaAnn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaAnn)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SchemaAnn)
$cgmapT :: (forall b. Data b => b -> b) -> SchemaAnn -> SchemaAnn
gmapT :: (forall b. Data b => b -> b) -> SchemaAnn -> SchemaAnn
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaAnn -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaAnn -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaAnn -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaAnn -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaAnn -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaAnn -> m SchemaAnn
Data, (forall (m :: * -> *). Quote m => SchemaAnn -> m Exp)
-> (forall (m :: * -> *). Quote m => SchemaAnn -> Code m SchemaAnn)
-> Lift SchemaAnn
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SchemaAnn -> m Exp
forall (m :: * -> *). Quote m => SchemaAnn -> Code m SchemaAnn
$clift :: forall (m :: * -> *). Quote m => SchemaAnn -> m Exp
lift :: forall (m :: * -> *). Quote m => SchemaAnn -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => SchemaAnn -> Code m SchemaAnn
liftTyped :: forall (m :: * -> *). Quote m => SchemaAnn -> Code m SchemaAnn
Lift)

{- | An annotation for the "title" schema attribute.

This annotation could be attached to a type or constructor:
@
{\-# ANN type MyFoo (SchemaTitle "My Foo Title") #-\}
{\-# ANN MkMyFoo (SchemaTitle "Title") #-\}
newtype MyFoo = MkMyFoo Int
@
-}
newtype SchemaTitle = SchemaTitle {SchemaTitle -> SchemaInfoError
schemaTitleToString :: String}
  deriving newtype (SchemaTitle -> SchemaTitle -> Bool
(SchemaTitle -> SchemaTitle -> Bool)
-> (SchemaTitle -> SchemaTitle -> Bool) -> Eq SchemaTitle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaTitle -> SchemaTitle -> Bool
== :: SchemaTitle -> SchemaTitle -> Bool
$c/= :: SchemaTitle -> SchemaTitle -> Bool
/= :: SchemaTitle -> SchemaTitle -> Bool
Eq, Eq SchemaTitle
Eq SchemaTitle =>
(SchemaTitle -> SchemaTitle -> Ordering)
-> (SchemaTitle -> SchemaTitle -> Bool)
-> (SchemaTitle -> SchemaTitle -> Bool)
-> (SchemaTitle -> SchemaTitle -> Bool)
-> (SchemaTitle -> SchemaTitle -> Bool)
-> (SchemaTitle -> SchemaTitle -> SchemaTitle)
-> (SchemaTitle -> SchemaTitle -> SchemaTitle)
-> Ord SchemaTitle
SchemaTitle -> SchemaTitle -> Bool
SchemaTitle -> SchemaTitle -> Ordering
SchemaTitle -> SchemaTitle -> SchemaTitle
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SchemaTitle -> SchemaTitle -> Ordering
compare :: SchemaTitle -> SchemaTitle -> Ordering
$c< :: SchemaTitle -> SchemaTitle -> Bool
< :: SchemaTitle -> SchemaTitle -> Bool
$c<= :: SchemaTitle -> SchemaTitle -> Bool
<= :: SchemaTitle -> SchemaTitle -> Bool
$c> :: SchemaTitle -> SchemaTitle -> Bool
> :: SchemaTitle -> SchemaTitle -> Bool
$c>= :: SchemaTitle -> SchemaTitle -> Bool
>= :: SchemaTitle -> SchemaTitle -> Bool
$cmax :: SchemaTitle -> SchemaTitle -> SchemaTitle
max :: SchemaTitle -> SchemaTitle -> SchemaTitle
$cmin :: SchemaTitle -> SchemaTitle -> SchemaTitle
min :: SchemaTitle -> SchemaTitle -> SchemaTitle
Ord, Int -> SchemaTitle -> ShowS
[SchemaTitle] -> ShowS
SchemaTitle -> SchemaInfoError
(Int -> SchemaTitle -> ShowS)
-> (SchemaTitle -> SchemaInfoError)
-> ([SchemaTitle] -> ShowS)
-> Show SchemaTitle
forall a.
(Int -> a -> ShowS)
-> (a -> SchemaInfoError) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaTitle -> ShowS
showsPrec :: Int -> SchemaTitle -> ShowS
$cshow :: SchemaTitle -> SchemaInfoError
show :: SchemaTitle -> SchemaInfoError
$cshowList :: [SchemaTitle] -> ShowS
showList :: [SchemaTitle] -> ShowS
Show, Typeable, [SchemaTitle] -> Encoding
[SchemaTitle] -> Value
SchemaTitle -> Bool
SchemaTitle -> Encoding
SchemaTitle -> Value
(SchemaTitle -> Value)
-> (SchemaTitle -> Encoding)
-> ([SchemaTitle] -> Value)
-> ([SchemaTitle] -> Encoding)
-> (SchemaTitle -> Bool)
-> ToJSON SchemaTitle
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SchemaTitle -> Value
toJSON :: SchemaTitle -> Value
$ctoEncoding :: SchemaTitle -> Encoding
toEncoding :: SchemaTitle -> Encoding
$ctoJSONList :: [SchemaTitle] -> Value
toJSONList :: [SchemaTitle] -> Value
$ctoEncodingList :: [SchemaTitle] -> Encoding
toEncodingList :: [SchemaTitle] -> Encoding
$comitField :: SchemaTitle -> Bool
omitField :: SchemaTitle -> Bool
ToJSON)
  deriving stock (Typeable SchemaTitle
Typeable SchemaTitle =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SchemaTitle -> c SchemaTitle)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SchemaTitle)
-> (SchemaTitle -> Constr)
-> (SchemaTitle -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SchemaTitle))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SchemaTitle))
-> ((forall b. Data b => b -> b) -> SchemaTitle -> SchemaTitle)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r)
-> (forall u. (forall d. Data d => d -> u) -> SchemaTitle -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SchemaTitle -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle)
-> Data SchemaTitle
SchemaTitle -> Constr
SchemaTitle -> DataType
(forall b. Data b => b -> b) -> SchemaTitle -> SchemaTitle
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SchemaTitle -> u
forall u. (forall d. Data d => d -> u) -> SchemaTitle -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaTitle
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaTitle -> c SchemaTitle
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaTitle)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaTitle)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaTitle -> c SchemaTitle
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaTitle -> c SchemaTitle
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaTitle
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaTitle
$ctoConstr :: SchemaTitle -> Constr
toConstr :: SchemaTitle -> Constr
$cdataTypeOf :: SchemaTitle -> DataType
dataTypeOf :: SchemaTitle -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaTitle)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaTitle)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaTitle)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaTitle)
$cgmapT :: (forall b. Data b => b -> b) -> SchemaTitle -> SchemaTitle
gmapT :: (forall b. Data b => b -> b) -> SchemaTitle -> SchemaTitle
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaTitle -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaTitle -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaTitle -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaTitle -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaTitle -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaTitle -> m SchemaTitle
Data, (forall (m :: * -> *). Quote m => SchemaTitle -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    SchemaTitle -> Code m SchemaTitle)
-> Lift SchemaTitle
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SchemaTitle -> m Exp
forall (m :: * -> *). Quote m => SchemaTitle -> Code m SchemaTitle
$clift :: forall (m :: * -> *). Quote m => SchemaTitle -> m Exp
lift :: forall (m :: * -> *). Quote m => SchemaTitle -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => SchemaTitle -> Code m SchemaTitle
liftTyped :: forall (m :: * -> *). Quote m => SchemaTitle -> Code m SchemaTitle
Lift)

{- | An annotation for the "description" schema attribute.

This annotation could be attached to a type or constructor:
@
{\-# ANN type MyFoo (SchemaDescription "My Foo Description") #-\}
{\-# ANN MkMyFoo (SchemaDescription "Description") #-\}
newtype MyFoo = MkMyFoo Int
@
-}
newtype SchemaDescription = SchemaDescription {SchemaDescription -> SchemaInfoError
schemaDescriptionToString :: String}
  deriving newtype (SchemaDescription -> SchemaDescription -> Bool
(SchemaDescription -> SchemaDescription -> Bool)
-> (SchemaDescription -> SchemaDescription -> Bool)
-> Eq SchemaDescription
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaDescription -> SchemaDescription -> Bool
== :: SchemaDescription -> SchemaDescription -> Bool
$c/= :: SchemaDescription -> SchemaDescription -> Bool
/= :: SchemaDescription -> SchemaDescription -> Bool
Eq, Eq SchemaDescription
Eq SchemaDescription =>
(SchemaDescription -> SchemaDescription -> Ordering)
-> (SchemaDescription -> SchemaDescription -> Bool)
-> (SchemaDescription -> SchemaDescription -> Bool)
-> (SchemaDescription -> SchemaDescription -> Bool)
-> (SchemaDescription -> SchemaDescription -> Bool)
-> (SchemaDescription -> SchemaDescription -> SchemaDescription)
-> (SchemaDescription -> SchemaDescription -> SchemaDescription)
-> Ord SchemaDescription
SchemaDescription -> SchemaDescription -> Bool
SchemaDescription -> SchemaDescription -> Ordering
SchemaDescription -> SchemaDescription -> SchemaDescription
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SchemaDescription -> SchemaDescription -> Ordering
compare :: SchemaDescription -> SchemaDescription -> Ordering
$c< :: SchemaDescription -> SchemaDescription -> Bool
< :: SchemaDescription -> SchemaDescription -> Bool
$c<= :: SchemaDescription -> SchemaDescription -> Bool
<= :: SchemaDescription -> SchemaDescription -> Bool
$c> :: SchemaDescription -> SchemaDescription -> Bool
> :: SchemaDescription -> SchemaDescription -> Bool
$c>= :: SchemaDescription -> SchemaDescription -> Bool
>= :: SchemaDescription -> SchemaDescription -> Bool
$cmax :: SchemaDescription -> SchemaDescription -> SchemaDescription
max :: SchemaDescription -> SchemaDescription -> SchemaDescription
$cmin :: SchemaDescription -> SchemaDescription -> SchemaDescription
min :: SchemaDescription -> SchemaDescription -> SchemaDescription
Ord, Int -> SchemaDescription -> ShowS
[SchemaDescription] -> ShowS
SchemaDescription -> SchemaInfoError
(Int -> SchemaDescription -> ShowS)
-> (SchemaDescription -> SchemaInfoError)
-> ([SchemaDescription] -> ShowS)
-> Show SchemaDescription
forall a.
(Int -> a -> ShowS)
-> (a -> SchemaInfoError) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaDescription -> ShowS
showsPrec :: Int -> SchemaDescription -> ShowS
$cshow :: SchemaDescription -> SchemaInfoError
show :: SchemaDescription -> SchemaInfoError
$cshowList :: [SchemaDescription] -> ShowS
showList :: [SchemaDescription] -> ShowS
Show, Typeable, [SchemaDescription] -> Encoding
[SchemaDescription] -> Value
SchemaDescription -> Bool
SchemaDescription -> Encoding
SchemaDescription -> Value
(SchemaDescription -> Value)
-> (SchemaDescription -> Encoding)
-> ([SchemaDescription] -> Value)
-> ([SchemaDescription] -> Encoding)
-> (SchemaDescription -> Bool)
-> ToJSON SchemaDescription
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SchemaDescription -> Value
toJSON :: SchemaDescription -> Value
$ctoEncoding :: SchemaDescription -> Encoding
toEncoding :: SchemaDescription -> Encoding
$ctoJSONList :: [SchemaDescription] -> Value
toJSONList :: [SchemaDescription] -> Value
$ctoEncodingList :: [SchemaDescription] -> Encoding
toEncodingList :: [SchemaDescription] -> Encoding
$comitField :: SchemaDescription -> Bool
omitField :: SchemaDescription -> Bool
ToJSON)
  deriving stock (Typeable SchemaDescription
Typeable SchemaDescription =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SchemaDescription
 -> c SchemaDescription)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SchemaDescription)
-> (SchemaDescription -> Constr)
-> (SchemaDescription -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SchemaDescription))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SchemaDescription))
-> ((forall b. Data b => b -> b)
    -> SchemaDescription -> SchemaDescription)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SchemaDescription -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SchemaDescription -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SchemaDescription -> m SchemaDescription)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SchemaDescription -> m SchemaDescription)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SchemaDescription -> m SchemaDescription)
-> Data SchemaDescription
SchemaDescription -> Constr
SchemaDescription -> DataType
(forall b. Data b => b -> b)
-> SchemaDescription -> SchemaDescription
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SchemaDescription -> u
forall u. (forall d. Data d => d -> u) -> SchemaDescription -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaDescription
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaDescription -> c SchemaDescription
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaDescription)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaDescription)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaDescription -> c SchemaDescription
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaDescription -> c SchemaDescription
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaDescription
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaDescription
$ctoConstr :: SchemaDescription -> Constr
toConstr :: SchemaDescription -> Constr
$cdataTypeOf :: SchemaDescription -> DataType
dataTypeOf :: SchemaDescription -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaDescription)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaDescription)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaDescription)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaDescription)
$cgmapT :: (forall b. Data b => b -> b)
-> SchemaDescription -> SchemaDescription
gmapT :: (forall b. Data b => b -> b)
-> SchemaDescription -> SchemaDescription
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaDescription -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaDescription -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaDescription -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SchemaDescription -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SchemaDescription -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaDescription -> m SchemaDescription
Data, (forall (m :: * -> *). Quote m => SchemaDescription -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    SchemaDescription -> Code m SchemaDescription)
-> Lift SchemaDescription
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SchemaDescription -> m Exp
forall (m :: * -> *).
Quote m =>
SchemaDescription -> Code m SchemaDescription
$clift :: forall (m :: * -> *). Quote m => SchemaDescription -> m Exp
lift :: forall (m :: * -> *). Quote m => SchemaDescription -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
SchemaDescription -> Code m SchemaDescription
liftTyped :: forall (m :: * -> *).
Quote m =>
SchemaDescription -> Code m SchemaDescription
Lift)

{- | An annotation for the "$comment" schema attribute.

This annotation could be attached to a type or constructor:
@
{\-# ANN type MyFoo (SchemaComment "My Foo Comment") #-\}
{\-# ANN MkMyFoo (SchemaComment "Comment") #-\}
newtype MyFoo = MkMyFoo Int
@
-}
newtype SchemaComment = SchemaComment {SchemaComment -> SchemaInfoError
schemaCommentToString :: String}
  deriving newtype (SchemaComment -> SchemaComment -> Bool
(SchemaComment -> SchemaComment -> Bool)
-> (SchemaComment -> SchemaComment -> Bool) -> Eq SchemaComment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaComment -> SchemaComment -> Bool
== :: SchemaComment -> SchemaComment -> Bool
$c/= :: SchemaComment -> SchemaComment -> Bool
/= :: SchemaComment -> SchemaComment -> Bool
Eq, Eq SchemaComment
Eq SchemaComment =>
(SchemaComment -> SchemaComment -> Ordering)
-> (SchemaComment -> SchemaComment -> Bool)
-> (SchemaComment -> SchemaComment -> Bool)
-> (SchemaComment -> SchemaComment -> Bool)
-> (SchemaComment -> SchemaComment -> Bool)
-> (SchemaComment -> SchemaComment -> SchemaComment)
-> (SchemaComment -> SchemaComment -> SchemaComment)
-> Ord SchemaComment
SchemaComment -> SchemaComment -> Bool
SchemaComment -> SchemaComment -> Ordering
SchemaComment -> SchemaComment -> SchemaComment
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SchemaComment -> SchemaComment -> Ordering
compare :: SchemaComment -> SchemaComment -> Ordering
$c< :: SchemaComment -> SchemaComment -> Bool
< :: SchemaComment -> SchemaComment -> Bool
$c<= :: SchemaComment -> SchemaComment -> Bool
<= :: SchemaComment -> SchemaComment -> Bool
$c> :: SchemaComment -> SchemaComment -> Bool
> :: SchemaComment -> SchemaComment -> Bool
$c>= :: SchemaComment -> SchemaComment -> Bool
>= :: SchemaComment -> SchemaComment -> Bool
$cmax :: SchemaComment -> SchemaComment -> SchemaComment
max :: SchemaComment -> SchemaComment -> SchemaComment
$cmin :: SchemaComment -> SchemaComment -> SchemaComment
min :: SchemaComment -> SchemaComment -> SchemaComment
Ord, Int -> SchemaComment -> ShowS
[SchemaComment] -> ShowS
SchemaComment -> SchemaInfoError
(Int -> SchemaComment -> ShowS)
-> (SchemaComment -> SchemaInfoError)
-> ([SchemaComment] -> ShowS)
-> Show SchemaComment
forall a.
(Int -> a -> ShowS)
-> (a -> SchemaInfoError) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaComment -> ShowS
showsPrec :: Int -> SchemaComment -> ShowS
$cshow :: SchemaComment -> SchemaInfoError
show :: SchemaComment -> SchemaInfoError
$cshowList :: [SchemaComment] -> ShowS
showList :: [SchemaComment] -> ShowS
Show, Typeable, [SchemaComment] -> Encoding
[SchemaComment] -> Value
SchemaComment -> Bool
SchemaComment -> Encoding
SchemaComment -> Value
(SchemaComment -> Value)
-> (SchemaComment -> Encoding)
-> ([SchemaComment] -> Value)
-> ([SchemaComment] -> Encoding)
-> (SchemaComment -> Bool)
-> ToJSON SchemaComment
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SchemaComment -> Value
toJSON :: SchemaComment -> Value
$ctoEncoding :: SchemaComment -> Encoding
toEncoding :: SchemaComment -> Encoding
$ctoJSONList :: [SchemaComment] -> Value
toJSONList :: [SchemaComment] -> Value
$ctoEncodingList :: [SchemaComment] -> Encoding
toEncodingList :: [SchemaComment] -> Encoding
$comitField :: SchemaComment -> Bool
omitField :: SchemaComment -> Bool
ToJSON)
  deriving stock (Typeable SchemaComment
Typeable SchemaComment =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SchemaComment -> c SchemaComment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SchemaComment)
-> (SchemaComment -> Constr)
-> (SchemaComment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SchemaComment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SchemaComment))
-> ((forall b. Data b => b -> b) -> SchemaComment -> SchemaComment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaComment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaComment -> r)
-> (forall u. (forall d. Data d => d -> u) -> SchemaComment -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SchemaComment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment)
-> Data SchemaComment
SchemaComment -> Constr
SchemaComment -> DataType
(forall b. Data b => b -> b) -> SchemaComment -> SchemaComment
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SchemaComment -> u
forall u. (forall d. Data d => d -> u) -> SchemaComment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaComment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaComment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaComment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaComment -> c SchemaComment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaComment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaComment)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaComment -> c SchemaComment
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaComment -> c SchemaComment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaComment
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaComment
$ctoConstr :: SchemaComment -> Constr
toConstr :: SchemaComment -> Constr
$cdataTypeOf :: SchemaComment -> DataType
dataTypeOf :: SchemaComment -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaComment)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaComment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaComment)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaComment)
$cgmapT :: (forall b. Data b => b -> b) -> SchemaComment -> SchemaComment
gmapT :: (forall b. Data b => b -> b) -> SchemaComment -> SchemaComment
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaComment -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaComment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaComment -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaComment -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaComment -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaComment -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaComment -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SchemaComment -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SchemaComment -> m SchemaComment
Data, (forall (m :: * -> *). Quote m => SchemaComment -> m Exp)
-> (forall (m :: * -> *).
    Quote m =>
    SchemaComment -> Code m SchemaComment)
-> Lift SchemaComment
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => SchemaComment -> m Exp
forall (m :: * -> *).
Quote m =>
SchemaComment -> Code m SchemaComment
$clift :: forall (m :: * -> *). Quote m => SchemaComment -> m Exp
lift :: forall (m :: * -> *). Quote m => SchemaComment -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
SchemaComment -> Code m SchemaComment
liftTyped :: forall (m :: * -> *).
Quote m =>
SchemaComment -> Code m SchemaComment
Lift)