{-# LANGUAGE TupleSections #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-- | Consume a 'Schema' and emit types intended for code generation.
module Fadno.Xml.EmitTypes
    (
     -- * XSD Schema to types
     emitSchema
     -- * Emit various productions
    ,emitElement,emitSimpleType,emitComplexType,emitCompositor
    ,emitGroup,emitChoice,emitSequence,emitParticle,emitAttrFields
     -- * Emit monad
    ,Emit,Env(..),schema,EmitState(..),types,stack,runEmit,die
    -- * Types
    ,Name(..),Namespace(..),Cardinality(..)
    ,Field(..),fieldName,fieldType,fieldCardinality,fieldXmlEmit,fieldIdx,FieldEmit(..)
    ,Ctor(..),ctorName,ctorFields
    ,Type(..),typeName,typeType,typeDerives,typeImpls,typeEmit,typeCtors,typeEnumValues,coreType
    ,DerivesFamily(..),DataTypeEmit(..),CoreType(..),Impl(..)
    ) where

import Fadno.Xml.ParseXsd
import Data.Semigroup
import Control.Lens hiding (Choice,element,elements,anon)

import Control.Monad.State.Strict
import Control.Monad.Reader
import Data.Maybe
import Data.Data
import Control.Exception hiding (handle)
import qualified Data.Map.Strict as M


-- | Field cardinality
data Cardinality =
    One |
    ZeroOrOne |
    Many
    deriving (Cardinality -> Cardinality -> Bool
(Cardinality -> Cardinality -> Bool)
-> (Cardinality -> Cardinality -> Bool) -> Eq Cardinality
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cardinality -> Cardinality -> Bool
$c/= :: Cardinality -> Cardinality -> Bool
== :: Cardinality -> Cardinality -> Bool
$c== :: Cardinality -> Cardinality -> Bool
Eq,Int -> Cardinality -> ShowS
[Cardinality] -> ShowS
Cardinality -> String
(Int -> Cardinality -> ShowS)
-> (Cardinality -> String)
-> ([Cardinality] -> ShowS)
-> Show Cardinality
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cardinality] -> ShowS
$cshowList :: [Cardinality] -> ShowS
show :: Cardinality -> String
$cshow :: Cardinality -> String
showsPrec :: Int -> Cardinality -> ShowS
$cshowsPrec :: Int -> Cardinality -> ShowS
Show,Typeable Cardinality
DataType
Constr
Typeable Cardinality
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Cardinality -> c Cardinality)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Cardinality)
-> (Cardinality -> Constr)
-> (Cardinality -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Cardinality))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Cardinality))
-> ((forall b. Data b => b -> b) -> Cardinality -> Cardinality)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Cardinality -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Cardinality -> r)
-> (forall u. (forall d. Data d => d -> u) -> Cardinality -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Cardinality -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Cardinality -> m Cardinality)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cardinality -> m Cardinality)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cardinality -> m Cardinality)
-> Data Cardinality
Cardinality -> DataType
Cardinality -> Constr
(forall b. Data b => b -> b) -> Cardinality -> Cardinality
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cardinality -> c Cardinality
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cardinality
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) -> Cardinality -> u
forall u. (forall d. Data d => d -> u) -> Cardinality -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Cardinality -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Cardinality -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cardinality
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cardinality -> c Cardinality
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Cardinality)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Cardinality)
$cMany :: Constr
$cZeroOrOne :: Constr
$cOne :: Constr
$tCardinality :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
gmapMp :: (forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
gmapM :: (forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cardinality -> m Cardinality
gmapQi :: Int -> (forall d. Data d => d -> u) -> Cardinality -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Cardinality -> u
gmapQ :: (forall d. Data d => d -> u) -> Cardinality -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Cardinality -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Cardinality -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Cardinality -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Cardinality -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Cardinality -> r
gmapT :: (forall b. Data b => b -> b) -> Cardinality -> Cardinality
$cgmapT :: (forall b. Data b => b -> b) -> Cardinality -> Cardinality
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Cardinality)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Cardinality)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Cardinality)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Cardinality)
dataTypeOf :: Cardinality -> DataType
$cdataTypeOf :: Cardinality -> DataType
toConstr :: Cardinality -> Constr
$ctoConstr :: Cardinality -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cardinality
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cardinality
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cardinality -> c Cardinality
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cardinality -> c Cardinality
$cp1Data :: Typeable Cardinality
Data,Typeable,Eq Cardinality
Eq Cardinality
-> (Cardinality -> Cardinality -> Ordering)
-> (Cardinality -> Cardinality -> Bool)
-> (Cardinality -> Cardinality -> Bool)
-> (Cardinality -> Cardinality -> Bool)
-> (Cardinality -> Cardinality -> Bool)
-> (Cardinality -> Cardinality -> Cardinality)
-> (Cardinality -> Cardinality -> Cardinality)
-> Ord Cardinality
Cardinality -> Cardinality -> Bool
Cardinality -> Cardinality -> Ordering
Cardinality -> Cardinality -> Cardinality
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
min :: Cardinality -> Cardinality -> Cardinality
$cmin :: Cardinality -> Cardinality -> Cardinality
max :: Cardinality -> Cardinality -> Cardinality
$cmax :: Cardinality -> Cardinality -> Cardinality
>= :: Cardinality -> Cardinality -> Bool
$c>= :: Cardinality -> Cardinality -> Bool
> :: Cardinality -> Cardinality -> Bool
$c> :: Cardinality -> Cardinality -> Bool
<= :: Cardinality -> Cardinality -> Bool
$c<= :: Cardinality -> Cardinality -> Bool
< :: Cardinality -> Cardinality -> Bool
$c< :: Cardinality -> Cardinality -> Bool
compare :: Cardinality -> Cardinality -> Ordering
$ccompare :: Cardinality -> Cardinality -> Ordering
$cp1Ord :: Eq Cardinality
Ord,Int -> Cardinality
Cardinality -> Int
Cardinality -> [Cardinality]
Cardinality -> Cardinality
Cardinality -> Cardinality -> [Cardinality]
Cardinality -> Cardinality -> Cardinality -> [Cardinality]
(Cardinality -> Cardinality)
-> (Cardinality -> Cardinality)
-> (Int -> Cardinality)
-> (Cardinality -> Int)
-> (Cardinality -> [Cardinality])
-> (Cardinality -> Cardinality -> [Cardinality])
-> (Cardinality -> Cardinality -> [Cardinality])
-> (Cardinality -> Cardinality -> Cardinality -> [Cardinality])
-> Enum Cardinality
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Cardinality -> Cardinality -> Cardinality -> [Cardinality]
$cenumFromThenTo :: Cardinality -> Cardinality -> Cardinality -> [Cardinality]
enumFromTo :: Cardinality -> Cardinality -> [Cardinality]
$cenumFromTo :: Cardinality -> Cardinality -> [Cardinality]
enumFromThen :: Cardinality -> Cardinality -> [Cardinality]
$cenumFromThen :: Cardinality -> Cardinality -> [Cardinality]
enumFrom :: Cardinality -> [Cardinality]
$cenumFrom :: Cardinality -> [Cardinality]
fromEnum :: Cardinality -> Int
$cfromEnum :: Cardinality -> Int
toEnum :: Int -> Cardinality
$ctoEnum :: Int -> Cardinality
pred :: Cardinality -> Cardinality
$cpred :: Cardinality -> Cardinality
succ :: Cardinality -> Cardinality
$csucc :: Cardinality -> Cardinality
Enum,Cardinality
Cardinality -> Cardinality -> Bounded Cardinality
forall a. a -> a -> Bounded a
maxBound :: Cardinality
$cmaxBound :: Cardinality
minBound :: Cardinality
$cminBound :: Cardinality
Bounded)

-- | Namespaces for various productions.
data Namespace =
    NSElement |
    NSSimple |
    NSUnion |
    NSComplex |
    NSBuiltIn |
    NSChoice |
    NSSequence |
    NSGroup
    deriving (Namespace -> Namespace -> Bool
(Namespace -> Namespace -> Bool)
-> (Namespace -> Namespace -> Bool) -> Eq Namespace
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Namespace -> Namespace -> Bool
$c/= :: Namespace -> Namespace -> Bool
== :: Namespace -> Namespace -> Bool
$c== :: Namespace -> Namespace -> Bool
Eq,Int -> Namespace -> ShowS
[Namespace] -> ShowS
Namespace -> String
(Int -> Namespace -> ShowS)
-> (Namespace -> String)
-> ([Namespace] -> ShowS)
-> Show Namespace
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Namespace] -> ShowS
$cshowList :: [Namespace] -> ShowS
show :: Namespace -> String
$cshow :: Namespace -> String
showsPrec :: Int -> Namespace -> ShowS
$cshowsPrec :: Int -> Namespace -> ShowS
Show,Typeable Namespace
DataType
Constr
Typeable Namespace
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Namespace -> c Namespace)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Namespace)
-> (Namespace -> Constr)
-> (Namespace -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Namespace))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Namespace))
-> ((forall b. Data b => b -> b) -> Namespace -> Namespace)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Namespace -> r)
-> (forall u. (forall d. Data d => d -> u) -> Namespace -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Namespace -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Namespace -> m Namespace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namespace -> m Namespace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Namespace -> m Namespace)
-> Data Namespace
Namespace -> DataType
Namespace -> Constr
(forall b. Data b => b -> b) -> Namespace -> Namespace
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace -> c Namespace
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Namespace
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) -> Namespace -> u
forall u. (forall d. Data d => d -> u) -> Namespace -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Namespace -> m Namespace
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Namespace -> m Namespace
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Namespace
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace -> c Namespace
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Namespace)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Namespace)
$cNSGroup :: Constr
$cNSSequence :: Constr
$cNSChoice :: Constr
$cNSBuiltIn :: Constr
$cNSComplex :: Constr
$cNSUnion :: Constr
$cNSSimple :: Constr
$cNSElement :: Constr
$tNamespace :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Namespace -> m Namespace
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Namespace -> m Namespace
gmapMp :: (forall d. Data d => d -> m d) -> Namespace -> m Namespace
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Namespace -> m Namespace
gmapM :: (forall d. Data d => d -> m d) -> Namespace -> m Namespace
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Namespace -> m Namespace
gmapQi :: Int -> (forall d. Data d => d -> u) -> Namespace -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Namespace -> u
gmapQ :: (forall d. Data d => d -> u) -> Namespace -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Namespace -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Namespace -> r
gmapT :: (forall b. Data b => b -> b) -> Namespace -> Namespace
$cgmapT :: (forall b. Data b => b -> b) -> Namespace -> Namespace
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Namespace)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Namespace)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Namespace)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Namespace)
dataTypeOf :: Namespace -> DataType
$cdataTypeOf :: Namespace -> DataType
toConstr :: Namespace -> Constr
$ctoConstr :: Namespace -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Namespace
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Namespace
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace -> c Namespace
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Namespace -> c Namespace
$cp1Data :: Typeable Namespace
Data,Typeable,Eq Namespace
Eq Namespace
-> (Namespace -> Namespace -> Ordering)
-> (Namespace -> Namespace -> Bool)
-> (Namespace -> Namespace -> Bool)
-> (Namespace -> Namespace -> Bool)
-> (Namespace -> Namespace -> Bool)
-> (Namespace -> Namespace -> Namespace)
-> (Namespace -> Namespace -> Namespace)
-> Ord Namespace
Namespace -> Namespace -> Bool
Namespace -> Namespace -> Ordering
Namespace -> Namespace -> Namespace
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
min :: Namespace -> Namespace -> Namespace
$cmin :: Namespace -> Namespace -> Namespace
max :: Namespace -> Namespace -> Namespace
$cmax :: Namespace -> Namespace -> Namespace
>= :: Namespace -> Namespace -> Bool
$c>= :: Namespace -> Namespace -> Bool
> :: Namespace -> Namespace -> Bool
$c> :: Namespace -> Namespace -> Bool
<= :: Namespace -> Namespace -> Bool
$c<= :: Namespace -> Namespace -> Bool
< :: Namespace -> Namespace -> Bool
$c< :: Namespace -> Namespace -> Bool
compare :: Namespace -> Namespace -> Ordering
$ccompare :: Namespace -> Namespace -> Ordering
$cp1Ord :: Eq Namespace
Ord,Int -> Namespace
Namespace -> Int
Namespace -> [Namespace]
Namespace -> Namespace
Namespace -> Namespace -> [Namespace]
Namespace -> Namespace -> Namespace -> [Namespace]
(Namespace -> Namespace)
-> (Namespace -> Namespace)
-> (Int -> Namespace)
-> (Namespace -> Int)
-> (Namespace -> [Namespace])
-> (Namespace -> Namespace -> [Namespace])
-> (Namespace -> Namespace -> [Namespace])
-> (Namespace -> Namespace -> Namespace -> [Namespace])
-> Enum Namespace
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Namespace -> Namespace -> Namespace -> [Namespace]
$cenumFromThenTo :: Namespace -> Namespace -> Namespace -> [Namespace]
enumFromTo :: Namespace -> Namespace -> [Namespace]
$cenumFromTo :: Namespace -> Namespace -> [Namespace]
enumFromThen :: Namespace -> Namespace -> [Namespace]
$cenumFromThen :: Namespace -> Namespace -> [Namespace]
enumFrom :: Namespace -> [Namespace]
$cenumFrom :: Namespace -> [Namespace]
fromEnum :: Namespace -> Int
$cfromEnum :: Namespace -> Int
toEnum :: Int -> Namespace
$ctoEnum :: Int -> Namespace
pred :: Namespace -> Namespace
$cpred :: Namespace -> Namespace
succ :: Namespace -> Namespace
$csucc :: Namespace -> Namespace
Enum,Namespace
Namespace -> Namespace -> Bounded Namespace
forall a. a -> a -> Bounded a
maxBound :: Namespace
$cmaxBound :: Namespace
minBound :: Namespace
$cminBound :: Namespace
Bounded)

