Documentation

Methods

fold :: Monoid m => MetaNode m -> m #

foldMap :: Monoid m => (a -> m) -> MetaNode a -> m #

foldMap' :: Monoid m => (a -> m) -> MetaNode a -> m #

foldr :: (a -> b -> b) -> b -> MetaNode a -> b #

foldr' :: (a -> b -> b) -> b -> MetaNode a -> b #

foldl :: (b -> a -> b) -> b -> MetaNode a -> b #

foldl' :: (b -> a -> b) -> b -> MetaNode a -> b #

foldr1 :: (a -> a -> a) -> MetaNode a -> a #

foldl1 :: (a -> a -> a) -> MetaNode a -> a #

toList :: MetaNode a -> [a] #

null :: MetaNode a -> Bool #

length :: MetaNode a -> Int #

elem :: Eq a => a -> MetaNode a -> Bool #

maximum :: Ord a => MetaNode a -> a #

minimum :: Ord a => MetaNode a -> a #

sum :: Num a => MetaNode a -> a #

product :: Num a => MetaNode a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> MetaNode a -> f (MetaNode b) #

sequenceA :: Applicative f => MetaNode (f a) -> f (MetaNode a) #

mapM :: Monad m => (a -> m b) -> MetaNode a -> m (MetaNode b) #

sequence :: Monad m => MetaNode (m a) -> m (MetaNode a) #

Methods

fmap :: (a -> b) -> MetaNode a -> MetaNode b #

(<$) :: a -> MetaNode b -> MetaNode a #

Methods

parseJSON :: Value -> Parser (MetaNode a)

parseJSONList :: Value -> Parser [MetaNode a]

omittedField :: Maybe (MetaNode a)

Methods

toJSON :: MetaNode a -> Value

toEncoding :: MetaNode a -> Encoding

toJSONList :: [MetaNode a] -> Value

toEncodingList :: [MetaNode a] -> Encoding

omitField :: MetaNode a -> Bool

Methods

from :: MetaNode a -> Rep (MetaNode a) x #

to :: Rep (MetaNode a) x -> MetaNode a #

Methods

declareNamedSchema :: Proxy (MetaNode a) -> Declare (Definitions Schema) NamedSchema

Methods

fold :: Monoid m => MetaTree m -> m #

foldMap :: Monoid m => (a -> m) -> MetaTree a -> m #

foldMap' :: Monoid m => (a -> m) -> MetaTree a -> m #

foldr :: (a -> b -> b) -> b -> MetaTree a -> b #

foldr' :: (a -> b -> b) -> b -> MetaTree a -> b #

foldl :: (b -> a -> b) -> b -> MetaTree a -> b #

foldl' :: (b -> a -> b) -> b -> MetaTree a -> b #

foldr1 :: (a -> a -> a) -> MetaTree a -> a #

foldl1 :: (a -> a -> a) -> MetaTree a -> a #

toList :: MetaTree a -> [a] #

null :: MetaTree a -> Bool #

length :: MetaTree a -> Int #

elem :: Eq a => a -> MetaTree a -> Bool #

maximum :: Ord a => MetaTree a -> a #

minimum :: Ord a => MetaTree a -> a #

sum :: Num a => MetaTree a -> a #

product :: Num a => MetaTree a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> MetaTree a -> f (MetaTree b) #

sequenceA :: Applicative f => MetaTree (f a) -> f (MetaTree a) #

mapM :: Monad m => (a -> m b) -> MetaTree a -> m (MetaTree b) #

sequence :: Monad m => MetaTree (m a) -> m (MetaTree a) #

Methods

fmap :: (a -> b) -> MetaTree a -> MetaTree b #

(<$) :: a -> MetaTree b -> MetaTree a #

Methods

parseJSON :: Value -> Parser (MetaTree a)

parseJSONList :: Value -> Parser [MetaTree a]

omittedField :: Maybe (MetaTree a)

Methods

toJSON :: MetaTree a -> Value

toEncoding :: MetaTree a -> Encoding

toJSONList :: [MetaTree a] -> Value

toEncodingList :: [MetaTree a] -> Encoding

omitField :: MetaTree a -> Bool

Methods

from :: MetaTree a -> Rep (MetaTree a) x #

to :: Rep (MetaTree a) x -> MetaTree a #

Methods

declareNamedSchema :: Proxy (MetaTree a) -> Declare (Definitions Schema) NamedSchema

Methods

fold :: Monoid m => Meta m -> m #

foldMap :: Monoid m => (a -> m) -> Meta a -> m #

foldMap' :: Monoid m => (a -> m) -> Meta a -> m #