-- | Type name.
data Name = Name {
      Name -> Namespace
nNamespace :: Namespace
    , Name -> QN
nName :: QN
    , Name -> Int
nIdx :: Int }
            deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq,Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
(Int -> Name -> ShowS)
-> (Name -> String) -> ([Name] -> ShowS) -> Show Name
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show,Typeable Name
DataType
Constr
Typeable Name
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name -> c Name)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name)
-> (Name -> Constr)
-> (Name -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
-> ((forall b. Data b => b -> b) -> Name -> Name)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> Data Name
Name -> DataType
Name -> Constr
(forall b. Data b => b -> b) -> Name -> Name
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
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) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cName :: Constr
$tName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable Name
Data,Typeable,Eq Name
Eq Name
-> (Name -> Name -> Ordering)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Name)
-> (Name -> Name -> Name)
-> Ord Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
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
min :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
$cp1Ord :: Eq Name
Ord)

-- | Field xml emit cue.
data FieldEmit =
    FieldAttribute |
    FieldElement |
    FieldText |
    FieldOther
    deriving (FieldEmit -> FieldEmit -> Bool
(FieldEmit -> FieldEmit -> Bool)
-> (FieldEmit -> FieldEmit -> Bool) -> Eq FieldEmit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldEmit -> FieldEmit -> Bool
$c/= :: FieldEmit -> FieldEmit -> Bool
== :: FieldEmit -> FieldEmit -> Bool
$c== :: FieldEmit -> FieldEmit -> Bool
Eq,Int -> FieldEmit -> ShowS
[FieldEmit] -> ShowS
FieldEmit -> String
(Int -> FieldEmit -> ShowS)
-> (FieldEmit -> String)
-> ([FieldEmit] -> ShowS)
-> Show FieldEmit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldEmit] -> ShowS
$cshowList :: [FieldEmit] -> ShowS
show :: FieldEmit -> String
$cshow :: FieldEmit -> String
showsPrec :: Int -> FieldEmit -> ShowS
$cshowsPrec :: Int -> FieldEmit -> ShowS
Show,Typeable FieldEmit
DataType
Constr
Typeable FieldEmit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FieldEmit -> c FieldEmit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FieldEmit)
-> (FieldEmit -> Constr)
-> (FieldEmit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FieldEmit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldEmit))
-> ((forall b. Data b => b -> b) -> FieldEmit -> FieldEmit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldEmit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldEmit -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldEmit -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FieldEmit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit)
-> Data FieldEmit
FieldEmit -> DataType
FieldEmit -> Constr
(forall b. Data b => b -> b) -> FieldEmit -> FieldEmit
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldEmit -> c FieldEmit
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldEmit
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) -> FieldEmit -> u
forall u. (forall d. Data d => d -> u) -> FieldEmit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldEmit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldEmit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldEmit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldEmit -> c FieldEmit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldEmit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldEmit)
$cFieldOther :: Constr
$cFieldText :: Constr
$cFieldElement :: Constr
$cFieldAttribute :: Constr
$tFieldEmit :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
gmapMp :: (forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
gmapM :: (forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldEmit -> m FieldEmit
gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldEmit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldEmit -> u
gmapQ :: (forall d. Data d => d -> u) -> FieldEmit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldEmit -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldEmit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldEmit -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldEmit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldEmit -> r
gmapT :: (forall b. Data b => b -> b) -> FieldEmit -> FieldEmit
$cgmapT :: (forall b. Data b => b -> b) -> FieldEmit -> FieldEmit
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldEmit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldEmit)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FieldEmit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldEmit)
dataTypeOf :: FieldEmit -> DataType
$cdataTypeOf :: FieldEmit -> DataType
toConstr :: FieldEmit -> Constr
$ctoConstr :: FieldEmit -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldEmit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldEmit
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldEmit -> c FieldEmit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldEmit -> c FieldEmit
$cp1Data :: Typeable FieldEmit
Data,Typeable,Eq FieldEmit
Eq FieldEmit
-> (FieldEmit -> FieldEmit -> Ordering)
-> (FieldEmit -> FieldEmit -> Bool)
-> (FieldEmit -> FieldEmit -> Bool)
-> (FieldEmit -> FieldEmit -> Bool)
-> (FieldEmit -> FieldEmit -> Bool)
-> (FieldEmit -> FieldEmit -> FieldEmit)
-> (FieldEmit -> FieldEmit -> FieldEmit)
-> Ord FieldEmit
FieldEmit -> FieldEmit -> Bool
FieldEmit -> FieldEmit -> Ordering
FieldEmit -> FieldEmit -> FieldEmit
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
min :: FieldEmit -> FieldEmit -> FieldEmit
$cmin :: FieldEmit -> FieldEmit -> FieldEmit
max :: FieldEmit -> FieldEmit -> FieldEmit
$cmax :: FieldEmit -> FieldEmit -> FieldEmit
>= :: FieldEmit -> FieldEmit -> Bool
$c>= :: FieldEmit -> FieldEmit -> Bool
> :: FieldEmit -> FieldEmit -> Bool
$c> :: FieldEmit -> FieldEmit -> Bool
<= :: FieldEmit -> FieldEmit -> Bool
$c<= :: FieldEmit -> FieldEmit -> Bool
< :: FieldEmit -> FieldEmit -> Bool
$c< :: FieldEmit -> FieldEmit -> Bool
compare :: FieldEmit -> FieldEmit -> Ordering
$ccompare :: FieldEmit -> FieldEmit -> Ordering
$cp1Ord :: Eq FieldEmit
Ord)

-- | Type field.
data Field = Field {
      Field -> QN
_fieldName :: QN
    , Field -> Type
_fieldType :: Type
    , Field -> Cardinality
_fieldCardinality :: Cardinality
    , Field -> FieldEmit
_fieldXmlEmit :: FieldEmit
    , Field -> Int
_fieldIdx :: Int
    } deriving (Field -> Field -> Bool
(Field -> Field -> Bool) -> (Field -> Field -> Bool) -> Eq Field
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Field -> Field -> Bool
$c/= :: Field -> Field -> Bool
== :: Field -> Field -> Bool
$c== :: Field -> Field -> Bool
Eq,Typeable Field
DataType
Constr
Typeable Field
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Field -> c Field)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Field)
-> (Field -> Constr)
-> (Field -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Field))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Field))
-> ((forall b. Data b => b -> b) -> Field -> Field)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r)
-> (forall u. (forall d. Data d => d -> u) -> Field -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Field -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Field -> m Field)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Field -> m Field)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Field -> m Field)
-> Data Field
Field -> DataType
Field -> Constr
(forall b. Data b => b -> b) -> Field -> Field
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Field -> c Field
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Field
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) -> Field -> u
forall u. (forall d. Data d => d -> u) -> Field -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Field -> m Field
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Field -> m Field
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Field
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Field -> c Field
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Field)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Field)
$cField :: Constr
$tField :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Field -> m Field
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Field -> m Field
gmapMp :: (forall d. Data d => d -> m d) -> Field -> m Field
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Field -> m Field
gmapM :: (forall d. Data d => d -> m d) -> Field -> m Field
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Field -> m Field
gmapQi :: Int -> (forall d. Data d => d -> u) -> Field -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Field -> u
gmapQ :: (forall d. Data d => d -> u) -> Field -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Field -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Field -> r
gmapT :: (forall b. Data b => b -> b) -> Field -> Field
$cgmapT :: (forall b. Data b => b -> b) -> Field -> Field
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Field)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Field)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Field)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Field)
dataTypeOf :: Field -> DataType
$cdataTypeOf :: Field -> DataType
toConstr :: Field -> Constr
$ctoConstr :: Field -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Field
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Field
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Field -> c Field
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Field -> c Field
$cp1Data :: Typeable Field
Data,Typeable,Eq Field
Eq Field
-> (Field -> Field -> Ordering)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Bool)
-> (Field -> Field -> Field)
-> (Field -> Field -> Field)
-> Ord Field
Field -> Field -> Bool
Field -> Field -> Ordering
Field -> Field -> Field
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
min :: Field -> Field -> Field
$cmin :: Field -> Field -> Field
max :: Field -> Field -> Field
$cmax :: Field -> Field -> Field
>= :: Field -> Field -> Bool
$c>= :: Field -> Field -> Bool
> :: Field -> Field -> Bool
$c> :: Field -> Field -> Bool
<= :: Field -> Field -> Bool
$c<= :: Field -> Field -> Bool
< :: Field -> Field -> Bool
$c< :: Field -> Field -> Bool
compare :: Field -> Field -> Ordering
$ccompare :: Field -> Field -> Ordering
$cp1Ord :: Eq Field
Ord)

instance Show Field where
    show :: Field -> String
show (Field QN
n Type
t Cardinality
c FieldEmit
x Int
i) =
        String
"Field {_fieldName = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ QN -> String
forall a. Show a => a -> String
show QN
n String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
",_fieldType = {_typeName = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Name -> String
forall a. Show a => a -> String
show (Type -> Name
_typeName Type
t) String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
"},_fieldCardinality = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Cardinality -> String
forall a. Show a => a -> String
show Cardinality
c String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
",_fieldXmlEmit = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ FieldEmit -> String
forall a. Show a => a -> String
show FieldEmit
x String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
",_fieldIdx = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i String -> ShowS
forall a. [a] -> [a] -> [a]
++
                    String
"}"

-- | Datatype constructor.
data Ctor = Ctor {
      Ctor -> String
_ctorName :: String
    , Ctor -> [Field]
_ctorFields :: [Field]
    } deriving (Ctor -> Ctor -> Bool
(Ctor -> Ctor -> Bool) -> (Ctor -> Ctor -> Bool) -> Eq Ctor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ctor -> Ctor -> Bool
$c/= :: Ctor -> Ctor -> Bool
== :: Ctor -> Ctor -> Bool
$c== :: Ctor -> Ctor -> Bool
Eq,Int -> Ctor -> ShowS
[Ctor] -> ShowS
Ctor -> String
(Int -> Ctor -> ShowS)
-> (Ctor -> String) -> ([Ctor] -> ShowS) -> Show Ctor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ctor] -> ShowS
$cshowList :: [Ctor] -> ShowS
show :: Ctor -> String
$cshow :: Ctor -> String
showsPrec :: Int -> Ctor -> ShowS
$cshowsPrec :: Int -> Ctor -> ShowS
Show,Typeable Ctor
DataType
Constr
Typeable Ctor
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Ctor -> c Ctor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Ctor)
-> (Ctor -> Constr)
-> (Ctor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Ctor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ctor))
-> ((forall b. Data b => b -> b) -> Ctor -> Ctor)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ctor -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ctor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ctor -> m Ctor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ctor -> m Ctor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ctor -> m Ctor)
-> Data Ctor
Ctor -> DataType
Ctor -> Constr
(forall b. Data b => b -> b) -> Ctor -> Ctor
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctor -> c Ctor
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ctor
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) -> Ctor -> u
forall u. (forall d. Data d => d -> u) -> Ctor -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ctor -> m Ctor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ctor -> m Ctor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ctor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctor -> c Ctor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ctor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ctor)
$cCtor :: Constr
$tCtor :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Ctor -> m Ctor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ctor -> m Ctor
gmapMp :: (forall d. Data d => d -> m d) -> Ctor -> m Ctor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ctor -> m Ctor
gmapM :: (forall d. Data d => d -> m d) -> Ctor -> m Ctor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ctor -> m Ctor
gmapQi :: Int -> (forall d. Data d => d -> u) -> Ctor -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ctor -> u
gmapQ :: (forall d. Data d => d -> u) -> Ctor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Ctor -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ctor -> r
gmapT :: (forall b. Data b => b -> b) -> Ctor -> Ctor
$cgmapT :: (forall b. Data b => b -> b) -> Ctor -> Ctor
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ctor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ctor)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Ctor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ctor)
dataTypeOf :: Ctor -> DataType
$cdataTypeOf :: Ctor -> DataType
toConstr :: Ctor -> Constr
$ctoConstr :: Ctor -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ctor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ctor
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctor -> c Ctor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ctor -> c Ctor
$cp1Data :: Typeable Ctor
Data,Typeable,Eq Ctor
Eq Ctor
-> (Ctor -> Ctor -> Ordering)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Ctor)
-> (Ctor -> Ctor -> Ctor)
-> Ord Ctor
Ctor -> Ctor -> Bool
Ctor -> Ctor -> Ordering
Ctor -> Ctor -> Ctor
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
min :: Ctor -> Ctor -> Ctor
$cmin :: Ctor -> Ctor -> Ctor
max :: Ctor -> Ctor -> Ctor
$cmax :: Ctor -> Ctor -> Ctor
>= :: Ctor -> Ctor -> Bool
$c>= :: Ctor -> Ctor -> Bool
> :: Ctor -> Ctor -> Bool
$c> :: Ctor -> Ctor -> Bool
<= :: Ctor -> Ctor -> Bool
$c<= :: Ctor -> Ctor -> Bool
< :: Ctor -> Ctor -> Bool
$c< :: Ctor -> Ctor -> Bool
compare :: Ctor -> Ctor -> Ordering
$ccompare :: Ctor -> Ctor -> Ordering
$cp1Ord :: Eq Ctor
Ord)

-- | Derive type "families".
data DerivesFamily =
    NewTypeString |
    NewTypeIntegral |
    NewTypeNum |
    DataEnum |
    OtherDerives
    deriving (DerivesFamily -> DerivesFamily -> Bool
(DerivesFamily -> DerivesFamily -> Bool)
-> (DerivesFamily -> DerivesFamily -> Bool) -> Eq DerivesFamily
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DerivesFamily -> DerivesFamily -> Bool
$c/= :: DerivesFamily -> DerivesFamily -> Bool
== :: DerivesFamily -> DerivesFamily -> Bool
$c== :: DerivesFamily -> DerivesFamily -> Bool
Eq,Int -> DerivesFamily -> ShowS
[DerivesFamily] -> ShowS
DerivesFamily -> String
(Int -> DerivesFamily -> ShowS)
-> (DerivesFamily -> String)
-> ([DerivesFamily] -> ShowS)
-> Show DerivesFamily
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DerivesFamily] -> ShowS
$cshowList :: [DerivesFamily] -> ShowS
show :: DerivesFamily -> String
$cshow :: DerivesFamily -> String
showsPrec :: Int -> DerivesFamily -> ShowS
$cshowsPrec :: Int -> DerivesFamily -> ShowS
Show,Typeable DerivesFamily
DataType
Constr
Typeable DerivesFamily
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivesFamily -> c DerivesFamily)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivesFamily)
-> (DerivesFamily -> Constr)
-> (DerivesFamily -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivesFamily))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivesFamily))
-> ((forall b. Data b => b -> b) -> DerivesFamily -> DerivesFamily)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r)
-> (forall u. (forall d. Data d => d -> u) -> DerivesFamily -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DerivesFamily -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily)
-> Data DerivesFamily
DerivesFamily -> DataType
DerivesFamily -> Constr
(forall b. Data b => b -> b) -> DerivesFamily -> DerivesFamily
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivesFamily -> c DerivesFamily
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivesFamily
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) -> DerivesFamily -> u
forall u. (forall d. Data d => d -> u) -> DerivesFamily -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivesFamily
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivesFamily -> c DerivesFamily
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivesFamily)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivesFamily)
$cOtherDerives :: Constr
$cDataEnum :: Constr
$cNewTypeNum :: Constr
$cNewTypeIntegral :: Constr
$cNewTypeString :: Constr
$tDerivesFamily :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
gmapMp :: (forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
gmapM :: (forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DerivesFamily -> m DerivesFamily
gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivesFamily -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DerivesFamily -> u
gmapQ :: (forall d. Data d => d -> u) -> DerivesFamily -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivesFamily -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivesFamily -> r
gmapT :: (forall b. Data b => b -> b) -> DerivesFamily -> DerivesFamily
$cgmapT :: (forall b. Data b => b -> b) -> DerivesFamily -> DerivesFamily
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivesFamily)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivesFamily)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DerivesFamily)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivesFamily)
dataTypeOf :: DerivesFamily -> DataType
$cdataTypeOf :: DerivesFamily -> DataType
toConstr :: DerivesFamily -> Constr
$ctoConstr :: DerivesFamily -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivesFamily
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivesFamily
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivesFamily -> c DerivesFamily
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivesFamily -> c DerivesFamily
$cp1Data :: Typeable DerivesFamily
Data,Typeable,Eq DerivesFamily
Eq DerivesFamily
-> (DerivesFamily -> DerivesFamily -> Ordering)
-> (DerivesFamily -> DerivesFamily -> Bool)
-> (DerivesFamily -> DerivesFamily -> Bool)
-> (DerivesFamily -> DerivesFamily -> Bool)
-> (DerivesFamily -> DerivesFamily -> Bool)
-> (DerivesFamily -> DerivesFamily -> DerivesFamily)
-> (DerivesFamily -> DerivesFamily -> DerivesFamily)
-> Ord DerivesFamily
DerivesFamily -> DerivesFamily -> Bool
DerivesFamily -> DerivesFamily -> Ordering
DerivesFamily -> DerivesFamily -> DerivesFamily
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
min :: DerivesFamily -> DerivesFamily -> DerivesFamily
$cmin :: DerivesFamily -> DerivesFamily -> DerivesFamily
max :: DerivesFamily -> DerivesFamily -> DerivesFamily
$cmax :: DerivesFamily -> DerivesFamily -> DerivesFamily
>= :: DerivesFamily -> DerivesFamily -> Bool
$c>= :: DerivesFamily -> DerivesFamily -> Bool
> :: DerivesFamily -> DerivesFamily -> Bool
$c> :: DerivesFamily -> DerivesFamily -> Bool
<= :: DerivesFamily -> DerivesFamily -> Bool
$c<= :: DerivesFamily -> DerivesFamily -> Bool
< :: DerivesFamily -> DerivesFamily -> Bool
$c< :: DerivesFamily -> DerivesFamily -> Bool
compare :: DerivesFamily -> DerivesFamily -> Ordering
$ccompare :: DerivesFamily -> DerivesFamily -> Ordering
$cp1Ord :: Eq DerivesFamily
Ord,Int -> DerivesFamily
DerivesFamily -> Int
DerivesFamily -> [DerivesFamily]
DerivesFamily -> DerivesFamily
DerivesFamily -> DerivesFamily -> [DerivesFamily]
DerivesFamily -> DerivesFamily -> DerivesFamily -> [DerivesFamily]
(DerivesFamily -> DerivesFamily)
-> (DerivesFamily -> DerivesFamily)
-> (Int -> DerivesFamily)
-> (DerivesFamily -> Int)
-> (DerivesFamily -> [DerivesFamily])
-> (DerivesFamily -> DerivesFamily -> [DerivesFamily])
-> (DerivesFamily -> DerivesFamily -> [DerivesFamily])
-> (DerivesFamily
    -> DerivesFamily -> DerivesFamily -> [DerivesFamily])
-> Enum DerivesFamily
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: DerivesFamily -> DerivesFamily -> DerivesFamily -> [DerivesFamily]
$cenumFromThenTo :: DerivesFamily -> DerivesFamily -> DerivesFamily -> [DerivesFamily]
enumFromTo :: DerivesFamily -> DerivesFamily -> [DerivesFamily]
$cenumFromTo :: DerivesFamily -> DerivesFamily -> [DerivesFamily]
enumFromThen :: DerivesFamily -> DerivesFamily -> [DerivesFamily]
$cenumFromThen :: DerivesFamily -> DerivesFamily -> [DerivesFamily]
enumFrom :: DerivesFamily -> [DerivesFamily]
$cenumFrom :: DerivesFamily -> [DerivesFamily]
fromEnum :: DerivesFamily -> Int
$cfromEnum :: DerivesFamily -> Int
toEnum :: Int -> DerivesFamily
$ctoEnum :: Int -> DerivesFamily
pred :: DerivesFamily -> DerivesFamily
$cpred :: DerivesFamily -> DerivesFamily
succ :: DerivesFamily -> DerivesFamily
$csucc :: DerivesFamily -> DerivesFamily
Enum,DerivesFamily
DerivesFamily -> DerivesFamily -> Bounded DerivesFamily
forall a. a -> a -> Bounded a
maxBound :: DerivesFamily
$cmaxBound :: DerivesFamily
minBound :: DerivesFamily
$cminBound :: DerivesFamily
Bounded)

-- | "Impl"s of classes, but also grab-bag of type deets.
data Impl =
    -- | Specifies min and max values
    Bounds (Maybe (Bound String), Maybe (Bound String)) |
    -- | Specifies string pattern
    Pattern String |
    -- | Implement 'Show' for newtype
    NewTypeShow |
    -- | Top-level element, so emit element name as well as contents.
    -- Elements normally inherit the name from the referencing production.
    TopLevel
            deriving (Impl -> Impl -> Bool
(Impl -> Impl -> Bool) -> (Impl -> Impl -> Bool) -> Eq Impl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Impl -> Impl -> Bool
$c/= :: Impl -> Impl -> Bool
== :: Impl -> Impl -> Bool
$c== :: Impl -> Impl -> Bool
Eq,Int -> Impl -> ShowS
[Impl] -> ShowS
Impl -> String
(Int -> Impl -> ShowS)
-> (Impl -> String) -> ([Impl] -> ShowS) -> Show Impl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Impl] -> ShowS
$cshowList :: [Impl] -> ShowS
show :: Impl -> String
$cshow :: Impl -> String
showsPrec :: Int -> Impl -> ShowS
$cshowsPrec :: Int -> Impl -> ShowS
Show,Typeable Impl
DataType
Constr
Typeable Impl
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Impl -> c Impl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Impl)
-> (Impl -> Constr)
-> (Impl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Impl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Impl))
-> ((forall b. Data b => b -> b) -> Impl -> Impl)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r)
-> (forall u. (forall d. Data d => d -> u) -> Impl -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Impl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Impl -> m Impl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Impl -> m Impl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Impl -> m Impl)
-> Data Impl
Impl -> DataType
Impl -> Constr
(forall b. Data b => b -> b) -> Impl -> Impl
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Impl -> c Impl
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Impl
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) -> Impl -> u
forall u. (forall d. Data d => d -> u) -> Impl -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Impl -> m Impl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Impl -> m Impl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Impl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Impl -> c Impl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Impl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Impl)
$cTopLevel :: Constr
$cNewTypeShow :: Constr
$cPattern :: Constr
$cBounds :: Constr
$tImpl :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Impl -> m Impl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Impl -> m Impl
gmapMp :: (forall d. Data d => d -> m d) -> Impl -> m Impl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Impl -> m Impl
gmapM :: (forall d. Data d => d -> m d) -> Impl -> m Impl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Impl -> m Impl
gmapQi :: Int -> (forall d. Data d => d -> u) -> Impl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Impl -> u
gmapQ :: (forall d. Data d => d -> u) -> Impl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Impl -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Impl -> r
gmapT :: (forall b. Data b => b -> b) -> Impl -> Impl
$cgmapT :: (forall b. Data b => b -> b) -> Impl -> Impl
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Impl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Impl)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Impl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Impl)
dataTypeOf :: Impl -> DataType
$cdataTypeOf :: Impl -> DataType
toConstr :: Impl -> Constr
$ctoConstr :: Impl -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Impl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Impl
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Impl -> c Impl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Impl -> c Impl
$cp1Data :: Typeable Impl
Data,Typeable,Eq Impl
Eq Impl
-> (Impl -> Impl -> Ordering)
-> (Impl -> Impl -> Bool)
-> (Impl -> Impl -> Bool)
-> (Impl -> Impl -> Bool)
-> (Impl -> Impl -> Bool)
-> (Impl -> Impl -> Impl)
-> (Impl -> Impl -> Impl)
-> Ord Impl
Impl -> Impl -> Bool
Impl -> Impl -> Ordering
Impl -> Impl -> Impl
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
min :: Impl -> Impl -> Impl
$cmin :: Impl -> Impl -> Impl
max :: Impl -> Impl -> Impl
$cmax :: Impl -> Impl -> Impl
>= :: Impl -> Impl -> Bool
$c>= :: Impl -> Impl -> Bool
> :: Impl -> Impl -> Bool
$c> :: Impl -> Impl -> Bool
<= :: Impl -> Impl -> Bool
$c<= :: Impl -> Impl -> Bool
< :: Impl -> Impl -> Bool
$c< :: Impl -> Impl -> Bool
compare :: Impl -> Impl -> Ordering
$ccompare :: Impl -> Impl -> Ordering
$cp1Ord :: Eq Impl
Ord)