foldr :: (a -> b -> b) -> b -> Meta a -> b #

foldr' :: (a -> b -> b) -> b -> Meta a -> b #

foldl :: (b -> a -> b) -> b -> Meta a -> b #

foldl' :: (b -> a -> b) -> b -> Meta a -> b #

foldr1 :: (a -> a -> a) -> Meta a -> a #

foldl1 :: (a -> a -> a) -> Meta a -> a #

toList :: Meta a -> [a] #

null :: Meta a -> Bool #

length :: Meta a -> Int #

elem :: Eq a => a -> Meta a -> Bool #

maximum :: Ord a => Meta a -> a #

minimum :: Ord a => Meta a -> a #

sum :: Num a => Meta a -> a #

product :: Num a => Meta a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Meta a -> f (Meta b) #

sequenceA :: Applicative f => Meta (f a) -> f (Meta a) #

mapM :: Monad m => (a -> m b) -> Meta a -> m (Meta b) #

sequence :: Monad m => Meta (m a) -> m (Meta a) #

Methods

fmap :: (a -> b) -> Meta a -> Meta b #

(<$) :: a -> Meta b -> Meta a #

Methods

parseJSON :: Value -> Parser (Meta a)

parseJSONList :: Value -> Parser [Meta a]

omittedField :: Maybe (Meta a)

Methods

toJSON :: Meta a -> Value

toEncoding :: Meta a -> Encoding

toJSONList :: [Meta a] -> Value

toEncodingList :: [Meta a] -> Encoding

omitField :: Meta a -> Bool

Methods

from :: Meta a -> Rep (Meta a) x #

to :: Rep (Meta a) x -> Meta a #

Methods

declareNamedSchema :: Proxy (Meta a) -> Declare (Definitions Schema) NamedSchema

Methods

parseJSON :: Value -> Parser TocEntry

parseJSONList :: Value -> Parser [TocEntry]

omittedField :: Maybe TocEntry

Methods

toJSON :: TocEntry -> Value

toEncoding :: TocEntry -> Encoding

toJSONList :: [TocEntry] -> Value

toEncodingList :: [TocEntry] -> Encoding

omitField :: TocEntry -> Bool

Methods

from :: TocEntry -> Rep TocEntry x #

to :: Rep TocEntry x -> TocEntry #

Methods

declareNamedSchema :: Proxy TocEntry -> Declare (Definitions Schema) NamedSchema

Methods

fmap :: (a -> b) -> TreeWithMetaData a -> TreeWithMetaData b #

(<$) :: a -> TreeWithMetaData b -> TreeWithMetaData a #

Methods

parseJSON :: Value -> Parser (TreeWithMetaData a)

parseJSONList :: Value -> Parser [TreeWithMetaData a]

omittedField :: Maybe (TreeWithMetaData a)

Methods

toJSON :: TreeWithMetaData a -> Value

toEncoding :: TreeWithMetaData a -> Encoding

toJSONList :: [TreeWithMetaData a] -> Value

toEncodingList :: [TreeWithMetaData a] -> Encoding

omitField :: TreeWithMetaData a -> Bool

Methods

from :: TreeWithMetaData a -> Rep (TreeWithMetaData a) x #

to :: Rep (TreeWithMetaData a) x -> TreeWithMetaData a #

Methods

declareNamedSchema :: Proxy (TreeWithMetaData a) -> Declare (Definitions Schema) NamedSchema

Methods

fmap :: (a -> b) -> TreeRevisionWithMetaData a -> TreeRevisionWithMetaData b #

(<$) :: a -> TreeRevisionWithMetaData b -> TreeRevisionWithMetaData a #

Methods

parseJSON :: Value -> Parser (TreeRevisionWithMetaData a)

parseJSONList :: Value -> Parser [TreeRevisionWithMetaData a]

omittedField :: Maybe (TreeRevisionWithMetaData a)

Methods

toJSON :: TreeRevisionWithMetaData a -> Value

toEncoding :: TreeRevisionWithMetaData a -> Encoding

toJSONList :: [TreeRevisionWithMetaData a] -> Value

toEncodingList :: [TreeRevisionWithMetaData a] -> Encoding

omitField :: TreeRevisionWithMetaData a -> Bool

Methods

from :: TreeRevisionWithMetaData a -> Rep (TreeRevisionWithMetaData a) x #

to :: Rep (TreeRevisionWithMetaData a) x -> TreeRevisionWithMetaData a #

Methods

declareNamedSchema :: Proxy (TreeRevisionWithMetaData a) -> Declare (Definitions Schema) NamedSchema