-- | newtype base types. Name after CT should be Haskell base type.
data CoreType =
    CTString |
    CTDecimal |
    CTFloat |
    CTDouble |
    CTInt |
    CTBool
    deriving (CoreType -> CoreType -> Bool
(CoreType -> CoreType -> Bool)
-> (CoreType -> CoreType -> Bool) -> Eq CoreType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CoreType -> CoreType -> Bool
$c/= :: CoreType -> CoreType -> Bool
== :: CoreType -> CoreType -> Bool
$c== :: CoreType -> CoreType -> Bool
Eq,Int -> CoreType -> ShowS
[CoreType] -> ShowS
CoreType -> String
(Int -> CoreType -> ShowS)
-> (CoreType -> String) -> ([CoreType] -> ShowS) -> Show CoreType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CoreType] -> ShowS
$cshowList :: [CoreType] -> ShowS
show :: CoreType -> String
$cshow :: CoreType -> String
showsPrec :: Int -> CoreType -> ShowS
$cshowsPrec :: Int -> CoreType -> ShowS
Show,Typeable CoreType
DataType
Constr
Typeable CoreType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CoreType -> c CoreType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CoreType)
-> (CoreType -> Constr)
-> (CoreType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CoreType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CoreType))
-> ((forall b. Data b => b -> b) -> CoreType -> CoreType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CoreType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CoreType -> r)
-> (forall u. (forall d. Data d => d -> u) -> CoreType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CoreType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CoreType -> m CoreType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CoreType -> m CoreType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CoreType -> m CoreType)
-> Data CoreType
CoreType -> DataType
CoreType -> Constr
(forall b. Data b => b -> b) -> CoreType -> CoreType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CoreType -> c CoreType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CoreType
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) -> CoreType -> u
forall u. (forall d. Data d => d -> u) -> CoreType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CoreType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CoreType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CoreType -> m CoreType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CoreType -> m CoreType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CoreType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CoreType -> c CoreType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CoreType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CoreType)
$cCTBool :: Constr
$cCTInt :: Constr
$cCTDouble :: Constr
$cCTFloat :: Constr
$cCTDecimal :: Constr
$cCTString :: Constr
$tCoreType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CoreType -> m CoreType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CoreType -> m CoreType
gmapMp :: (forall d. Data d => d -> m d) -> CoreType -> m CoreType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CoreType -> m CoreType
gmapM :: (forall d. Data d => d -> m d) -> CoreType -> m CoreType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CoreType -> m CoreType
gmapQi :: Int -> (forall d. Data d => d -> u) -> CoreType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CoreType -> u
gmapQ :: (forall d. Data d => d -> u) -> CoreType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CoreType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CoreType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CoreType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CoreType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CoreType -> r
gmapT :: (forall b. Data b => b -> b) -> CoreType -> CoreType
$cgmapT :: (forall b. Data b => b -> b) -> CoreType -> CoreType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CoreType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CoreType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CoreType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CoreType)
dataTypeOf :: CoreType -> DataType
$cdataTypeOf :: CoreType -> DataType
toConstr :: CoreType -> Constr
$ctoConstr :: CoreType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CoreType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CoreType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CoreType -> c CoreType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CoreType -> c CoreType
$cp1Data :: Typeable CoreType
Data,Typeable,Eq CoreType
Eq CoreType
-> (CoreType -> CoreType -> Ordering)
-> (CoreType -> CoreType -> Bool)
-> (CoreType -> CoreType -> Bool)
-> (CoreType -> CoreType -> Bool)
-> (CoreType -> CoreType -> Bool)
-> (CoreType -> CoreType -> CoreType)
-> (CoreType -> CoreType -> CoreType)
-> Ord CoreType
CoreType -> CoreType -> Bool
CoreType -> CoreType -> Ordering
CoreType -> CoreType -> CoreType
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
min :: CoreType -> CoreType -> CoreType
$cmin :: CoreType -> CoreType -> CoreType
max :: CoreType -> CoreType -> CoreType
$cmax :: CoreType -> CoreType -> CoreType
>= :: CoreType -> CoreType -> Bool
$c>= :: CoreType -> CoreType -> Bool
> :: CoreType -> CoreType -> Bool
$c> :: CoreType -> CoreType -> Bool
<= :: CoreType -> CoreType -> Bool
$c<= :: CoreType -> CoreType -> Bool
< :: CoreType -> CoreType -> Bool
$c< :: CoreType -> CoreType -> Bool
compare :: CoreType -> CoreType -> Ordering
$ccompare :: CoreType -> CoreType -> Ordering
$cp1Ord :: Eq CoreType
Ord,Int -> CoreType
CoreType -> Int
CoreType -> [CoreType]
CoreType -> CoreType
CoreType -> CoreType -> [CoreType]
CoreType -> CoreType -> CoreType -> [CoreType]
(CoreType -> CoreType)
-> (CoreType -> CoreType)
-> (Int -> CoreType)
-> (CoreType -> Int)
-> (CoreType -> [CoreType])
-> (CoreType -> CoreType -> [CoreType])
-> (CoreType -> CoreType -> [CoreType])
-> (CoreType -> CoreType -> CoreType -> [CoreType])
-> Enum CoreType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: CoreType -> CoreType -> CoreType -> [CoreType]
$cenumFromThenTo :: CoreType -> CoreType -> CoreType -> [CoreType]
enumFromTo :: CoreType -> CoreType -> [CoreType]
$cenumFromTo :: CoreType -> CoreType -> [CoreType]
enumFromThen :: CoreType -> CoreType -> [CoreType]
$cenumFromThen :: CoreType -> CoreType -> [CoreType]
enumFrom :: CoreType -> [CoreType]
$cenumFrom :: CoreType -> [CoreType]
fromEnum :: CoreType -> Int
$cfromEnum :: CoreType -> Int
toEnum :: Int -> CoreType
$ctoEnum :: Int -> CoreType
pred :: CoreType -> CoreType
$cpred :: CoreType -> CoreType
succ :: CoreType -> CoreType
$csucc :: CoreType -> CoreType
Enum,CoreType
CoreType -> CoreType -> Bounded CoreType
forall a. a -> a -> Bounded a
maxBound :: CoreType
$cmaxBound :: CoreType
minBound :: CoreType
$cminBound :: CoreType
Bounded)

-- | Data type xml emit cue.
data DataTypeEmit =
    DataTypeComplex |
    DataTypeSimple |
    DataTypeCompositor
    deriving (DataTypeEmit -> DataTypeEmit -> Bool
(DataTypeEmit -> DataTypeEmit -> Bool)
-> (DataTypeEmit -> DataTypeEmit -> Bool) -> Eq DataTypeEmit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataTypeEmit -> DataTypeEmit -> Bool
$c/= :: DataTypeEmit -> DataTypeEmit -> Bool
== :: DataTypeEmit -> DataTypeEmit -> Bool
$c== :: DataTypeEmit -> DataTypeEmit -> Bool
Eq,Int -> DataTypeEmit -> ShowS
[DataTypeEmit] -> ShowS
DataTypeEmit -> String
(Int -> DataTypeEmit -> ShowS)
-> (DataTypeEmit -> String)
-> ([DataTypeEmit] -> ShowS)
-> Show DataTypeEmit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataTypeEmit] -> ShowS
$cshowList :: [DataTypeEmit] -> ShowS
show :: DataTypeEmit -> String
$cshow :: DataTypeEmit -> String
showsPrec :: Int -> DataTypeEmit -> ShowS
$cshowsPrec :: Int -> DataTypeEmit -> ShowS
Show,Typeable DataTypeEmit
DataType
Constr
Typeable DataTypeEmit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataTypeEmit -> c DataTypeEmit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataTypeEmit)
-> (DataTypeEmit -> Constr)
-> (DataTypeEmit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataTypeEmit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DataTypeEmit))
-> ((forall b. Data b => b -> b) -> DataTypeEmit -> DataTypeEmit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataTypeEmit -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataTypeEmit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit)
-> Data DataTypeEmit
DataTypeEmit -> DataType
DataTypeEmit -> Constr
(forall b. Data b => b -> b) -> DataTypeEmit -> DataTypeEmit
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataTypeEmit -> c DataTypeEmit
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataTypeEmit
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) -> DataTypeEmit -> u
forall u. (forall d. Data d => d -> u) -> DataTypeEmit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataTypeEmit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataTypeEmit -> c DataTypeEmit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataTypeEmit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataTypeEmit)
$cDataTypeCompositor :: Constr
$cDataTypeSimple :: Constr
$cDataTypeComplex :: Constr
$tDataTypeEmit :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
gmapMp :: (forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
gmapM :: (forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataTypeEmit -> m DataTypeEmit
gmapQi :: Int -> (forall d. Data d => d -> u) -> DataTypeEmit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataTypeEmit -> u
gmapQ :: (forall d. Data d => d -> u) -> DataTypeEmit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataTypeEmit -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataTypeEmit -> r
gmapT :: (forall b. Data b => b -> b) -> DataTypeEmit -> DataTypeEmit
$cgmapT :: (forall b. Data b => b -> b) -> DataTypeEmit -> DataTypeEmit
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataTypeEmit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataTypeEmit)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DataTypeEmit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataTypeEmit)
dataTypeOf :: DataTypeEmit -> DataType
$cdataTypeOf :: DataTypeEmit -> DataType
toConstr :: DataTypeEmit -> Constr
$ctoConstr :: DataTypeEmit -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataTypeEmit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataTypeEmit
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataTypeEmit -> c DataTypeEmit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataTypeEmit -> c DataTypeEmit
$cp1Data :: Typeable DataTypeEmit
Data,Typeable,Eq DataTypeEmit
Eq DataTypeEmit
-> (DataTypeEmit -> DataTypeEmit -> Ordering)
-> (DataTypeEmit -> DataTypeEmit -> Bool)
-> (DataTypeEmit -> DataTypeEmit -> Bool)
-> (DataTypeEmit -> DataTypeEmit -> Bool)
-> (DataTypeEmit -> DataTypeEmit -> Bool)
-> (DataTypeEmit -> DataTypeEmit -> DataTypeEmit)
-> (DataTypeEmit -> DataTypeEmit -> DataTypeEmit)
-> Ord DataTypeEmit
DataTypeEmit -> DataTypeEmit -> Bool
DataTypeEmit -> DataTypeEmit -> Ordering
DataTypeEmit -> DataTypeEmit -> DataTypeEmit
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
min :: DataTypeEmit -> DataTypeEmit -> DataTypeEmit
$cmin :: DataTypeEmit -> DataTypeEmit -> DataTypeEmit
max :: DataTypeEmit -> DataTypeEmit -> DataTypeEmit
$cmax :: DataTypeEmit -> DataTypeEmit -> DataTypeEmit
>= :: DataTypeEmit -> DataTypeEmit -> Bool
$c>= :: DataTypeEmit -> DataTypeEmit -> Bool
> :: DataTypeEmit -> DataTypeEmit -> Bool
$c> :: DataTypeEmit -> DataTypeEmit -> Bool
<= :: DataTypeEmit -> DataTypeEmit -> Bool
$c<= :: DataTypeEmit -> DataTypeEmit -> Bool
< :: DataTypeEmit -> DataTypeEmit -> Bool
$c< :: DataTypeEmit -> DataTypeEmit -> Bool
compare :: DataTypeEmit -> DataTypeEmit -> Ordering
$ccompare :: DataTypeEmit -> DataTypeEmit -> Ordering
$cp1Ord :: Eq DataTypeEmit
Ord)

-- | Emitted type.
data Type =
    NewType {
      Type -> Name
_typeName :: Name
    , Type -> Type
_typeType :: Type
    , Type -> DerivesFamily
_typeDerives :: DerivesFamily
    , Type -> [Impl]
_typeImpls :: [Impl]
    , Type -> Maybe Documentation
_typeDoc :: Maybe Documentation
    } |
    DataType {
      _typeName :: Name
    , Type -> [Ctor]
_typeCtors :: [Ctor]
    , _typeDerives :: DerivesFamily
    , _typeImpls :: [Impl]
    , Type -> DataTypeEmit
_typeEmit :: DataTypeEmit
    , _typeDoc :: Maybe Documentation
    } |
    EnumType {
      _typeName :: Name
    , Type -> [String]
_typeEnumValues :: [String]
    , _typeDerives :: DerivesFamily
    , _typeImpls :: [Impl]
    , _typeDoc :: Maybe Documentation
    } |
    BuiltIn {
      _typeName :: Name
    , Type -> CoreType
_coreType :: CoreType
    , _typeDerives :: DerivesFamily
    , _typeImpls :: [Impl]
    } deriving (Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c== :: Type -> Type -> Bool
Eq,Int -> Type -> ShowS
[Type] -> ShowS
Type -> String
(Int -> Type -> ShowS)
-> (Type -> String) -> ([Type] -> ShowS) -> Show Type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Type] -> ShowS
$cshowList :: [Type] -> ShowS
show :: Type -> String
$cshow :: Type -> String
showsPrec :: Int -> Type -> ShowS
$cshowsPrec :: Int -> Type -> ShowS
Show,Typeable Type
DataType
Constr
Typeable Type
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type -> c Type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Type)
-> (Type -> Constr)
-> (Type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type))
-> ((forall b. Data b => b -> b) -> Type -> Type)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> Data Type
Type -> DataType
Type -> Constr
(forall b. Data b => b -> b) -> Type -> Type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
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) -> Type -> u
forall u. (forall d. Data d => d -> u) -> Type -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cBuiltIn :: Constr
$cEnumType :: Constr
$cDataType :: Constr
$cNewType :: Constr
$tType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapMp :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapM :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapT :: (forall b. Data b => b -> b) -> Type -> Type
$cgmapT :: (forall b. Data b => b -> b) -> Type -> Type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
dataTypeOf :: Type -> DataType
$cdataTypeOf :: Type -> DataType
toConstr :: Type -> Constr
$ctoConstr :: Type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cp1Data :: Typeable Type
Data,Typeable,Eq Type
Eq Type
-> (Type -> Type -> Ordering)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Type)
-> (Type -> Type -> Type)
-> Ord Type
Type -> Type -> Bool
Type -> Type -> Ordering
Type -> Type -> Type
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
min :: Type -> Type -> Type
$cmin :: Type -> Type -> Type
max :: Type -> Type -> Type
$cmax :: Type -> Type -> Type
>= :: Type -> Type -> Bool
$c>= :: Type -> Type -> Bool
> :: Type -> Type -> Bool
$c> :: Type -> Type -> Bool
<= :: Type -> Type -> Bool
$c<= :: Type -> Type -> Bool
< :: Type -> Type -> Bool
$c< :: Type -> Type -> Bool
compare :: Type -> Type -> Ordering
$ccompare :: Type -> Type -> Ordering
$cp1Ord :: Eq Type
Ord)

$(makeLenses ''Type)
$(makeLenses ''Ctor)
$(makeLenses ''Field)


-- | Reader environment.
data Env = Env {
      Env -> Schema
_schema :: Schema
}
$(makeLenses ''Env)

-- | State data.
data EmitState = EmitState { EmitState -> Map Name Type
_types :: M.Map Name Type, EmitState -> [Name]
_stack :: [Name] }
$(makeLenses ''EmitState)
instance Semigroup EmitState where
  (EmitState Map Name Type
a [Name]
b) <> :: EmitState -> EmitState -> EmitState
<> (EmitState Map Name Type
c [Name]
d) = Map Name Type -> [Name] -> EmitState
EmitState (Map Name Type
aMap Name Type -> Map Name Type -> Map Name Type
forall a. Semigroup a => a -> a -> a
<>Map Name Type
c) ([Name]
b[Name] -> [Name] -> [Name]
forall a. Semigroup a => a -> a -> a
<>[Name]
d)
instance Monoid EmitState where
    mempty :: EmitState
mempty = Map Name Type -> [Name] -> EmitState
EmitState Map Name Type
forall a. Monoid a => a
mempty [Name]
forall a. Monoid a => a
mempty
    mappend :: EmitState -> EmitState -> EmitState
mappend = EmitState -> EmitState -> EmitState
forall a. Semigroup a => a -> a -> a
(<>)


-- | Emit monad.
type Emit a = ReaderT Env (StateT EmitState IO) a

-- | Run emit monad.
runEmit :: Env -> EmitState -> Emit a -> IO (a, EmitState)
runEmit :: Env -> EmitState -> Emit a -> IO (a, EmitState)
runEmit Env
env EmitState
st Emit a
act = StateT EmitState IO a -> EmitState -> IO (a, EmitState)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (Emit a -> Env -> StateT EmitState IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Emit a
act Env
env) EmitState
st

-- | Emit schema types. Starts with element productions
-- and emits all dependent types.
emitSchema :: Schema -> Emit ()
emitSchema :: Schema -> Emit ()
emitSchema Schema
s = do
  [QN]
els <- Map QN Type -> [QN]
forall k a. Map k a -> [k]
M.keys (Map QN Type -> [QN])
-> ReaderT Env (StateT EmitState IO) (Map QN Type)
-> ReaderT Env (StateT EmitState IO) [QN]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Element -> ReaderT Env (StateT EmitState IO) Type)
-> Map QN Element
-> ReaderT Env (StateT EmitState IO) (Map QN Type)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Element -> ReaderT Env (StateT EmitState IO) Type
emitElement (Schema -> Map QN Element
_elements Schema
s)
  (Map Name Type -> Identity (Map Name Type))
-> EmitState -> Identity EmitState
Lens' EmitState (Map Name Type)
types ((Map Name Type -> Identity (Map Name Type))
 -> EmitState -> Identity EmitState)
-> (Map Name Type -> Map Name Type) -> Emit ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Name -> Type -> Type) -> Map Name Type -> Map Name Type
forall k a b. (k -> a -> b) -> Map k a -> Map k b
M.mapWithKey
            (\Name
k Type
v -> if Name -> QN
nName Name
k QN -> [QN] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [QN]
els
                     then ASetter Type Type [Impl] [Impl]
-> ([Impl] -> [Impl]) -> Type -> Type
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter Type Type [Impl] [Impl]
Lens' Type [Impl]
typeImpls (Impl
TopLevelImpl -> [Impl] -> [Impl]
forall a. a -> [a] -> [a]
:) Type
v
                     else Type
v)

-- | String builtin.
builtInString :: Type
builtInString :: Type
builtInString = String -> CoreType -> DerivesFamily -> Type
mkBuiltIn String
"string" CoreType
CTString DerivesFamily
NewTypeString

-- | All built-in types.
builtIns :: M.Map QN Type
builtIns :: Map QN Type
builtIns = (Type -> Map QN Type -> Map QN Type)
-> Map QN Type -> [Type] -> Map QN Type
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\Type
b -> QN -> Type -> Map QN Type -> Map QN Type
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert (Name -> QN
nName (Type -> Name
_typeName Type
b)) Type
b) Map QN Type
forall a. Monoid a => a
mempty
           [Type
builtInInteger,Type
builtInDecimal,Type
builtInDouble,
            Type
builtInFloat,Type
builtInBoolean,Type
builtInString]
    where
      builtInInteger :: Type
builtInInteger = String -> CoreType -> DerivesFamily -> Type
mkBuiltIn String
"integer" CoreType
CTInt DerivesFamily
NewTypeIntegral
      builtInDecimal :: Type
builtInDecimal = String -> CoreType -> DerivesFamily -> Type
mkBuiltIn String
"decimal" CoreType
CTDecimal DerivesFamily
NewTypeNum
      builtInFloat :: Type
builtInFloat = String -> CoreType -> DerivesFamily -> Type
mkBuiltIn String
"float" CoreType
CTFloat DerivesFamily
NewTypeNum
      builtInDouble :: Type
builtInDouble = String -> CoreType -> DerivesFamily -> Type
mkBuiltIn String
"double" CoreType
CTDouble DerivesFamily
NewTypeNum
      builtInBoolean :: Type
builtInBoolean = String -> CoreType -> DerivesFamily -> Type
mkBuiltIn String
"boolean" CoreType
CTBool DerivesFamily
OtherDerives

-- | Smart ctor for built-in types.
mkBuiltIn :: String -> CoreType -> DerivesFamily -> Type
mkBuiltIn :: String -> CoreType -> DerivesFamily -> Type
mkBuiltIn String
n CoreType
ct DerivesFamily
df = Name -> CoreType -> DerivesFamily -> [Impl] -> Type
BuiltIn (Namespace -> QN -> Int -> Name
Name Namespace
NSBuiltIn (String -> Maybe String -> QN
QN String
n (String -> Maybe String
forall a. a -> Maybe a
Just String
"xs")) Int
0) CoreType
ct DerivesFamily
df [Impl
NewTypeShow]


-- | Emit type for element content; element name production
-- captured in containing field.
emitElement :: Element -> Emit Type
emitElement :: Element -> ReaderT Env (StateT EmitState IO) Type
emitElement (ElementType QN
_ Ref (Either ComplexType SimpleType)
t Occurs
_ Maybe Documentation
doc) = do
  Either ComplexType SimpleType
rt <- Ref (Either ComplexType SimpleType)
-> Emit (Either ComplexType SimpleType)
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref (Either ComplexType SimpleType)
t
  case Either ComplexType SimpleType
rt of
    Left ComplexType
ct -> Maybe QN -> ComplexType -> ReaderT Env (StateT EmitState IO) Type
emitComplexType Maybe QN
forall a. Maybe a
Nothing ComplexType
ct
    Right SimpleType
st -> SimpleType -> ReaderT Env (StateT EmitState IO) Type
emitSimpleType SimpleType
st
emitElement (ElementComplex QN
n ComplexType
c Occurs
_ Maybe Documentation
doc) = Maybe QN -> ComplexType -> ReaderT Env (StateT EmitState IO) Type
emitComplexType (QN -> Maybe QN
forall a. a -> Maybe a
Just QN
n) ComplexType
c
emitElement (ElementRef {}) = String -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. MonadIO m => String -> m a
die String
"ElementRef unsupported"
emitElement (ElementSimple {}) = String -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. MonadIO m => String -> m a
die String
"ElementSimple unsupported"

-- | Error out in IO.
die :: MonadIO m => String -> m a
die :: String -> m a
die = IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> (String -> IO a) -> String -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IOError -> IO a
forall e a. Exception e => e -> IO a
throwIO (IOError -> IO a) -> (String -> IOError) -> String -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IOError
userError


-- | Resolve a ref and obtain the resolved value.
resolvedRef :: (Resolvable (Ref a)) => Ref a -> Emit a
resolvedRef :: Ref a -> Emit a
resolvedRef Ref a
r = do
  Schema
s <- Getting Schema Env Schema
-> ReaderT Env (StateT EmitState IO) Schema
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Schema Env Schema
Iso' Env Schema
schema
  case Getting (Leftmost a) (Ref a) a -> Ref a -> Maybe a
forall a s. Getting (Leftmost a) s a -> s -> Maybe a
firstOf Getting (Leftmost a) (Ref a) a
forall a1 a2. Traversal (Ref a1) (Ref a2) a1 a2
refvalue (Schema -> Ref a -> Ref a
forall a. Resolvable a => Schema -> a -> a
resolve Schema
s Ref a
r) of
    Just a
a -> a -> Emit a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a
    Maybe a
Nothing -> String -> Emit a
forall (m :: * -> *) a. MonadIO m => String -> m a
die (String -> Emit a) -> String -> Emit a
forall a b. (a -> b) -> a -> b
$ String
"resolvedRef: resolve failed on " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Ref a -> String
forall a. Show a => a -> String
show Ref a
r


-- | Handle simpleType production.
emitSimpleType :: SimpleType -> Emit Type
emitSimpleType :: SimpleType -> ReaderT Env (StateT EmitState IO) Type
emitSimpleType SimpleType
t =
    case Getting (Maybe QN) SimpleType (Maybe QN) -> SimpleType -> Maybe QN
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe QN) SimpleType (Maybe QN)
Lens' SimpleType (Maybe QN)
simpleTypeName SimpleType
t of
      Maybe QN
Nothing -> Getting [Name] EmitState [Name]
-> ReaderT Env (StateT EmitState IO) [Name]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting [Name] EmitState [Name]
Lens' EmitState [Name]
stack ReaderT Env (StateT EmitState IO) [Name]
-> ([Name] -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Name]
s -> String -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. MonadIO m => String -> m a
die (String -> ReaderT Env (StateT EmitState IO) Type)
-> String -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ String
"emitSimpleType: anon type: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ SimpleType -> String
forall a. Show a => a -> String
show SimpleType
t String -> ShowS
forall a. [a] -> [a] -> [a]
++
                 String
", stack: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Name] -> String
forall a. Show a => a -> String
show [Name]
s
      Just QN
stn -> do
          Maybe Type
bt <- SimpleType -> Emit (Maybe Type)
tryBuiltIn SimpleType
t
          ReaderT Env (StateT EmitState IO) Type
-> (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Maybe Type
-> ReaderT Env (StateT EmitState IO) Type
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Namespace
-> QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkDefinedType Namespace
NSSimple QN
stn ((Name -> ReaderT Env (StateT EmitState IO) Type)
 -> ReaderT Env (StateT EmitState IO) Type)
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ SimpleType -> Name -> ReaderT Env (StateT EmitState IO) Type
doSimpleType SimpleType
t) Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Type
bt

doSimpleType :: SimpleType -> Name -> Emit Type
doSimpleType :: SimpleType -> Name -> ReaderT Env (StateT EmitState IO) Type
doSimpleType (SimpleTypeRestrict Maybe QN
_ (SimpleRestriction Ref SimpleType
base [String]
enumz Maybe (Bound String)
mins Maybe (Bound String)
maxs Maybe String
patt) Maybe Documentation
doc) Name
n = do
  SimpleType
bt <- Ref SimpleType -> Emit SimpleType
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref SimpleType
base
  if Bool -> Bool
not ([String] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
enumz)
  then SimpleType
-> Name
-> [String]
-> Maybe Documentation
-> ReaderT Env (StateT EmitState IO) Type
emitEnum SimpleType
bt Name
n [String]
enumz Maybe Documentation
doc
  else do
    Type
btt <- SimpleType -> ReaderT Env (StateT EmitState IO) Type
emitSimpleType SimpleType
bt
    Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Name
-> Type -> DerivesFamily -> [Impl] -> Maybe Documentation -> Type
NewType Name
n Type
btt (Type -> DerivesFamily
_typeDerives Type
btt)
           ([(Maybe (Bound String), Maybe (Bound String)) -> Impl
Bounds (Maybe (Bound String)
mins,Maybe (Bound String)
maxs) | Maybe (Bound String) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Bound String)
mins Bool -> Bool -> Bool
|| Maybe (Bound String) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Bound String)
maxs] [Impl] -> [Impl] -> [Impl]
forall a. [a] -> [a] -> [a]
++
            [Impl] -> (String -> [Impl]) -> Maybe String -> [Impl]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (Impl -> [Impl]
forall (m :: * -> *) a. Monad m => a -> m a
return(Impl -> [Impl]) -> (String -> Impl) -> String -> [Impl]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.String -> Impl
Pattern) Maybe String
patt [Impl] -> [Impl] -> [Impl]
forall a. [a] -> [a] -> [a]
++
            Type -> [Impl]
_typeImpls Type
btt) Maybe Documentation
doc
doSimpleType (SimpleTypeUnion Maybe QN
_ (Union [Ref SimpleType]
refs [SimpleType]
sts) Maybe Documentation
doc) Name
n = do
  [SimpleType]
rts <- (Ref SimpleType -> Emit SimpleType)
-> [Ref SimpleType]
-> ReaderT Env (StateT EmitState IO) [SimpleType]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Ref SimpleType -> Emit SimpleType
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef [Ref SimpleType]
refs
  [Type]
rtts <- (SimpleType -> ReaderT Env (StateT EmitState IO) Type)
-> [SimpleType] -> ReaderT Env (StateT EmitState IO) [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM SimpleType -> ReaderT Env (StateT EmitState IO) Type
emitSimpleType [SimpleType]
rts
  let doAnon :: SimpleType -> ReaderT Env (StateT EmitState IO) Type
doAnon SimpleType
t = Namespace
-> Maybe QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkUniqueType Namespace
NSUnion Maybe QN
forall a. Maybe a
Nothing (SimpleType -> Name -> ReaderT Env (StateT EmitState IO) Type
doSimpleType SimpleType
t)
  [Type]
atns <- (SimpleType -> ReaderT Env (StateT EmitState IO) Type)
-> [SimpleType] -> ReaderT Env (StateT EmitState IO) [Type]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM SimpleType -> ReaderT Env (StateT EmitState IO) Type
doAnon [SimpleType]
sts
  let doCtor :: a -> Type -> Ctor
doCtor a
i Type
t =
          String -> [Field] -> Ctor
Ctor (QN -> String
_qLocal (QN -> String) -> QN -> String
forall a b. (a -> b) -> a -> b
$ Name -> QN
nName (Type -> Name
_typeName Type
t))
                   [QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field (String -> Maybe String -> QN
QN (a -> String
forall a. Show a => a -> String
show a
i) Maybe String
forall a. Maybe a
Nothing) Type
t Cardinality
One FieldEmit
FieldAttribute Int
0]
  Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Type -> Type
fixFields (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$
         Name
-> [Ctor]
-> DerivesFamily
-> [Impl]
-> DataTypeEmit
-> Maybe Documentation
-> Type
DataType Name
n ((Int -> Type -> Ctor) -> [Int] -> [Type] -> [Ctor]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Int -> Type -> Ctor
forall a. Show a => a -> Type -> Ctor
doCtor [(Int
1 :: Int) ..] ([Type] -> [Ctor]) -> [Type] -> [Ctor]
forall a b. (a -> b) -> a -> b
$ [Type]
rtts [Type] -> [Type] -> [Type]
forall a. [a] -> [a] -> [a]
++ [Type]
atns)
                  DerivesFamily
OtherDerives [] DataTypeEmit
DataTypeSimple Maybe Documentation
doc

-- | Check if type is built-in.
tryBuiltIn :: SimpleType -> Emit (Maybe Type)
tryBuiltIn :: SimpleType -> Emit (Maybe Type)
tryBuiltIn SimpleType
t =
    case Getting (Maybe QN) SimpleType (Maybe QN) -> SimpleType -> Maybe QN
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe QN) SimpleType (Maybe QN)
Lens' SimpleType (Maybe QN)
simpleTypeName SimpleType
t of
      Maybe QN
Nothing -> Maybe Type -> Emit (Maybe Type)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Type
forall a. Maybe a
Nothing
      Just QN
tn ->
          case QN -> Map QN Type -> Maybe Type
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup QN
tn Map QN Type
builtIns of
            Just Type
bt -> Maybe Type -> Emit (Maybe Type)
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> Maybe Type
forall a. a -> Maybe a
Just Type
bt)
            Maybe Type
Nothing ->
                case Getting (Leftmost QN) SimpleType QN -> SimpleType -> Maybe QN
forall a s. Getting (Leftmost a) s a -> s -> Maybe a
firstOf ((SimpleRestriction -> Const (Leftmost QN) SimpleRestriction)
-> SimpleType -> Const (Leftmost QN) SimpleType
Traversal' SimpleType SimpleRestriction
simpleTypeRestriction((SimpleRestriction -> Const (Leftmost QN) SimpleRestriction)
 -> SimpleType -> Const (Leftmost QN) SimpleType)
-> ((QN -> Const (Leftmost QN) QN)
    -> SimpleRestriction -> Const (Leftmost QN) SimpleRestriction)
-> Getting (Leftmost QN) SimpleType QN
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Ref SimpleType -> Const (Leftmost QN) (Ref SimpleType))
-> SimpleRestriction -> Const (Leftmost QN) SimpleRestriction
Lens' SimpleRestriction (Ref SimpleType)
simpleRestrictBase((Ref SimpleType -> Const (Leftmost QN) (Ref SimpleType))
 -> SimpleRestriction -> Const (Leftmost QN) SimpleRestriction)
-> ((QN -> Const (Leftmost QN) QN)
    -> Ref SimpleType -> Const (Leftmost QN) (Ref SimpleType))
-> (QN -> Const (Leftmost QN) QN)
-> SimpleRestriction
-> Const (Leftmost QN) SimpleRestriction
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(QN -> Const (Leftmost QN) QN)
-> Ref SimpleType -> Const (Leftmost QN) (Ref SimpleType)
forall a1. Traversal' (Ref a1) QN
unresolved) SimpleType
t of
                  Maybe QN
Nothing -> Maybe Type -> Emit (Maybe Type)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Type
forall a. Maybe a
Nothing
                  Just QN
bt | QN
bt QN -> QN -> Bool
forall a. Eq a => a -> a -> Bool
== QN
anySimpleTypeName -> Maybe Type -> Emit (Maybe Type)
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> Maybe Type
forall a. a -> Maybe a
Just Type
builtInString)
                          | Bool
otherwise -> Maybe Type -> Emit (Maybe Type)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Type
forall a. Maybe a
Nothing




emitEnum :: SimpleType -> Name -> [String] -> Maybe Documentation -> Emit Type
emitEnum :: SimpleType
-> Name
-> [String]
-> Maybe Documentation
-> ReaderT Env (StateT EmitState IO) Type
emitEnum SimpleType
_base Name
n [String]
vals Maybe Documentation
doc = Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Name
-> [String]
-> DerivesFamily
-> [Impl]
-> Maybe Documentation
-> Type
EnumType Name
n [String]
vals DerivesFamily
DataEnum [] Maybe Documentation
doc


-- | Complex type. 'anon' arg indicates element-defined complex type, therefore unique;
-- otherwise defined type.
emitComplexType :: Maybe QN -> ComplexType -> Emit Type
emitComplexType :: Maybe QN -> ComplexType -> ReaderT Env (StateT EmitState IO) Type
emitComplexType anon :: Maybe QN
anon@(Just QN
_) ComplexType
t =
    Namespace
-> Maybe QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkUniqueType Namespace
NSComplex Maybe QN
anon ((Name -> ReaderT Env (StateT EmitState IO) Type)
 -> ReaderT Env (StateT EmitState IO) Type)
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ ComplexType -> Name -> ReaderT Env (StateT EmitState IO) Type
doComplexType ComplexType
t
emitComplexType Maybe QN
Nothing ComplexType
t = do
  QN
n <- ReaderT Env (StateT EmitState IO) QN
-> (QN -> ReaderT Env (StateT EmitState IO) QN)
-> Maybe QN
-> ReaderT Env (StateT EmitState IO) QN
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a. MonadIO m => String -> m a
die (String -> ReaderT Env (StateT EmitState IO) QN)
-> String -> ReaderT Env (StateT EmitState IO) QN
forall a b. (a -> b) -> a -> b
$ String
"emitComplexType: no complex name: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ComplexType -> String
forall a. Show a => a -> String
show ComplexType
t) QN -> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe QN -> ReaderT Env (StateT EmitState IO) QN)
-> Maybe QN -> ReaderT Env (StateT EmitState IO) QN
forall a b. (a -> b) -> a -> b
$
       Getting (Maybe QN) ComplexType (Maybe QN)
-> ComplexType -> Maybe QN
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe QN) ComplexType (Maybe QN)
Lens' ComplexType (Maybe QN)
complexTypeName ComplexType
t
  Namespace
-> QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkDefinedType Namespace
NSComplex QN
n ((Name -> ReaderT Env (StateT EmitState IO) Type)
 -> ReaderT Env (StateT EmitState IO) Type)
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ ComplexType -> Name -> ReaderT Env (StateT EmitState IO) Type
doComplexType ComplexType
t


doComplexType :: ComplexType -> Name -> Emit Type
doComplexType :: ComplexType -> Name -> ReaderT Env (StateT EmitState IO) Type
doComplexType (ComplexTypeSimple Maybe QN
_ (SimpleContentExtension Ref SimpleType
scb Attributes
atts) Maybe Documentation
doc) Name
mn = do
  Type
rt <- Ref SimpleType -> Emit SimpleType
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref SimpleType
scb Emit SimpleType
-> (SimpleType -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SimpleType -> ReaderT Env (StateT EmitState IO) Type
emitSimpleType
  [Field]
ats <- Attributes -> Emit [Field]
emitAttrFields Attributes
atts
  Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Type -> Type
fixFields (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ Name
-> [Ctor]
-> DerivesFamily
-> [Impl]
-> DataTypeEmit
-> Maybe Documentation
-> Type
DataType Name
mn
             [String -> [Field] -> Ctor
Ctor String
"" (QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field (Ref SimpleType -> QN
forall t. Ref t -> QN
getRefType Ref SimpleType
scb) Type
rt Cardinality
One FieldEmit
FieldText Int
0Field -> [Field] -> [Field]
forall a. a -> [a] -> [a]
:[Field]
ats)]
             DerivesFamily
OtherDerives [] DataTypeEmit
DataTypeComplex Maybe Documentation
doc
doComplexType (ComplexTypeCompositor Maybe QN
_ Maybe Compositor
comp Attributes
atts Maybe Documentation
doc) Name
mn = do
  [Field]
ats <- Attributes -> Emit [Field]
emitAttrFields Attributes
atts
  [Field]
c <- Emit [Field]
-> (Compositor -> Emit [Field]) -> Maybe Compositor -> Emit [Field]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return []) ([QN] -> Compositor -> Emit [Field]
emitCompositor [Name -> QN
nName Name
mn]) Maybe Compositor
comp
  Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Type -> Type
fixFields (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$
         Name
-> [Ctor]
-> DerivesFamily
-> [Impl]
-> DataTypeEmit
-> Maybe Documentation
-> Type
DataType Name
mn [String -> [Field] -> Ctor
Ctor String
"" ([Field]
ats [Field] -> [Field] -> [Field]
forall a. [a] -> [a] -> [a]
++ [Field]
c)] DerivesFamily
OtherDerives [] DataTypeEmit
DataTypeComplex Maybe Documentation
doc
doComplexType (ComplexTypeComplex Maybe QN
_ (ComplexContentExtension Ref ComplexType
ccb Attributes
atts Maybe Compositor
comp) Maybe Documentation
doc) Name
mn = do
  Type
ct <- Ref ComplexType -> Emit ComplexType
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref ComplexType
ccb Emit ComplexType
-> (ComplexType -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe QN -> ComplexType -> ReaderT Env (StateT EmitState IO) Type
emitComplexType (QN -> Maybe QN
forall a. a -> Maybe a
Just (QN -> Maybe QN) -> QN -> Maybe QN
forall a b. (a -> b) -> a -> b
$ Name -> QN
nName Name
mn)
  [Field]
ats <- Attributes -> Emit [Field]
emitAttrFields Attributes
atts
  [Field]
c <- Emit [Field]
-> (Compositor -> Emit [Field]) -> Maybe Compositor -> Emit [Field]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return []) ([QN] -> Compositor -> Emit [Field]
emitCompositor [Name -> QN
nName Name
mn]) Maybe Compositor
comp
  -- TODO using FieldOther for base content, should be ok?
  Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Type -> Type
fixFields (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$ Name
-> [Ctor]
-> DerivesFamily
-> [Impl]
-> DataTypeEmit
-> Maybe Documentation
-> Type
DataType Name
mn
             [String -> [Field] -> Ctor
Ctor String
"" (QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field (Ref ComplexType -> QN
forall t. Ref t -> QN
getRefType Ref ComplexType
ccb) Type
ct Cardinality
One FieldEmit
FieldOther Int
0Field -> [Field] -> [Field]
forall a. a -> [a] -> [a]
:([Field]
ats [Field] -> [Field] -> [Field]
forall a. [a] -> [a] -> [a]
++ [Field]
c))]
             DerivesFamily
OtherDerives [] DataTypeEmit
DataTypeComplex Maybe Documentation
doc

-- | Obtain string name of 'Ref'.
getRefType :: Ref t -> QN
getRefType :: Ref t -> QN
getRefType (Unresolved QN
n) = QN
n
getRefType (Resolved QN
n t
_) = QN
n
getRefType Ref t
Final = String -> QN
forall a. HasCallStack => String -> a
error String
"Attempt to resolve ref on final"

-- | Emit compositor field.
emitCompositor :: [QN] -> Compositor -> Emit [Field]
emitCompositor :: [QN] -> Compositor -> Emit [Field]
emitCompositor [QN]
ns (CompositorGroup Group
g) = [QN] -> Group -> Emit [Field]
emitGroup [QN]
ns Group
g
emitCompositor [QN]
ns (CompositorChoice Choice
c) = [QN] -> Choice -> Maybe Documentation -> Emit [Field]
emitChoice [QN]
ns Choice
c Maybe Documentation
forall a. Maybe a
Nothing
emitCompositor [QN]
ns (CompositorSequence Sequence
s) = [QN]
-> Maybe Occurs -> Sequence -> Maybe Documentation -> Emit [Field]
emitSequence [QN]
ns Maybe Occurs
forall a. Maybe a
Nothing Sequence
s Maybe Documentation
forall a. Maybe a
Nothing

-- | Build up name stack, used in compositor/particle field emittance.
appendNames :: [QN] -> Maybe QN -> [QN]
appendNames :: [QN] -> Maybe QN -> [QN]
appendNames [QN]
ss = [QN] -> (QN -> [QN]) -> Maybe QN -> [QN]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [QN]
ss (QN -> [QN] -> [QN]
forall a. a -> [a] -> [a]
:[QN]
ss)

-- | Emit group. Referenced groups make types, others pass through.
emitGroup :: [QN] -> Group -> Emit [Field]
emitGroup :: [QN] -> Group -> Emit [Field]
emitGroup [QN]
ns (GroupRef Ref Group
r Occurs
o) = do
    Group
g <- Ref Group -> Emit Group
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref Group
r
    Type
t <- Namespace
-> QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkDefinedType Namespace
NSGroup (Ref Group -> QN
forall t. Ref t -> QN
getRefType Ref Group
r) ((Name -> ReaderT Env (StateT EmitState IO) Type)
 -> ReaderT Env (StateT EmitState IO) Type)
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ \Name
tn ->
         do
           [Field]
fs <- [QN] -> Group -> Emit [Field]
emitGroup [QN]
ns Group
g
           Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Name
-> [Ctor]
-> DerivesFamily
-> [Impl]
-> DataTypeEmit
-> Maybe Documentation
-> Type
DataType Name
tn [String -> [Field] -> Ctor
Ctor String
"" [Field]
fs]
                  DerivesFamily
OtherDerives [] DataTypeEmit
DataTypeComplex Maybe Documentation
forall a. Maybe a
Nothing
    [Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Field] -> Emit [Field]) -> [Field] -> Emit [Field]
forall a b. (a -> b) -> a -> b
$ Occurs -> Field -> [Field]
forOccurs Occurs
o (Field -> [Field]) -> Field -> [Field]
forall a b. (a -> b) -> a -> b
$ QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field (Ref Group -> QN
forall t. Ref t -> QN
getRefType Ref Group
r) Type
t Cardinality
One FieldEmit
FieldOther Int
0
emitGroup [QN]
ns (GroupChoice Maybe QN
n Occurs
o Choice
c Maybe Documentation
doc) =
    (Field -> [Field]) -> [Field] -> [Field]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Occurs -> Field -> [Field]
forOccurs Occurs
o) ([Field] -> [Field]) -> Emit [Field] -> Emit [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [QN] -> Choice -> Maybe Documentation -> Emit [Field]
emitChoice ([QN] -> Maybe QN -> [QN]
appendNames [QN]
ns Maybe QN
n) Choice
c Maybe Documentation
doc
emitGroup [QN]
ns (GroupSequence Maybe QN
n Occurs
o Sequence
s Maybe Documentation
doc) =
    (Field -> [Field]) -> [Field] -> [Field]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Occurs -> Field -> [Field]
forOccurs Occurs
o) ([Field] -> [Field]) -> Emit [Field] -> Emit [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [QN]
-> Maybe Occurs -> Sequence -> Maybe Documentation -> Emit [Field]
emitSequence ([QN] -> Maybe QN -> [QN]
appendNames [QN]
ns Maybe QN
n) (Occurs -> Maybe Occurs
forall a. a -> Maybe a
Just Occurs
o) Sequence
s Maybe Documentation
doc

-- | Choice production.
emitChoice :: [QN] -> Choice -> Maybe Documentation -> Emit [Field]
emitChoice :: [QN] -> Choice -> Maybe Documentation -> Emit [Field]
emitChoice [QN]
ns (Choice Occurs
o [Particle]
ps) Maybe Documentation
doc = do
  [[Field]]
fss <- (Particle -> Emit [Field])
-> [Particle] -> ReaderT Env (StateT EmitState IO) [[Field]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([QN] -> Particle -> Emit [Field]
emitParticle [QN]
ns) [Particle]
ps
  Type
t <- Namespace
-> Maybe QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkUniqueType Namespace
NSChoice (QN -> Maybe QN
forall a. a -> Maybe a
Just (QN -> Maybe QN) -> QN -> Maybe QN
forall a b. (a -> b) -> a -> b
$ [QN] -> QN
forall a. [a] -> a
head [QN]
ns) ((Name -> ReaderT Env (StateT EmitState IO) Type)
 -> ReaderT Env (StateT EmitState IO) Type)
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ \Name
mn ->
       do
         let cctor :: [Field] -> Ctor
cctor [Field]
fs = String -> [Field] -> Ctor
Ctor (QN -> String
_qLocal ([Field] -> QN
chooseName [Field]
fs)) [Field]
fs
             chooseName :: [Field] -> QN
chooseName [Field
f] = Field -> QN
_fieldName Field
f
             chooseName [Field]
fs = Field -> QN
_fieldName ([Field] -> Field
forall a. [a] -> a
head [Field]
fs) -- ++ show (length fs)
         Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Type -> Type
fixFields (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$
                Name
-> [Ctor]
-> DerivesFamily
-> [Impl]
-> DataTypeEmit
-> Maybe Documentation
-> Type
DataType Name
mn (([Field] -> Ctor) -> [[Field]] -> [Ctor]
forall a b. (a -> b) -> [a] -> [b]
map [Field] -> Ctor
cctor [[Field]]
fss) DerivesFamily
OtherDerives [] DataTypeEmit
DataTypeCompositor Maybe Documentation
doc
  [Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Field] -> Emit [Field]) -> [Field] -> Emit [Field]
forall a b. (a -> b) -> a -> b
$ Occurs -> Field -> [Field]
forOccurs Occurs
o (QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field ([QN] -> QN
forall a. [a] -> a
head [QN]
ns) Type
t Cardinality
One FieldEmit
FieldOther Int
0)

-- | Guarantee unique constructor fields for a type.
fixFields :: Type -> Type
fixFields :: Type -> Type
fixFields = ASetter Type Type [Ctor] [Ctor]
-> ([Ctor] -> [Ctor]) -> Type -> Type
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter Type Type [Ctor] [Ctor]
Traversal' Type [Ctor]
typeCtors (\[Ctor]
cs -> State (Map QN Int) [Ctor] -> Map QN Int -> [Ctor]
forall s a. State s a -> s -> a
evalState ((Ctor -> StateT (Map QN Int) Identity Ctor)
-> [Ctor] -> State (Map QN Int) [Ctor]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Ctor -> StateT (Map QN Int) Identity Ctor
fixC [Ctor]
cs) Map QN Int
forall a. Monoid a => a
mempty)
    where fixC :: Ctor -> State (M.Map QN Int) Ctor
          fixC :: Ctor -> StateT (Map QN Int) Identity Ctor
fixC c :: Ctor
c@(Ctor String
_ [Field]
fs) = do
            [Field]
fs' <- (Field -> StateT (Map QN Int) Identity Field)
-> [Field] -> StateT (Map QN Int) Identity [Field]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Field -> StateT (Map QN Int) Identity Field
fixF [Field]
fs
            Ctor -> StateT (Map QN Int) Identity Ctor
forall (m :: * -> *) a. Monad m => a -> m a
return (Ctor -> StateT (Map QN Int) Identity Ctor)
-> Ctor -> StateT (Map QN Int) Identity Ctor
forall a b. (a -> b) -> a -> b
$ ASetter Ctor Ctor [Field] [Field] -> [Field] -> Ctor -> Ctor
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter Ctor Ctor [Field] [Field]
Lens' Ctor [Field]
ctorFields [Field]
fs' Ctor
c
          fixF :: Field -> State (M.Map QN Int) Field
          fixF :: Field -> StateT (Map QN Int) Identity Field
fixF f :: Field
f@(Field QN
fn Type
_ Cardinality
_ FieldEmit
_ Int
_) = do
            Maybe Int
seen <- QN -> Map QN Int -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup QN
fn (Map QN Int -> Maybe Int)
-> StateT (Map QN Int) Identity (Map QN Int)
-> StateT (Map QN Int) Identity (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT (Map QN Int) Identity (Map QN Int)
forall s (m :: * -> *). MonadState s m => m s
get
            (Map QN Int -> Map QN Int) -> StateT (Map QN Int) Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((Int -> Int -> Int) -> QN -> Int -> Map QN Int -> Map QN Int
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
M.insertWith Int -> Int -> Int
forall a. Num a => a -> a -> a
(+) QN
fn Int
1)
            Field -> StateT (Map QN Int) Identity Field
forall (m :: * -> *) a. Monad m => a -> m a
return (Field -> StateT (Map QN Int) Identity Field)
-> Field -> StateT (Map QN Int) Identity Field
forall a b. (a -> b) -> a -> b
$ Field -> (Int -> Field) -> Maybe Int -> Field
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Field
f (\Int
i -> ASetter Field Field Int Int -> Int -> Field -> Field
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter Field Field Int Int
Lens' Field Int
fieldIdx Int
i Field
f) Maybe Int
seen


-- | Sequence production.
emitSequence :: [QN] -> Maybe Occurs -> Sequence -> Maybe Documentation -> Emit [Field]
emitSequence :: [QN]
-> Maybe Occurs -> Sequence -> Maybe Documentation -> Emit [Field]
emitSequence [QN]
ns Maybe Occurs
parentO (Sequence Occurs
o [Particle]
ps) Maybe Documentation
doc = do
  [Field]
fs <- [[Field]] -> [Field]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Field]] -> [Field])
-> ReaderT Env (StateT EmitState IO) [[Field]] -> Emit [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Particle -> Emit [Field])
-> [Particle] -> ReaderT Env (StateT EmitState IO) [[Field]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([QN] -> Particle -> Emit [Field]
emitParticle [QN]
ns) [Particle]
ps
  -- don't emit new type for 'One' cardinality
  case (Occurs -> Cardinality
occursToCardinality Occurs
o,(Occurs -> Cardinality) -> Maybe Occurs -> Maybe Cardinality
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Occurs -> Cardinality
occursToCardinality Maybe Occurs
parentO) of
    (Cardinality
One,Maybe Cardinality
Nothing) -> [Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return [Field]
fs
    (Cardinality
One,Just Cardinality
One) -> [Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return [Field]
fs
    (Cardinality, Maybe Cardinality)
_ -> do
      Type
t <- Namespace
-> Maybe QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkUniqueType Namespace
NSSequence (QN -> Maybe QN
forall a. a -> Maybe a
Just (QN -> Maybe QN) -> QN -> Maybe QN
forall a b. (a -> b) -> a -> b
$ [QN] -> QN
forall a. [a] -> a
head [QN]
ns) ((Name -> ReaderT Env (StateT EmitState IO) Type)
 -> ReaderT Env (StateT EmitState IO) Type)
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ \Name
mn ->
           Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> ReaderT Env (StateT EmitState IO) Type)
-> Type -> ReaderT Env (StateT EmitState IO) Type
forall a b. (a -> b) -> a -> b
$ Type -> Type
fixFields (Type -> Type) -> Type -> Type
forall a b. (a -> b) -> a -> b
$
                  Name
-> [Ctor]
-> DerivesFamily
-> [Impl]
-> DataTypeEmit
-> Maybe Documentation
-> Type
DataType Name
mn [String -> [Field] -> Ctor
Ctor String
"" [Field]
fs] DerivesFamily
OtherDerives [] DataTypeEmit
DataTypeCompositor Maybe Documentation
doc
      [Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Field] -> Emit [Field]) -> [Field] -> Emit [Field]
forall a b. (a -> b) -> a -> b
$ Occurs -> Field -> [Field]
forOccurs Occurs
o (QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field ([QN] -> QN
forall a. [a] -> a
head [QN]
ns) Type
t Cardinality
One FieldEmit
FieldOther Int
0)

-- | Particle field production.
-- Element fields emit containing element.
emitParticle :: [QN] -> Particle -> Emit [Field]
emitParticle :: [QN] -> Particle -> Emit [Field]
emitParticle [QN]
_ (PartElement Element
e) = do
  Type
et <- Element -> ReaderT Env (StateT EmitState IO) Type
emitElement Element
e
  QN
fn <- ReaderT Env (StateT EmitState IO) QN
-> (QN -> ReaderT Env (StateT EmitState IO) QN)
-> Maybe QN
-> ReaderT Env (StateT EmitState IO) QN
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a. MonadIO m => String -> m a
die String
"emitParticle: emitted element must have name") QN -> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe QN -> ReaderT Env (StateT EmitState IO) QN)
-> Maybe QN -> ReaderT Env (StateT EmitState IO) QN
forall a b. (a -> b) -> a -> b
$
        Getting (Leftmost QN) Element QN -> Element -> Maybe QN
forall a s. Getting (Leftmost a) s a -> s -> Maybe a
firstOf Getting (Leftmost QN) Element QN
Traversal' Element QN
elementName Element
e
  let o :: Occurs
o = Occurs -> Maybe Occurs -> Occurs
forall a. a -> Maybe a -> a
fromMaybe (Maybe String -> Maybe String -> Occurs
Occurs Maybe String
forall a. Maybe a
Nothing Maybe String
forall a. Maybe a
Nothing) (Maybe Occurs -> Occurs) -> Maybe Occurs -> Occurs
forall a b. (a -> b) -> a -> b
$ Getting (Leftmost Occurs) Element Occurs -> Element -> Maybe Occurs
forall a s. Getting (Leftmost a) s a -> s -> Maybe a
firstOf Getting (Leftmost Occurs) Element Occurs
Lens' Element Occurs
elementOccurs Element
e
  [Field] -> Emit [Field]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Field] -> Emit [Field]) -> [Field] -> Emit [Field]
forall a b. (a -> b) -> a -> b
$ Occurs -> Field -> [Field]
forOccurs Occurs
o (Field -> [Field]) -> Field -> [Field]
forall a b. (a -> b) -> a -> b
$ QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field QN
fn Type
et Cardinality
One FieldEmit
FieldElement Int
0
emitParticle [QN]
ns (PartGroup Group
g) = [QN] -> Group -> Emit [Field]
emitGroup [QN]
ns Group
g
emitParticle [QN]
ns (PartChoice Choice
c) = [QN] -> Choice -> Maybe Documentation -> Emit [Field]
emitChoice [QN]
ns Choice
c Maybe Documentation
forall a. Maybe a
Nothing
emitParticle [QN]
ns (PartSequence Sequence
s) = [QN]
-> Maybe Occurs -> Sequence -> Maybe Documentation -> Emit [Field]
emitSequence [QN]
ns Maybe Occurs
forall a. Maybe a
Nothing Sequence
s Maybe Documentation
forall a. Maybe a
Nothing


-- | Modify a field cardinality per occurs.
-- TODO: musicxml uses max occurs only for >1 or unbounded, but could be 1 ...
-- TODO use occursToCardinality
forOccurs :: Occurs -> Field -> [Field]
forOccurs :: Occurs -> Field -> [Field]
forOccurs (Occurs Maybe String
Nothing Maybe String
Nothing) Field
f = [Field
f]
forOccurs (Occurs (Just String
"0") Maybe String
Nothing) Field
f = [ASetter Field Field Cardinality Cardinality
-> Cardinality -> Field -> Field
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter Field Field Cardinality Cardinality
Lens' Field Cardinality
fieldCardinality Cardinality
ZeroOrOne Field
f]
forOccurs (Occurs Maybe String
_ Maybe String
_) Field
f = [ASetter Field Field Cardinality Cardinality
-> Cardinality -> Field -> Field
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter Field Field Cardinality Cardinality
Lens' Field Cardinality
fieldCardinality Cardinality
Many Field
f]

-- | Imprecise mapping of occurs-* to cardinality.
occursToCardinality :: Occurs -> Cardinality
occursToCardinality :: Occurs -> Cardinality
occursToCardinality (Occurs Maybe String
Nothing Maybe String
Nothing) = Cardinality
One
occursToCardinality (Occurs Maybe String
Nothing (Just String
"1")) = Cardinality
One
occursToCardinality (Occurs (Just String
"0") Maybe String
Nothing) = Cardinality
ZeroOrOne
occursToCardinality (Occurs (Just String
"1") Maybe String
Nothing) = Cardinality
One
occursToCardinality (Occurs (Just String
"1") (Just String
"1")) = Cardinality
One
occursToCardinality (Occurs Maybe String
_ Maybe String
_) = Cardinality
Many


-- | Handle attribute and attribute group productions as fields.
emitAttrFields :: Attributes -> Emit [Field]
emitAttrFields :: Attributes -> Emit [Field]
emitAttrFields  = Attributes -> Emit [Field]
doAttrs
    where doAttrs :: Attributes -> Emit [Field]
doAttrs (Attributes [Attribute]
as [AttributeGroup]
ags) =
              [Field] -> [Field] -> [Field]
forall a. [a] -> [a] -> [a]
(++) ([Field] -> [Field] -> [Field])
-> Emit [Field]
-> ReaderT Env (StateT EmitState IO) ([Field] -> [Field])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Maybe Field] -> [Field]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe Field] -> [Field])
-> ReaderT Env (StateT EmitState IO) [Maybe Field] -> Emit [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Attribute -> ReaderT Env (StateT EmitState IO) (Maybe Field))
-> [Attribute] -> ReaderT Env (StateT EmitState IO) [Maybe Field]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Attribute -> ReaderT Env (StateT EmitState IO) (Maybe Field)
resolveAttr [Attribute]
as) ReaderT Env (StateT EmitState IO) ([Field] -> [Field])
-> Emit [Field] -> Emit [Field]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              ([[Field]] -> [Field]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Field]] -> [Field])
-> ReaderT Env (StateT EmitState IO) [[Field]] -> Emit [Field]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (AttributeGroup -> Emit [Field])
-> [AttributeGroup] -> ReaderT Env (StateT EmitState IO) [[Field]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM AttributeGroup -> Emit [Field]
resolveAttrGroup [AttributeGroup]
ags)
          forUse :: Use -> Field -> Maybe Field
forUse Use
Prohibited Field
_ = Maybe Field
forall a. Maybe a
Nothing
          forUse Use
Optional Field
a = Field -> Maybe Field
forall a. a -> Maybe a
Just (Field -> Maybe Field) -> Field -> Maybe Field
forall a b. (a -> b) -> a -> b
$ ASetter Field Field Cardinality Cardinality
-> Cardinality -> Field -> Field
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter Field Field Cardinality Cardinality
Lens' Field Cardinality
fieldCardinality Cardinality
ZeroOrOne Field
a
          forUse Use
Required Field
a = Field -> Maybe Field
forall a. a -> Maybe a
Just (Field -> Maybe Field) -> Field -> Maybe Field
forall a b. (a -> b) -> a -> b
$ ASetter Field Field Cardinality Cardinality
-> Cardinality -> Field -> Field
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter Field Field Cardinality Cardinality
Lens' Field Cardinality
fieldCardinality Cardinality
One Field
a
          resolveAttr :: Attribute -> ReaderT Env (StateT EmitState IO) (Maybe Field)
resolveAttr (AttributeRef Ref Attribute
r Use
u Maybe String
_) = do
              Attribute
a <- Ref Attribute -> Emit Attribute
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref Attribute
r
              Maybe Field -> (Field -> Maybe Field) -> Maybe Field -> Maybe Field
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe Field
forall a. Maybe a
Nothing (Use -> Field -> Maybe Field
forUse Use
u) (Maybe Field -> Maybe Field)
-> ReaderT Env (StateT EmitState IO) (Maybe Field)
-> ReaderT Env (StateT EmitState IO) (Maybe Field)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Attribute -> ReaderT Env (StateT EmitState IO) (Maybe Field)
resolveAttr Attribute
a
          resolveAttr (AttributeSimpleType QN
n SimpleType
t) = do
              Type
a <- Namespace
-> QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkDefinedType Namespace
NSSimple QN
n (SimpleType -> Name -> ReaderT Env (StateT EmitState IO) Type
doSimpleType SimpleType
t) -- TODO why not just doSimpleType, or emit??
              Maybe Field -> ReaderT Env (StateT EmitState IO) (Maybe Field)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Field -> ReaderT Env (StateT EmitState IO) (Maybe Field))
-> Maybe Field -> ReaderT Env (StateT EmitState IO) (Maybe Field)
forall a b. (a -> b) -> a -> b
$ Field -> Maybe Field
forall a. a -> Maybe a
Just (Field -> Maybe Field) -> Field -> Maybe Field
forall a b. (a -> b) -> a -> b
$ QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field QN
n Type
a Cardinality
One FieldEmit
FieldAttribute Int
0
          resolveAttr (AttributeType QN
n Ref SimpleType
r Use
u Maybe String
_) =
              Ref SimpleType -> Emit SimpleType
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref SimpleType
r Emit SimpleType
-> (SimpleType -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SimpleType -> ReaderT Env (StateT EmitState IO) Type
emitSimpleType ReaderT Env (StateT EmitState IO) Type
-> (Type -> ReaderT Env (StateT EmitState IO) (Maybe Field))
-> ReaderT Env (StateT EmitState IO) (Maybe Field)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Type
t ->
                  Maybe Field -> ReaderT Env (StateT EmitState IO) (Maybe Field)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Field -> ReaderT Env (StateT EmitState IO) (Maybe Field))
-> Maybe Field -> ReaderT Env (StateT EmitState IO) (Maybe Field)
forall a b. (a -> b) -> a -> b
$ Use -> Field -> Maybe Field
forUse Use
u (Field -> Maybe Field) -> Field -> Maybe Field
forall a b. (a -> b) -> a -> b
$ QN -> Type -> Cardinality -> FieldEmit -> Int -> Field
Field QN
n Type
t Cardinality
One FieldEmit
FieldAttribute Int
0
          resolveAttrGroup :: AttributeGroup -> Emit [Field]
resolveAttrGroup (AttributeGroup QN
_ Attributes
as Maybe Documentation
doc) = Attributes -> Emit [Field]
doAttrs Attributes
as
          resolveAttrGroup (AttributeGroupRef Ref AttributeGroup
r) = Ref AttributeGroup -> Emit AttributeGroup
forall a. Resolvable (Ref a) => Ref a -> Emit a
resolvedRef Ref AttributeGroup
r Emit AttributeGroup
-> (AttributeGroup -> Emit [Field]) -> Emit [Field]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= AttributeGroup -> Emit [Field]
resolveAttrGroup

-- | register a unique type, where namespace collisions will
-- | increment 'nIdx' on the namespace.
checkUniqueType :: Namespace -> Maybe QN -> (Name -> Emit Type) -> Emit Type
checkUniqueType :: Namespace
-> Maybe QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkUniqueType Namespace
ns Maybe QN
mtn Name -> ReaderT Env (StateT EmitState IO) Type
act = do
  QN
n <- case Maybe QN
mtn of
          Just QN
t -> QN -> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a. Monad m => a -> m a
return QN
t
          Maybe QN
Nothing -> ([Name] -> [Name])
-> ReaderT Env (StateT EmitState IO) [Name]
-> ReaderT Env (StateT EmitState IO) [Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> [Name] -> [Name]
forall a. Int -> [a] -> [a]
take Int
1) (Getting [Name] EmitState [Name]
-> ReaderT Env (StateT EmitState IO) [Name]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting [Name] EmitState [Name]
Lens' EmitState [Name]
stack) ReaderT Env (StateT EmitState IO) [Name]
-> ([Name] -> ReaderT Env (StateT EmitState IO) QN)
-> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Name]
h ->
                     case [Name]
h of [Name Namespace
_ QN
a Int
_] -> QN -> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a. Monad m => a -> m a
return QN
a
                               [Name]
_ -> String -> ReaderT Env (StateT EmitState IO) QN
forall (m :: * -> *) a. MonadIO m => String -> m a
die (String -> ReaderT Env (StateT EmitState IO) QN)
-> String -> ReaderT Env (StateT EmitState IO) QN
forall a b. (a -> b) -> a -> b
$ String
"checkType: empty stack on anon type: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Namespace -> String
forall a. Show a => a -> String
show Namespace
ns
  let find :: Int -> m Name
find Int
i = do
        let cand :: Name
cand = Namespace -> QN -> Int -> Name
Name Namespace
ns QN
n Int
i
        Maybe Type
mt <- Name -> Map Name Type -> Maybe Type
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Name
cand (Map Name Type -> Maybe Type)
-> m (Map Name Type) -> m (Maybe Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting (Map Name Type) EmitState (Map Name Type)
-> m (Map Name Type)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Map Name Type) EmitState (Map Name Type)
Lens' EmitState (Map Name Type)
types
        m Name -> (Type -> m Name) -> Maybe Type -> m Name
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Name -> m Name
forall (m :: * -> *) a. Monad m => a -> m a
return Name
cand) (\Type
_ -> Int -> m Name
find (Int -> Int
forall a. Enum a => a -> a
succ Int
i)) Maybe Type
mt
  Name
mn <- Int -> ReaderT Env (StateT EmitState IO) Name
forall (m :: * -> *). MonadState EmitState m => Int -> m Name
find Int
0
  Name
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
buildType Name
mn Name -> ReaderT Env (StateT EmitState IO) Type
act


-- | register or lookup a pre-defined type; the 'Namespace' argument
-- | should uniquely idenfify.
checkDefinedType :: Namespace -> QN -> (Name -> Emit Type) -> Emit Type
checkDefinedType :: Namespace
-> QN
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
checkDefinedType Namespace
ns QN
tn Name -> ReaderT Env (StateT EmitState IO) Type
act = do
  let mn :: Name
mn = Namespace -> QN -> Int -> Name
Name Namespace
ns QN
tn Int
0
  Maybe Type
ts <- Name -> Map Name Type -> Maybe Type
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Name
mn (Map Name Type -> Maybe Type)
-> ReaderT Env (StateT EmitState IO) (Map Name Type)
-> Emit (Maybe Type)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting (Map Name Type) EmitState (Map Name Type)
-> ReaderT Env (StateT EmitState IO) (Map Name Type)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Map Name Type) EmitState (Map Name Type)
Lens' EmitState (Map Name Type)
types
  case Maybe Type
ts of
    Just Type
t -> Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return Type
t
    Maybe Type
Nothing -> Name
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
buildType Name
mn Name -> ReaderT Env (StateT EmitState IO) Type
act

-- | Update state for new type.
buildType :: Name -> (Name -> Emit Type) -> Emit Type
buildType :: Name
-> (Name -> ReaderT Env (StateT EmitState IO) Type)
-> ReaderT Env (StateT EmitState IO) Type
buildType Name
mn Name -> ReaderT Env (StateT EmitState IO) Type
act = do
  ([Name] -> Identity [Name]) -> EmitState -> Identity EmitState
Lens' EmitState [Name]
stack (([Name] -> Identity [Name]) -> EmitState -> Identity EmitState)
-> ([Name] -> [Name]) -> Emit ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Name
mnName -> [Name] -> [Name]
forall a. a -> [a] -> [a]
:)
  Type
nt <- Name -> ReaderT Env (StateT EmitState IO) Type
act Name
mn
  ([Name] -> Identity [Name]) -> EmitState -> Identity EmitState
Lens' EmitState [Name]
stack (([Name] -> Identity [Name]) -> EmitState -> Identity EmitState)
-> ([Name] -> [Name]) -> Emit ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= [Name] -> [Name]
forall a. [a] -> [a]
tail
  (Map Name Type -> Identity (Map Name Type))
-> EmitState -> Identity EmitState
Lens' EmitState (Map Name Type)
types ((Map Name Type -> Identity (Map Name Type))
 -> EmitState -> Identity EmitState)
-> (Map Name Type -> Map Name Type) -> Emit ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Name -> Type -> Map Name Type -> Map Name Type
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert Name
mn Type
nt
  Type -> ReaderT Env (StateT EmitState IO) Type
forall (m :: * -> *) a. Monad m => a -> m a
return Type
nt