{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./OMDoc/OMDocInterface.hs
Description :  Handpicked model of OMDoc subset
Copyright   :  (c) Hendrik Iben, Uni Bremen 2005-2007
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  hiben@informatik.uni-bremen.de
Stability   :  provisional
Portability :  non-portable

Model of a handpicked subset from OMDoc
-}
module OMDoc.OMDocInterface where

import qualified Common.IRI as IRI

import Data.Char
import Data.Data

import qualified Data.Word as Word

import Common.Doc
import Common.DocUtils
import Common.Id

omdocDefaultNamespace :: String
omdocDefaultNamespace :: String
omdocDefaultNamespace = "http://www.mathweb.org/omdoc"

-- | OMDocRef is anyIRI
type OMDocRef = IRI.IRI

-- | OMDocRefs modelled as a list
type OMDocRefs = [OMDocRef]

showIRI :: IRI.IRI -> String
showIRI :: IRI -> String
showIRI = IRI -> String
IRI.iriToStringUnsecure

-- Try to parse an IRI
mkOMDocRef :: String -> Maybe OMDocRef
mkOMDocRef :: String -> Maybe IRI
mkOMDocRef = String -> Maybe IRI
IRI.parseIRIReference

mkSymbolRef :: XmlId -> OMDocRef
mkSymbolRef :: String -> IRI
mkSymbolRef xid :: String
xid =
  case String -> Maybe IRI
IRI.parseIRIReference ('#' Char -> String -> String
forall a. a -> [a] -> [a]
: String
xid) of
    Nothing -> String -> IRI
forall a. HasCallStack => String -> a
error ("Invalid Symbol-Id! (" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
xid String -> String -> String
forall a. [a] -> [a] -> [a]
++ ")")
    (Just u :: IRI
u) -> IRI
u

mkExtSymbolRef :: XmlId -> XmlId -> OMDocRef
mkExtSymbolRef :: String -> String -> IRI
mkExtSymbolRef xcd :: String
xcd xid :: String
xid =
  case String -> Maybe IRI
IRI.parseIRIReference (String
xcd String -> String -> String
forall a. [a] -> [a] -> [a]
++ "#" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
xid) of
    Nothing -> String -> IRI
forall a. HasCallStack => String -> a
error "Invalid Reference!"
    (Just u :: IRI
u) -> IRI
u

-- OMDoc

-- | used for ids
type XmlId = String
-- | used for names, pcdata
type XmlString = String

-- | OMDoc
data OMDoc =
  OMDoc
    {
        OMDoc -> String
omdocId :: XmlId
      , OMDoc -> [Theory]
omdocTheories :: [Theory]
      , OMDoc -> [Inclusion]
omdocInclusions :: [Inclusion]
    }
    deriving (Int -> OMDoc -> String -> String
[OMDoc] -> String -> String
OMDoc -> String
(Int -> OMDoc -> String -> String)
-> (OMDoc -> String) -> ([OMDoc] -> String -> String) -> Show OMDoc
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [OMDoc] -> String -> String
$cshowList :: [OMDoc] -> String -> String
show :: OMDoc -> String
$cshow :: OMDoc -> String
showsPrec :: Int -> OMDoc -> String -> String
$cshowsPrec :: Int -> OMDoc -> String -> String
Show, Typeable, Typeable OMDoc
Constr
DataType
Typeable OMDoc =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OMDoc -> c OMDoc)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OMDoc)
-> (OMDoc -> Constr)
-> (OMDoc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OMDoc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMDoc))
-> ((forall b. Data b => b -> b) -> OMDoc -> OMDoc)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r)
-> (forall u. (forall d. Data d => d -> u) -> OMDoc -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OMDoc -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OMDoc -> m OMDoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMDoc -> m OMDoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMDoc -> m OMDoc)
-> Data OMDoc
OMDoc -> Constr
OMDoc -> DataType
(forall b. Data b => b -> b) -> OMDoc -> OMDoc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDoc -> c OMDoc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDoc
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) -> OMDoc -> u
forall u. (forall d. Data d => d -> u) -> OMDoc -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDoc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDoc -> c OMDoc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMDoc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMDoc)
$cOMDoc :: Constr
$tOMDoc :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
gmapMp :: (forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
gmapM :: (forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMDoc -> m OMDoc
gmapQi :: Int -> (forall d. Data d => d -> u) -> OMDoc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OMDoc -> u
gmapQ :: (forall d. Data d => d -> u) -> OMDoc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OMDoc -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OMDoc -> r
gmapT :: (forall b. Data b => b -> b) -> OMDoc -> OMDoc
$cgmapT :: (forall b. Data b => b -> b) -> OMDoc -> OMDoc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMDoc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMDoc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OMDoc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMDoc)
dataTypeOf :: OMDoc -> DataType
$cdataTypeOf :: OMDoc -> DataType
toConstr :: OMDoc -> Constr
$ctoConstr :: OMDoc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDoc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDoc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDoc -> c OMDoc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDoc -> c OMDoc
$cp1Data :: Typeable OMDoc
Data)

addTheories :: OMDoc -> [Theory] -> OMDoc
addTheories :: OMDoc -> [Theory] -> OMDoc
addTheories omdoc :: OMDoc
omdoc theories :: [Theory]
theories =
  OMDoc
omdoc
    {
      omdocTheories :: [Theory]
omdocTheories = OMDoc -> [Theory]
omdocTheories OMDoc
omdoc [Theory] -> [Theory] -> [Theory]
forall a. [a] -> [a] -> [a]
++ [Theory]
theories
    }

addInclusions :: OMDoc -> [Inclusion] -> OMDoc
addInclusions :: OMDoc -> [Inclusion] -> OMDoc
addInclusions omdoc :: OMDoc
omdoc inclusions :: [Inclusion]
inclusions =
  OMDoc
omdoc
    {
      omdocInclusions :: [Inclusion]
omdocInclusions = OMDoc -> [Inclusion]
omdocInclusions OMDoc
omdoc [Inclusion] -> [Inclusion] -> [Inclusion]
forall a. [a] -> [a] -> [a]
++ [Inclusion]
inclusions
    }

-- Theory
data Theory =
  Theory
    {
        Theory -> String
theoryId :: XmlId
      , Theory -> [Constitutive]
theoryConstitutives :: [Constitutive]
      , Theory -> [Presentation]
theoryPresentations :: [Presentation]
      , Theory -> Maybe String
theoryComment :: Maybe String
    }
    deriving (Int -> Theory -> String -> String
[Theory] -> String -> String
Theory -> String
(Int -> Theory -> String -> String)
-> (Theory -> String)
-> ([Theory] -> String -> String)
-> Show Theory
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Theory] -> String -> String
$cshowList :: [Theory] -> String -> String
show :: Theory -> String
$cshow :: Theory -> String
showsPrec :: Int -> Theory -> String -> String
$cshowsPrec :: Int -> Theory -> String -> String
Show, Typeable, Typeable Theory
Constr
DataType
Typeable Theory =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Theory -> c Theory)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Theory)
-> (Theory -> Constr)
-> (Theory -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Theory))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Theory))
-> ((forall b. Data b => b -> b) -> Theory -> Theory)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Theory -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Theory -> r)
-> (forall u. (forall d. Data d => d -> u) -> Theory -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Theory -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Theory -> m Theory)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Theory -> m Theory)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Theory -> m Theory)
-> Data Theory
Theory -> Constr
Theory -> DataType
(forall b. Data b => b -> b) -> Theory -> Theory
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Theory -> c Theory
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Theory
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) -> Theory -> u
forall u. (forall d. Data d => d -> u) -> Theory -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Theory -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Theory -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Theory -> m Theory
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Theory -> m Theory
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Theory
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Theory -> c Theory
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Theory)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Theory)
$cTheory :: Constr
$tTheory :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Theory -> m Theory
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Theory -> m Theory
gmapMp :: (forall d. Data d => d -> m d) -> Theory -> m Theory
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Theory -> m Theory
gmapM :: (forall d. Data d => d -> m d) -> Theory -> m Theory
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Theory -> m Theory
gmapQi :: Int -> (forall d. Data d => d -> u) -> Theory -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Theory -> u
gmapQ :: (forall d. Data d => d -> u) -> Theory -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Theory -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Theory -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Theory -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Theory -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Theory -> r
gmapT :: (forall b. Data b => b -> b) -> Theory -> Theory
$cgmapT :: (forall b. Data b => b -> b) -> Theory -> Theory
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Theory)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Theory)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Theory)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Theory)
dataTypeOf :: Theory -> DataType
$cdataTypeOf :: Theory -> DataType
toConstr :: Theory -> Constr
$ctoConstr :: Theory -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Theory
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Theory
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Theory -> c Theory
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Theory -> c Theory
$cp1Data :: Typeable Theory
Data)

instance Pretty Theory where
  pretty :: Theory -> Doc
pretty t :: Theory
t = String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$
    String -> String
forall a. Show a => a -> String
show (Theory -> String
theoryId Theory
t)
    String -> String -> String
forall a. [a] -> [a] -> [a]
++
      case Theory -> Maybe String
theoryComment Theory
t of
        Nothing -> ""
        (Just c :: String
c) -> ": " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
c

instance Eq Theory where
  t1 :: Theory
t1 == :: Theory -> Theory -> Bool
== t2 :: Theory
t2 = Theory -> String
theoryId Theory
t1 String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== Theory -> String
theoryId Theory
t2

instance Ord Theory where
  t1 :: Theory
t1 compare :: Theory -> Theory -> Ordering
`compare` t2 :: Theory
t2 = Theory -> String
theoryId Theory
t1 String -> String -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Theory -> String
theoryId Theory
t2

-- debug
showTheory :: Theory -> String
showTheory :: Theory -> String
showTheory t :: Theory
t = Theory -> String
forall a. Show a => a -> String
show (Theory
t { theoryPresentations :: [Presentation]
theoryPresentations = [] })

-- | Type (scope) of import
data ImportsType = ITLocal | ITGlobal
  deriving (Int -> ImportsType -> String -> String
[ImportsType] -> String -> String
ImportsType -> String
(Int -> ImportsType -> String -> String)
-> (ImportsType -> String)
-> ([ImportsType] -> String -> String)
-> Show ImportsType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ImportsType] -> String -> String
$cshowList :: [ImportsType] -> String -> String
show :: ImportsType -> String
$cshow :: ImportsType -> String
showsPrec :: Int -> ImportsType -> String -> String
$cshowsPrec :: Int -> ImportsType -> String -> String
Show, Typeable, Typeable ImportsType
Constr
DataType
Typeable ImportsType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ImportsType -> c ImportsType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportsType)
-> (ImportsType -> Constr)
-> (ImportsType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportsType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImportsType))
-> ((forall b. Data b => b -> b) -> ImportsType -> ImportsType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportsType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportsType -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImportsType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImportsType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImportsType -> m ImportsType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportsType -> m ImportsType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImportsType -> m ImportsType)
-> Data ImportsType
ImportsType -> Constr
ImportsType -> DataType
(forall b. Data b => b -> b) -> ImportsType -> ImportsType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportsType -> c ImportsType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportsType
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) -> ImportsType -> u
forall u. (forall d. Data d => d -> u) -> ImportsType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportsType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportsType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportsType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportsType -> c ImportsType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportsType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportsType)
$cITGlobal :: Constr
$cITLocal :: Constr
$tImportsType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
gmapMp :: (forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
gmapM :: (forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportsType -> m ImportsType
gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportsType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportsType -> u
gmapQ :: (forall d. Data d => d -> u) -> ImportsType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportsType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportsType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportsType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportsType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportsType -> r
gmapT :: (forall b. Data b => b -> b) -> ImportsType -> ImportsType
$cgmapT :: (forall b. Data b => b -> b) -> ImportsType -> ImportsType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportsType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportsType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ImportsType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportsType)
dataTypeOf :: ImportsType -> DataType
$cdataTypeOf :: ImportsType -> DataType
toConstr :: ImportsType -> Constr
$ctoConstr :: ImportsType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportsType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportsType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportsType -> c ImportsType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportsType -> c ImportsType
$cp1Data :: Typeable ImportsType
Data)

-- | Imports (for Theory)
data Imports =
  Imports
    {
        Imports -> IRI
importsFrom :: OMDocRef
      , Imports -> Maybe Morphism
importsMorphism :: Maybe Morphism
      , Imports -> Maybe String
importsId :: Maybe XmlId
      , Imports -> ImportsType
importsType :: ImportsType
      , Imports -> Conservativity
importsConservativity :: Conservativity
    }
    deriving (Int -> Imports -> String -> String
[Imports] -> String -> String
Imports -> String
(Int -> Imports -> String -> String)
-> (Imports -> String)
-> ([Imports] -> String -> String)
-> Show Imports
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Imports] -> String -> String
$cshowList :: [Imports] -> String -> String
show :: Imports -> String
$cshow :: Imports -> String
showsPrec :: Int -> Imports -> String -> String
$cshowsPrec :: Int -> Imports -> String -> String
Show, Typeable, Typeable Imports
Constr
DataType
Typeable Imports =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Imports -> c Imports)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Imports)
-> (Imports -> Constr)
-> (Imports -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Imports))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports))
-> ((forall b. Data b => b -> b) -> Imports -> Imports)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Imports -> r)
-> (forall u. (forall d. Data d => d -> u) -> Imports -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Imports -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Imports -> m Imports)
-> Data Imports
Imports -> Constr
Imports -> DataType
(forall b. Data b => b -> b) -> Imports -> Imports
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Imports -> c Imports
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Imports
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) -> Imports -> u
forall u. (forall d. Data d => d -> u) -> Imports -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Imports -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Imports -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Imports -> m Imports
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Imports -> m Imports
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Imports
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Imports -> c Imports
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Imports)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports)
$cImports :: Constr
$tImports :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Imports -> m Imports
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Imports -> m Imports
gmapMp :: (forall d. Data d => d -> m d) -> Imports -> m Imports
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Imports -> m Imports
gmapM :: (forall d. Data d => d -> m d) -> Imports -> m Imports
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Imports -> m Imports
gmapQi :: Int -> (forall d. Data d => d -> u) -> Imports -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Imports -> u
gmapQ :: (forall d. Data d => d -> u) -> Imports -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Imports -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Imports -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Imports -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Imports -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Imports -> r
gmapT :: (forall b. Data b => b -> b) -> Imports -> Imports
$cgmapT :: (forall b. Data b => b -> b) -> Imports -> Imports
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Imports)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Imports)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Imports)
dataTypeOf :: Imports -> DataType
$cdataTypeOf :: Imports -> DataType
toConstr :: Imports -> Constr
$ctoConstr :: Imports -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Imports
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Imports
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Imports -> c Imports
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Imports -> c Imports
$cp1Data :: Typeable Imports
Data)

-- | Presentation
data Presentation =
  Presentation
    {
        Presentation -> String
presentationForId :: XmlId
      , Presentation -> Maybe String
presentationSystem :: Maybe XmlString
      , Presentation -> [Use]
presentationUses :: [Use]
    }
    deriving (Int -> Presentation -> String -> String
[Presentation] -> String -> String
Presentation -> String
(Int -> Presentation -> String -> String)
-> (Presentation -> String)
-> ([Presentation] -> String -> String)
-> Show Presentation
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Presentation] -> String -> String
$cshowList :: [Presentation] -> String -> String
show :: Presentation -> String
$cshow :: Presentation -> String
showsPrec :: Int -> Presentation -> String -> String
$cshowsPrec :: Int -> Presentation -> String -> String
Show, Presentation -> Presentation -> Bool
(Presentation -> Presentation -> Bool)
-> (Presentation -> Presentation -> Bool) -> Eq Presentation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Presentation -> Presentation -> Bool
$c/= :: Presentation -> Presentation -> Bool
== :: Presentation -> Presentation -> Bool
$c== :: Presentation -> Presentation -> Bool
Eq, Typeable, Typeable Presentation
Constr
DataType
Typeable Presentation =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Presentation -> c Presentation)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Presentation)
-> (Presentation -> Constr)
-> (Presentation -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Presentation))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Presentation))
-> ((forall b. Data b => b -> b) -> Presentation -> Presentation)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Presentation -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Presentation -> r)
-> (forall u. (forall d. Data d => d -> u) -> Presentation -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Presentation -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Presentation -> m Presentation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Presentation -> m Presentation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Presentation -> m Presentation)
-> Data Presentation
Presentation -> Constr
Presentation -> DataType
(forall b. Data b => b -> b) -> Presentation -> Presentation
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Presentation -> c Presentation
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Presentation
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) -> Presentation -> u
forall u. (forall d. Data d => d -> u) -> Presentation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Presentation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Presentation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Presentation -> m Presentation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Presentation -> m Presentation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Presentation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Presentation -> c Presentation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Presentation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Presentation)
$cPresentation :: Constr
$tPresentation :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Presentation -> m Presentation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Presentation -> m Presentation
gmapMp :: (forall d. Data d => d -> m d) -> Presentation -> m Presentation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Presentation -> m Presentation
gmapM :: (forall d. Data d => d -> m d) -> Presentation -> m Presentation
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Presentation -> m Presentation
gmapQi :: Int -> (forall d. Data d => d -> u) -> Presentation -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Presentation -> u
gmapQ :: (forall d. Data d => d -> u) -> Presentation -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Presentation -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Presentation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Presentation -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Presentation -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Presentation -> r
gmapT :: (forall b. Data b => b -> b) -> Presentation -> Presentation
$cgmapT :: (forall b. Data b => b -> b) -> Presentation -> Presentation
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Presentation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Presentation)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Presentation)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Presentation)
dataTypeOf :: Presentation -> DataType
$cdataTypeOf :: Presentation -> DataType
toConstr :: Presentation -> Constr
$ctoConstr :: Presentation -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Presentation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Presentation
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Presentation -> c Presentation
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Presentation -> c Presentation
$cp1Data :: Typeable Presentation
Data)

mkPresentationS :: XmlId -> XmlString -> [Use] -> Presentation
mkPresentationS :: String -> String -> [Use] -> Presentation
mkPresentationS forid :: String
forid presSystem :: String
presSystem = String -> Maybe String -> [Use] -> Presentation
Presentation String
forid (String -> Maybe String
forall a. a -> Maybe a
Just String
presSystem)

mkPresentation :: XmlId -> [Use] -> Presentation
mkPresentation :: String -> [Use] -> Presentation
mkPresentation forid :: String
forid = String -> Maybe String -> [Use] -> Presentation
Presentation String
forid Maybe String
forall a. Maybe a
Nothing

addUse :: Presentation -> Use -> Presentation
addUse :: Presentation -> Use -> Presentation
addUse pres :: Presentation
pres use :: Use
use = Presentation
pres { presentationUses :: [Use]
presentationUses = Presentation -> [Use]
presentationUses Presentation
pres [Use] -> [Use] -> [Use]
forall a. [a] -> [a] -> [a]
++ [Use
use] }

-- | Use for Presentation
data Use =
  Use
    {
        Use -> String
useFormat :: XmlString
      , Use -> String
useValue :: String
    }
    deriving (Int -> Use -> String -> String
[Use] -> String -> String
Use -> String
(Int -> Use -> String -> String)
-> (Use -> String) -> ([Use] -> String -> String) -> Show Use
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Use] -> String -> String
$cshowList :: [Use] -> String -> String
show :: Use -> String
$cshow :: Use -> String
showsPrec :: Int -> Use -> String -> String
$cshowsPrec :: Int -> Use -> String -> String
Show, Use -> Use -> Bool
(Use -> Use -> Bool) -> (Use -> Use -> Bool) -> Eq Use
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Use -> Use -> Bool
$c/= :: Use -> Use -> Bool
== :: Use -> Use -> Bool
$c== :: Use -> Use -> Bool
Eq, Typeable, Typeable Use
Constr
DataType
Typeable Use =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Use -> c Use)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Use)
-> (Use -> Constr)
-> (Use -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Use))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Use))
-> ((forall b. Data b => b -> b) -> Use -> Use)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r)
-> (forall u. (forall d. Data d => d -> u) -> Use -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Use -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Use -> m Use)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Use -> m Use)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Use -> m Use)
-> Data Use
Use -> Constr
Use -> DataType
(forall b. Data b => b -> b) -> Use -> Use
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Use -> c Use
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Use
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) -> Use -> u
forall u. (forall d. Data d => d -> u) -> Use -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Use -> m Use
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Use -> m Use
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Use
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Use -> c Use
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Use)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Use)
$cUse :: Constr
$tUse :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Use -> m Use
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Use -> m Use
gmapMp :: (forall d. Data d => d -> m d) -> Use -> m Use
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Use -> m Use
gmapM :: (forall d. Data d => d -> m d) -> Use -> m Use
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Use -> m Use
gmapQi :: Int -> (forall d. Data d => d -> u) -> Use -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Use -> u
gmapQ :: (forall d. Data d => d -> u) -> Use -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Use -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Use -> r
gmapT :: (forall b. Data b => b -> b) -> Use -> Use
$cgmapT :: (forall b. Data b => b -> b) -> Use -> Use
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Use)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Use)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Use)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Use)
dataTypeOf :: Use -> DataType
$cdataTypeOf :: Use -> DataType
toConstr :: Use -> Constr
$ctoConstr :: Use -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Use
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Use
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Use -> c Use
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Use -> c Use
$cp1Data :: Typeable Use
Data)

mkUse :: XmlString -> String -> Use
mkUse :: String -> String -> Use
mkUse = String -> String -> Use
Use

-- | SymbolRole for Symbol
data SymbolRole =
    SRType
  | SRSort
  | SRObject
  | SRBinder
  | SRAttribution
  | SRSemanticAttribution
  | SRError
  deriving (SymbolRole -> SymbolRole -> Bool
(SymbolRole -> SymbolRole -> Bool)
-> (SymbolRole -> SymbolRole -> Bool) -> Eq SymbolRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SymbolRole -> SymbolRole -> Bool
$c/= :: SymbolRole -> SymbolRole -> Bool
== :: SymbolRole -> SymbolRole -> Bool
$c== :: SymbolRole -> SymbolRole -> Bool
Eq, Eq SymbolRole
Eq SymbolRole =>
(SymbolRole -> SymbolRole -> Ordering)
-> (SymbolRole -> SymbolRole -> Bool)
-> (SymbolRole -> SymbolRole -> Bool)
-> (SymbolRole -> SymbolRole -> Bool)
-> (SymbolRole -> SymbolRole -> Bool)
-> (SymbolRole -> SymbolRole -> SymbolRole)
-> (SymbolRole -> SymbolRole -> SymbolRole)
-> Ord SymbolRole
SymbolRole -> SymbolRole -> Bool
SymbolRole -> SymbolRole -> Ordering
SymbolRole -> SymbolRole -> SymbolRole
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 :: SymbolRole -> SymbolRole -> SymbolRole
$cmin :: SymbolRole -> SymbolRole -> SymbolRole
max :: SymbolRole -> SymbolRole -> SymbolRole
$cmax :: SymbolRole -> SymbolRole -> SymbolRole
>= :: SymbolRole -> SymbolRole -> Bool
$c>= :: SymbolRole -> SymbolRole -> Bool
> :: SymbolRole -> SymbolRole -> Bool
$c> :: SymbolRole -> SymbolRole -> Bool
<= :: SymbolRole -> SymbolRole -> Bool
$c<= :: SymbolRole -> SymbolRole -> Bool
< :: SymbolRole -> SymbolRole -> Bool
$c< :: SymbolRole -> SymbolRole -> Bool
compare :: SymbolRole -> SymbolRole -> Ordering
$ccompare :: SymbolRole -> SymbolRole -> Ordering
$cp1Ord :: Eq SymbolRole
Ord, Typeable, Typeable SymbolRole
Constr
DataType
Typeable SymbolRole =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SymbolRole -> c SymbolRole)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SymbolRole)
-> (SymbolRole -> Constr)
-> (SymbolRole -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SymbolRole))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SymbolRole))
-> ((forall b. Data b => b -> b) -> SymbolRole -> SymbolRole)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SymbolRole -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SymbolRole -> r)
-> (forall u. (forall d. Data d => d -> u) -> SymbolRole -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SymbolRole -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole)
-> Data SymbolRole
SymbolRole -> Constr
SymbolRole -> DataType
(forall b. Data b => b -> b) -> SymbolRole -> SymbolRole
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymbolRole -> c SymbolRole
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymbolRole
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) -> SymbolRole -> u
forall u. (forall d. Data d => d -> u) -> SymbolRole -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolRole -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolRole -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymbolRole
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymbolRole -> c SymbolRole
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymbolRole)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymbolRole)
$cSRError :: Constr
$cSRSemanticAttribution :: Constr
$cSRAttribution :: Constr
$cSRBinder :: Constr
$cSRObject :: Constr
$cSRSort :: Constr
$cSRType :: Constr
$tSymbolRole :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
gmapMp :: (forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
gmapM :: (forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SymbolRole -> m SymbolRole
gmapQi :: Int -> (forall d. Data d => d -> u) -> SymbolRole -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SymbolRole -> u
gmapQ :: (forall d. Data d => d -> u) -> SymbolRole -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SymbolRole -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolRole -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolRole -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolRole -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolRole -> r
gmapT :: (forall b. Data b => b -> b) -> SymbolRole -> SymbolRole
$cgmapT :: (forall b. Data b => b -> b) -> SymbolRole -> SymbolRole
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymbolRole)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymbolRole)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SymbolRole)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymbolRole)
dataTypeOf :: SymbolRole -> DataType
$cdataTypeOf :: SymbolRole -> DataType
toConstr :: SymbolRole -> Constr
$ctoConstr :: SymbolRole -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymbolRole
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymbolRole
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymbolRole -> c SymbolRole
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymbolRole -> c SymbolRole
$cp1Data :: Typeable SymbolRole
Data)

instance Show SymbolRole where
  show :: SymbolRole -> String
show SRType = "type"
  show SRSort = "sort"
  show SRObject = "object"
  show SRBinder = "binder"
  show SRAttribution = "attribution"
  show SRSemanticAttribution = "semantic-attribution"
  show SRError = "error"

instance Read SymbolRole where
  readsPrec :: Int -> ReadS SymbolRole
readsPrec _ s :: String
s =
    case (Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
s of
      "type" -> [(SymbolRole
SRType, [])]
      "sort" -> [(SymbolRole
SRSort, [])]
      "object" -> [(SymbolRole
SRObject, [])]
      "binder" -> [(SymbolRole
SRBinder, [])]
      "attribution" -> [(SymbolRole
SRAttribution, [])]
      "semantic-attribution" -> [(SymbolRole
SRSemanticAttribution, [])]
      "error" -> [(SymbolRole
SRError, [])]
      _ -> []

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

instance GetRange Symbol

instance Pretty Symbol where
  pretty :: Symbol -> Doc
pretty s :: Symbol
s =
   String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Symbol -> String
forall a. Show a => a -> String
show Symbol
s

mkSymbolE :: Maybe XmlId -> XmlId -> SymbolRole -> Maybe Type -> Symbol
mkSymbolE :: Maybe String -> String -> SymbolRole -> Maybe Type -> Symbol
mkSymbolE = Maybe String -> String -> SymbolRole -> Maybe Type -> Symbol
Symbol

mkSymbol :: XmlId -> SymbolRole -> Symbol
mkSymbol :: String -> SymbolRole -> Symbol
mkSymbol xid :: String
xid sr :: SymbolRole
sr = Maybe String -> String -> SymbolRole -> Maybe Type -> Symbol
mkSymbolE Maybe String
forall a. Maybe a
Nothing String
xid SymbolRole
sr Maybe Type
forall a. Maybe a
Nothing

-- | Type
data Type =
  Type
    {
        Type -> Maybe IRI
typeSystem :: Maybe IRI.IRI
      , Type -> OMDocMathObject
typeOMDocMathObject :: OMDocMathObject
    }
    deriving (Int -> Type -> String -> String
[Type] -> String -> String
Type -> String
(Int -> Type -> String -> String)
-> (Type -> String) -> ([Type] -> String -> String) -> Show Type
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Type] -> String -> String
$cshowList :: [Type] -> String -> String
show :: Type -> String
$cshow :: Type -> String
showsPrec :: Int -> Type -> String -> String
$cshowsPrec :: Int -> Type -> String -> String
Show, 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, 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, Typeable, Typeable Type
Constr
DataType
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 -> Constr
Type -> DataType
(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)
$cType :: 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)

mkType :: Maybe OMDocRef -> OMDocMathObject -> Type
mkType :: Maybe IRI -> OMDocMathObject -> Type
mkType = Maybe IRI -> OMDocMathObject -> Type
Type

{- |
  OMDoc Theory constitutive elements + convenience additions (ADT)
-}
data Constitutive =
    CAx Axiom
  | CDe Definition
  | CSy Symbol
  | CIm Imports
  | CAd ADT
  | CCo { Constitutive -> String
conComCmt :: String, Constitutive -> Constitutive
conComCon :: Constitutive }
  deriving (Int -> Constitutive -> String -> String
[Constitutive] -> String -> String
Constitutive -> String
(Int -> Constitutive -> String -> String)
-> (Constitutive -> String)
-> ([Constitutive] -> String -> String)
-> Show Constitutive
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Constitutive] -> String -> String
$cshowList :: [Constitutive] -> String -> String
show :: Constitutive -> String
$cshow :: Constitutive -> String
showsPrec :: Int -> Constitutive -> String -> String
$cshowsPrec :: Int -> Constitutive -> String -> String
Show, Typeable, Typeable Constitutive
Constr
DataType
Typeable Constitutive =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Constitutive -> c Constitutive)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Constitutive)
-> (Constitutive -> Constr)
-> (Constitutive -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Constitutive))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Constitutive))
-> ((forall b. Data b => b -> b) -> Constitutive -> Constitutive)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Constitutive -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Constitutive -> r)
-> (forall u. (forall d. Data d => d -> u) -> Constitutive -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Constitutive -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Constitutive -> m Constitutive)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Constitutive -> m Constitutive)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Constitutive -> m Constitutive)
-> Data Constitutive
Constitutive -> Constr
Constitutive -> DataType
(forall b. Data b => b -> b) -> Constitutive -> Constitutive
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constitutive -> c Constitutive
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constitutive
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) -> Constitutive -> u
forall u. (forall d. Data d => d -> u) -> Constitutive -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constitutive -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constitutive -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constitutive
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constitutive -> c Constitutive
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constitutive)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Constitutive)
$cCCo :: Constr
$cCAd :: Constr
$cCIm :: Constr
$cCSy :: Constr
$cCDe :: Constr
$cCAx :: Constr
$tConstitutive :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
gmapMp :: (forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
gmapM :: (forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constitutive -> m Constitutive
gmapQi :: Int -> (forall d. Data d => d -> u) -> Constitutive -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Constitutive -> u
gmapQ :: (forall d. Data d => d -> u) -> Constitutive -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Constitutive -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constitutive -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constitutive -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constitutive -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constitutive -> r
gmapT :: (forall b. Data b => b -> b) -> Constitutive -> Constitutive
$cgmapT :: (forall b. Data b => b -> b) -> Constitutive -> Constitutive
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Constitutive)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Constitutive)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Constitutive)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constitutive)
dataTypeOf :: Constitutive -> DataType
$cdataTypeOf :: Constitutive -> DataType
toConstr :: Constitutive -> Constr
$ctoConstr :: Constitutive -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constitutive
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constitutive
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constitutive -> c Constitutive
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constitutive -> c Constitutive
$cp1Data :: Typeable Constitutive
Data)

mkCAx :: Axiom -> Constitutive
mkCAx :: Axiom -> Constitutive
mkCAx = Axiom -> Constitutive
CAx
mkCDe :: Definition -> Constitutive
mkCDe :: Definition -> Constitutive
mkCDe = Definition -> Constitutive
CDe
mkCSy :: Symbol -> Constitutive
mkCSy :: Symbol -> Constitutive
mkCSy = Symbol -> Constitutive
CSy
mkCIm :: Imports -> Constitutive
mkCIm :: Imports -> Constitutive
mkCIm = Imports -> Constitutive
CIm
mkCAd :: ADT -> Constitutive
mkCAd :: ADT -> Constitutive
mkCAd = ADT -> Constitutive
CAd
mkCCo :: String -> Constitutive -> Constitutive
mkCCo :: String -> Constitutive -> Constitutive
mkCCo = String -> Constitutive -> Constitutive
CCo

isAxiom :: Constitutive -> Bool
isAxiom :: Constitutive -> Bool
isAxiom (CAx {}) = Bool
True
isAxiom _ = Bool
False

isDefinition :: Constitutive -> Bool
isDefinition :: Constitutive -> Bool
isDefinition (CDe {}) = Bool
True
isDefinition _ = Bool
False

isSymbol :: Constitutive -> Bool
isSymbol :: Constitutive -> Bool
isSymbol (CSy {}) = Bool
True
isSymbol _ = Bool
False

isImports :: Constitutive -> Bool
isImports :: Constitutive -> Bool
isImports (CIm {}) = Bool
True
isImports _ = Bool
False

isADT :: Constitutive -> Bool
isADT :: Constitutive -> Bool
isADT (CAd {}) = Bool
True
isADT _ = Bool
False

isCommented :: Constitutive -> Bool
isCommented :: Constitutive -> Bool
isCommented (CCo {}) = Bool
True
isCommented _ = Bool
False

getIdsForPresentation :: Constitutive -> [XmlId]
getIdsForPresentation :: Constitutive -> [String]
getIdsForPresentation (CAx a :: Axiom
a) = [Axiom -> String
axiomName Axiom
a]
getIdsForPresentation (CDe _) = []
getIdsForPresentation (CSy s :: Symbol
s) = [Symbol -> String
symbolId Symbol
s]
getIdsForPresentation (CIm _) = []
getIdsForPresentation (CAd a :: ADT
a) = (SortDef -> String) -> [SortDef] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map SortDef -> String
sortDefName (ADT -> [SortDef]
adtSortDefs ADT
a)
getIdsForPresentation (CCo {}) = []

-- | Axiom
data Axiom =
  Axiom
    {
        Axiom -> String
axiomName :: XmlId
      , Axiom -> [CMP]
axiomCMPs :: [CMP]
      , Axiom -> [FMP]
axiomFMPs :: [FMP]
    }
    deriving (Int -> Axiom -> String -> String
[Axiom] -> String -> String
Axiom -> String
(Int -> Axiom -> String -> String)
-> (Axiom -> String) -> ([Axiom] -> String -> String) -> Show Axiom
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Axiom] -> String -> String
$cshowList :: [Axiom] -> String -> String
show :: Axiom -> String
$cshow :: Axiom -> String
showsPrec :: Int -> Axiom -> String -> String
$cshowsPrec :: Int -> Axiom -> String -> String
Show, Typeable, Typeable Axiom
Constr
DataType
Typeable Axiom =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Axiom -> c Axiom)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Axiom)
-> (Axiom -> Constr)
-> (Axiom -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Axiom))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom))
-> ((forall b. Data b => b -> b) -> Axiom -> Axiom)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r)
-> (forall u. (forall d. Data d => d -> u) -> Axiom -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Axiom -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Axiom -> m Axiom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Axiom -> m Axiom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Axiom -> m Axiom)
-> Data Axiom
Axiom -> Constr
Axiom -> DataType
(forall b. Data b => b -> b) -> Axiom -> Axiom
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
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) -> Axiom -> u
forall u. (forall d. Data d => d -> u) -> Axiom -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Axiom)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom)
$cAxiom :: Constr
$tAxiom :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Axiom -> m Axiom
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
gmapMp :: (forall d. Data d => d -> m d) -> Axiom -> m Axiom
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
gmapM :: (forall d. Data d => d -> m d) -> Axiom -> m Axiom
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Axiom -> m Axiom
gmapQi :: Int -> (forall d. Data d => d -> u) -> Axiom -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Axiom -> u
gmapQ :: (forall d. Data d => d -> u) -> Axiom -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Axiom -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Axiom -> r
gmapT :: (forall b. Data b => b -> b) -> Axiom -> Axiom
$cgmapT :: (forall b. Data b => b -> b) -> Axiom -> Axiom
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Axiom)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Axiom)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Axiom)
dataTypeOf :: Axiom -> DataType
$cdataTypeOf :: Axiom -> DataType
toConstr :: Axiom -> Constr
$ctoConstr :: Axiom -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Axiom
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Axiom -> c Axiom
$cp1Data :: Typeable Axiom
Data)

mkAxiom :: XmlId -> [CMP] -> [FMP] -> Axiom
mkAxiom :: String -> [CMP] -> [FMP] -> Axiom
mkAxiom = String -> [CMP] -> [FMP] -> Axiom
Axiom

-- | CMP
data CMP =
  CMP
    {
      CMP -> MText
cmpContent :: MText
    }
  deriving (Int -> CMP -> String -> String
[CMP] -> String -> String
CMP -> String
(Int -> CMP -> String -> String)
-> (CMP -> String) -> ([CMP] -> String -> String) -> Show CMP
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [CMP] -> String -> String
$cshowList :: [CMP] -> String -> String
show :: CMP -> String
$cshow :: CMP -> String
showsPrec :: Int -> CMP -> String -> String
$cshowsPrec :: Int -> CMP -> String -> String
Show, Typeable, Typeable CMP
Constr
DataType
Typeable CMP =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CMP -> c CMP)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CMP)
-> (CMP -> Constr)
-> (CMP -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CMP))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMP))
-> ((forall b. Data b => b -> b) -> CMP -> CMP)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r)
-> (forall u. (forall d. Data d => d -> u) -> CMP -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CMP -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CMP -> m CMP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CMP -> m CMP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CMP -> m CMP)
-> Data CMP
CMP -> Constr
CMP -> DataType
(forall b. Data b => b -> b) -> CMP -> CMP
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMP -> c CMP
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMP
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) -> CMP -> u
forall u. (forall d. Data d => d -> u) -> CMP -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CMP -> m CMP
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CMP -> m CMP
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMP
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMP -> c CMP
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CMP)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMP)
$cCMP :: Constr
$tCMP :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CMP -> m CMP
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CMP -> m CMP
gmapMp :: (forall d. Data d => d -> m d) -> CMP -> m CMP
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CMP -> m CMP
gmapM :: (forall d. Data d => d -> m d) -> CMP -> m CMP
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CMP -> m CMP
gmapQi :: Int -> (forall d. Data d => d -> u) -> CMP -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CMP -> u
gmapQ :: (forall d. Data d => d -> u) -> CMP -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CMP -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMP -> r
gmapT :: (forall b. Data b => b -> b) -> CMP -> CMP
$cgmapT :: (forall b. Data b => b -> b) -> CMP -> CMP
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMP)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMP)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CMP)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CMP)
dataTypeOf :: CMP -> DataType
$cdataTypeOf :: CMP -> DataType
toConstr :: CMP -> Constr
$ctoConstr :: CMP -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMP
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMP
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMP -> c CMP
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMP -> c CMP
$cp1Data :: Typeable CMP
Data)

mkCMP :: MText -> CMP
mkCMP :: MText -> CMP
mkCMP = MText -> CMP
CMP

-- | FMP
data FMP =
  FMP
    {
        FMP -> Maybe String
fmpLogic :: Maybe XmlString
      , FMP -> Either OMObject ([Assumption], [Conclusion])
fmpContent :: Either OMObject ([Assumption], [Conclusion])
    }
  deriving (Int -> FMP -> String -> String
[FMP] -> String -> String
FMP -> String
(Int -> FMP -> String -> String)
-> (FMP -> String) -> ([FMP] -> String -> String) -> Show FMP
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [FMP] -> String -> String
$cshowList :: [FMP] -> String -> String
show :: FMP -> String
$cshow :: FMP -> String
showsPrec :: Int -> FMP -> String -> String
$cshowsPrec :: Int -> FMP -> String -> String
Show, Typeable, Typeable FMP
Constr
DataType
Typeable FMP =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FMP -> c FMP)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FMP)
-> (FMP -> Constr)
-> (FMP -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FMP))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FMP))
-> ((forall b. Data b => b -> b) -> FMP -> FMP)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r)
-> (forall u. (forall d. Data d => d -> u) -> FMP -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FMP -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FMP -> m FMP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FMP -> m FMP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FMP -> m FMP)
-> Data FMP
FMP -> Constr
FMP -> DataType
(forall b. Data b => b -> b) -> FMP -> FMP
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMP -> c FMP
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FMP
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) -> FMP -> u
forall u. (forall d. Data d => d -> u) -> FMP -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FMP -> m FMP
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FMP -> m FMP
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FMP
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMP -> c FMP
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FMP)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FMP)
$cFMP :: Constr
$tFMP :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FMP -> m FMP
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FMP -> m FMP
gmapMp :: (forall d. Data d => d -> m d) -> FMP -> m FMP
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FMP -> m FMP
gmapM :: (forall d. Data d => d -> m d) -> FMP -> m FMP
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FMP -> m FMP
gmapQi :: Int -> (forall d. Data d => d -> u) -> FMP -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FMP -> u
gmapQ :: (forall d. Data d => d -> u) -> FMP -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FMP -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FMP -> r
gmapT :: (forall b. Data b => b -> b) -> FMP -> FMP
$cgmapT :: (forall b. Data b => b -> b) -> FMP -> FMP
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FMP)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FMP)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FMP)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FMP)
dataTypeOf :: FMP -> DataType
$cdataTypeOf :: FMP -> DataType
toConstr :: FMP -> Constr
$ctoConstr :: FMP -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FMP
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FMP
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMP -> c FMP
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMP -> c FMP
$cp1Data :: Typeable FMP
Data)

-- | Assumption (incomplete)
data Assumption = Assumption
  deriving (Int -> Assumption -> String -> String
[Assumption] -> String -> String
Assumption -> String
(Int -> Assumption -> String -> String)
-> (Assumption -> String)
-> ([Assumption] -> String -> String)
-> Show Assumption
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Assumption] -> String -> String
$cshowList :: [Assumption] -> String -> String
show :: Assumption -> String
$cshow :: Assumption -> String
showsPrec :: Int -> Assumption -> String -> String
$cshowsPrec :: Int -> Assumption -> String -> String
Show, Typeable, Typeable Assumption
Constr
DataType
Typeable Assumption =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Assumption -> c Assumption)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Assumption)
-> (Assumption -> Constr)
-> (Assumption -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Assumption))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Assumption))
-> ((forall b. Data b => b -> b) -> Assumption -> Assumption)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Assumption -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Assumption -> r)
-> (forall u. (forall d. Data d => d -> u) -> Assumption -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Assumption -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Assumption -> m Assumption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assumption -> m Assumption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assumption -> m Assumption)
-> Data Assumption
Assumption -> Constr
Assumption -> DataType
(forall b. Data b => b -> b) -> Assumption -> Assumption
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assumption -> c Assumption
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assumption
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) -> Assumption -> u
forall u. (forall d. Data d => d -> u) -> Assumption -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assumption -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assumption -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assumption -> m Assumption
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assumption -> m Assumption
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assumption
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assumption -> c Assumption
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assumption)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assumption)
$cAssumption :: Constr
$tAssumption :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Assumption -> m Assumption
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assumption -> m Assumption
gmapMp :: (forall d. Data d => d -> m d) -> Assumption -> m Assumption
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assumption -> m Assumption
gmapM :: (forall d. Data d => d -> m d) -> Assumption -> m Assumption
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assumption -> m Assumption
gmapQi :: Int -> (forall d. Data d => d -> u) -> Assumption -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Assumption -> u
gmapQ :: (forall d. Data d => d -> u) -> Assumption -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Assumption -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assumption -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Assumption -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assumption -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Assumption -> r
gmapT :: (forall b. Data b => b -> b) -> Assumption -> Assumption
$cgmapT :: (forall b. Data b => b -> b) -> Assumption -> Assumption
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assumption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assumption)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Assumption)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assumption)
dataTypeOf :: Assumption -> DataType
$cdataTypeOf :: Assumption -> DataType
toConstr :: Assumption -> Constr
$ctoConstr :: Assumption -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assumption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assumption
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assumption -> c Assumption
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assumption -> c Assumption
$cp1Data :: Typeable Assumption
Data)

data Conclusion = Conclusion
  deriving (Int -> Conclusion -> String -> String
[Conclusion] -> String -> String
Conclusion -> String
(Int -> Conclusion -> String -> String)
-> (Conclusion -> String)
-> ([Conclusion] -> String -> String)
-> Show Conclusion
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Conclusion] -> String -> String
$cshowList :: [Conclusion] -> String -> String
show :: Conclusion -> String
$cshow :: Conclusion -> String
showsPrec :: Int -> Conclusion -> String -> String
$cshowsPrec :: Int -> Conclusion -> String -> String
Show, Typeable, Typeable Conclusion
Constr
DataType
Typeable Conclusion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Conclusion -> c Conclusion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Conclusion)
-> (Conclusion -> Constr)
-> (Conclusion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Conclusion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Conclusion))
-> ((forall b. Data b => b -> b) -> Conclusion -> Conclusion)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Conclusion -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Conclusion -> r)
-> (forall u. (forall d. Data d => d -> u) -> Conclusion -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Conclusion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Conclusion -> m Conclusion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Conclusion -> m Conclusion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Conclusion -> m Conclusion)
-> Data Conclusion
Conclusion -> Constr
Conclusion -> DataType
(forall b. Data b => b -> b) -> Conclusion -> Conclusion
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conclusion -> c Conclusion
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conclusion
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) -> Conclusion -> u
forall u. (forall d. Data d => d -> u) -> Conclusion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conclusion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conclusion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conclusion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conclusion -> c Conclusion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Conclusion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Conclusion)
$cConclusion :: Constr
$tConclusion :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
gmapMp :: (forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
gmapM :: (forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Conclusion -> m Conclusion
gmapQi :: Int -> (forall d. Data d => d -> u) -> Conclusion -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Conclusion -> u
gmapQ :: (forall d. Data d => d -> u) -> Conclusion -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Conclusion -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conclusion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conclusion -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conclusion -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conclusion -> r
gmapT :: (forall b. Data b => b -> b) -> Conclusion -> Conclusion
$cgmapT :: (forall b. Data b => b -> b) -> Conclusion -> Conclusion
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Conclusion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Conclusion)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Conclusion)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Conclusion)
dataTypeOf :: Conclusion -> DataType
$cdataTypeOf :: Conclusion -> DataType
toConstr :: Conclusion -> Constr
$ctoConstr :: Conclusion -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conclusion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conclusion
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conclusion -> c Conclusion
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conclusion -> c Conclusion
$cp1Data :: Typeable Conclusion
Data)

-- | Definition (incomplete)
data Definition =
  Definition
    {
        Definition -> String
definitionId :: XmlId
      , Definition -> [CMP]
definitionCMPs :: [CMP]
      , Definition -> [FMP]
definitionFMPs :: [FMP]
    }
  deriving (Int -> Definition -> String -> String
[Definition] -> String -> String
Definition -> String
(Int -> Definition -> String -> String)
-> (Definition -> String)
-> ([Definition] -> String -> String)
-> Show Definition
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Definition] -> String -> String
$cshowList :: [Definition] -> String -> String
show :: Definition -> String
$cshow :: Definition -> String
showsPrec :: Int -> Definition -> String -> String
$cshowsPrec :: Int -> Definition -> String -> String
Show, Typeable, Typeable Definition
Constr
DataType
Typeable Definition =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Definition -> c Definition)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Definition)
-> (Definition -> Constr)
-> (Definition -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Definition))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Definition))
-> ((forall b. Data b => b -> b) -> Definition -> Definition)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Definition -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Definition -> r)
-> (forall u. (forall d. Data d => d -> u) -> Definition -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Definition -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Definition -> m Definition)
-> Data Definition
Definition -> Constr
Definition -> DataType
(forall b. Data b => b -> b) -> Definition -> Definition
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
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) -> Definition -> u
forall u. (forall d. Data d => d -> u) -> Definition -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Definition)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
$cDefinition :: Constr
$tDefinition :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapMp :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapM :: (forall d. Data d => d -> m d) -> Definition -> m Definition
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Definition -> m Definition
gmapQi :: Int -> (forall d. Data d => d -> u) -> Definition -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Definition -> u
gmapQ :: (forall d. Data d => d -> u) -> Definition -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Definition -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Definition -> r
gmapT :: (forall b. Data b => b -> b) -> Definition -> Definition
$cgmapT :: (forall b. Data b => b -> b) -> Definition -> Definition
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Definition)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Definition)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Definition)
dataTypeOf :: Definition -> DataType
$cdataTypeOf :: Definition -> DataType
toConstr :: Definition -> Constr
$ctoConstr :: Definition -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Definition
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Definition -> c Definition
$cp1Data :: Typeable Definition
Data)

mkDefinition :: XmlId -> [CMP] -> [FMP] -> Definition
mkDefinition :: String -> [CMP] -> [FMP] -> Definition
mkDefinition = String -> [CMP] -> [FMP] -> Definition
Definition

-- | ADT
data ADT =
  ADT
    {
        ADT -> Maybe String
adtId :: Maybe XmlId
      , ADT -> [SortDef]
adtSortDefs :: [SortDef]
    }
  deriving (Int -> ADT -> String -> String
[ADT] -> String -> String
ADT -> String
(Int -> ADT -> String -> String)
-> (ADT -> String) -> ([ADT] -> String -> String) -> Show ADT
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ADT] -> String -> String
$cshowList :: [ADT] -> String -> String
show :: ADT -> String
$cshow :: ADT -> String
showsPrec :: Int -> ADT -> String -> String
$cshowsPrec :: Int -> ADT -> String -> String
Show, Typeable, Typeable ADT
Constr
DataType
Typeable ADT =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ADT -> c ADT)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ADT)
-> (ADT -> Constr)
-> (ADT -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ADT))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADT))
-> ((forall b. Data b => b -> b) -> ADT -> ADT)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r)
-> (forall u. (forall d. Data d => d -> u) -> ADT -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ADT -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ADT -> m ADT)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ADT -> m ADT)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ADT -> m ADT)
-> Data ADT
ADT -> Constr
ADT -> DataType
(forall b. Data b => b -> b) -> ADT -> ADT
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ADT -> c ADT
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ADT
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) -> ADT -> u
forall u. (forall d. Data d => d -> u) -> ADT -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ADT -> m ADT
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADT -> m ADT
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ADT
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ADT -> c ADT
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ADT)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADT)
$cADT :: Constr
$tADT :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ADT -> m ADT
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADT -> m ADT
gmapMp :: (forall d. Data d => d -> m d) -> ADT -> m ADT
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ADT -> m ADT
gmapM :: (forall d. Data d => d -> m d) -> ADT -> m ADT
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ADT -> m ADT
gmapQi :: Int -> (forall d. Data d => d -> u) -> ADT -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ADT -> u
gmapQ :: (forall d. Data d => d -> u) -> ADT -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ADT -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ADT -> r
gmapT :: (forall b. Data b => b -> b) -> ADT -> ADT
$cgmapT :: (forall b. Data b => b -> b) -> ADT -> ADT
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADT)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ADT)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ADT)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ADT)
dataTypeOf :: ADT -> DataType
$cdataTypeOf :: ADT -> DataType
toConstr :: ADT -> Constr
$ctoConstr :: ADT -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ADT
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ADT
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ADT -> c ADT
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ADT -> c ADT
$cp1Data :: Typeable ADT
Data)

data SortType = STFree | STGenerated | STLoose deriving (Typeable, Typeable SortType
Constr
DataType
Typeable SortType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SortType -> c SortType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SortType)
-> (SortType -> Constr)
-> (SortType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SortType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortType))
-> ((forall b. Data b => b -> b) -> SortType -> SortType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SortType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SortType -> r)
-> (forall u. (forall d. Data d => d -> u) -> SortType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SortType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SortType -> m SortType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SortType -> m SortType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SortType -> m SortType)
-> Data SortType
SortType -> Constr
SortType -> DataType
(forall b. Data b => b -> b) -> SortType -> SortType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortType -> c SortType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortType
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) -> SortType -> u
forall u. (forall d. Data d => d -> u) -> SortType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortType -> m SortType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortType -> m SortType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortType -> c SortType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortType)
$cSTLoose :: Constr
$cSTGenerated :: Constr
$cSTFree :: Constr
$tSortType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SortType -> m SortType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortType -> m SortType
gmapMp :: (forall d. Data d => d -> m d) -> SortType -> m SortType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortType -> m SortType
gmapM :: (forall d. Data d => d -> m d) -> SortType -> m SortType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortType -> m SortType
gmapQi :: Int -> (forall d. Data d => d -> u) -> SortType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SortType -> u
gmapQ :: (forall d. Data d => d -> u) -> SortType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SortType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortType -> r
gmapT :: (forall b. Data b => b -> b) -> SortType -> SortType
$cgmapT :: (forall b. Data b => b -> b) -> SortType -> SortType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SortType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortType)
dataTypeOf :: SortType -> DataType
$cdataTypeOf :: SortType -> DataType
toConstr :: SortType -> Constr
$ctoConstr :: SortType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortType -> c SortType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortType -> c SortType
$cp1Data :: Typeable SortType
Data)

mkADT :: [SortDef] -> ADT
mkADT :: [SortDef] -> ADT
mkADT = Maybe String -> [SortDef] -> ADT
ADT Maybe String
forall a. Maybe a
Nothing

mkADTEx :: Maybe XmlId -> [SortDef] -> ADT
mkADTEx :: Maybe String -> [SortDef] -> ADT
mkADTEx = Maybe String -> [SortDef] -> ADT
ADT

instance Show SortType where
  show :: SortType -> String
show STFree = "free"
  show STGenerated = "generated"
  show STLoose = "loose"

instance Read SortType where
  readsPrec :: Int -> ReadS SortType
readsPrec _ s :: String
s
   | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "free" = [(SortType
STFree, "")]
   | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "generated" = [(SortType
STGenerated, "")]
   | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== "loose" = [(SortType
STLoose, "")]
   | Bool
otherwise = []

-- | SortDef
data SortDef =
  SortDef
    {
        SortDef -> String
sortDefName :: XmlId
      , SortDef -> SymbolRole
sortDefRole :: SymbolRole
      , SortDef -> SortType
sortDefType :: SortType
      , SortDef -> [Constructor]
sortDefConstructors :: [Constructor]
      , SortDef -> [Insort]
sortDefInsorts :: [Insort]
      , SortDef -> [Recognizer]
sortDefRecognizers :: [Recognizer]
    }
  deriving (Int -> SortDef -> String -> String
[SortDef] -> String -> String
SortDef -> String
(Int -> SortDef -> String -> String)
-> (SortDef -> String)
-> ([SortDef] -> String -> String)
-> Show SortDef
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [SortDef] -> String -> String
$cshowList :: [SortDef] -> String -> String
show :: SortDef -> String
$cshow :: SortDef -> String
showsPrec :: Int -> SortDef -> String -> String
$cshowsPrec :: Int -> SortDef -> String -> String
Show, Typeable, Typeable SortDef
Constr
DataType
Typeable SortDef =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SortDef -> c SortDef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SortDef)
-> (SortDef -> Constr)
-> (SortDef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SortDef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortDef))
-> ((forall b. Data b => b -> b) -> SortDef -> SortDef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SortDef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SortDef -> r)
-> (forall u. (forall d. Data d => d -> u) -> SortDef -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SortDef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SortDef -> m SortDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SortDef -> m SortDef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SortDef -> m SortDef)
-> Data SortDef
SortDef -> Constr
SortDef -> DataType
(forall b. Data b => b -> b) -> SortDef -> SortDef
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortDef -> c SortDef
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortDef
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) -> SortDef -> u
forall u. (forall d. Data d => d -> u) -> SortDef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortDef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortDef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortDef -> m SortDef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortDef -> m SortDef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortDef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortDef -> c SortDef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortDef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortDef)
$cSortDef :: Constr
$tSortDef :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SortDef -> m SortDef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortDef -> m SortDef
gmapMp :: (forall d. Data d => d -> m d) -> SortDef -> m SortDef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SortDef -> m SortDef
gmapM :: (forall d. Data d => d -> m d) -> SortDef -> m SortDef
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SortDef -> m SortDef
gmapQi :: Int -> (forall d. Data d => d -> u) -> SortDef -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SortDef -> u
gmapQ :: (forall d. Data d => d -> u) -> SortDef -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SortDef -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortDef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SortDef -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortDef -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SortDef -> r
gmapT :: (forall b. Data b => b -> b) -> SortDef -> SortDef
$cgmapT :: (forall b. Data b => b -> b) -> SortDef -> SortDef
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortDef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SortDef)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SortDef)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SortDef)
dataTypeOf :: SortDef -> DataType
$cdataTypeOf :: SortDef -> DataType
toConstr :: SortDef -> Constr
$ctoConstr :: SortDef -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortDef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SortDef
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortDef -> c SortDef
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SortDef -> c SortDef
$cp1Data :: Typeable SortDef
Data)

mkSortDefE :: XmlId -> SymbolRole -> SortType -> [Constructor] -> [Insort] -> [Recognizer] -> SortDef
mkSortDefE :: String
-> SymbolRole
-> SortType
-> [Constructor]
-> [Insort]
-> [Recognizer]
-> SortDef
mkSortDefE = String
-> SymbolRole
-> SortType
-> [Constructor]
-> [Insort]
-> [Recognizer]
-> SortDef
SortDef

mkSortDef :: XmlId -> [Constructor] -> [Insort] -> [Recognizer] -> SortDef
mkSortDef :: String -> [Constructor] -> [Insort] -> [Recognizer] -> SortDef
mkSortDef xid :: String
xid = String
-> SymbolRole
-> SortType
-> [Constructor]
-> [Insort]
-> [Recognizer]
-> SortDef
mkSortDefE String
xid SymbolRole
SRSort SortType
STFree

-- | Constructor
data Constructor =
  Constructor
    {
        Constructor -> String
constructorName :: XmlId
      , Constructor -> SymbolRole
constructorRole :: SymbolRole
      , Constructor -> [Type]
constructorArguments :: [Type]
    }
  deriving (Int -> Constructor -> String -> String
[Constructor] -> String -> String
Constructor -> String
(Int -> Constructor -> String -> String)
-> (Constructor -> String)
-> ([Constructor] -> String -> String)
-> Show Constructor
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Constructor] -> String -> String
$cshowList :: [Constructor] -> String -> String
show :: Constructor -> String
$cshow :: Constructor -> String
showsPrec :: Int -> Constructor -> String -> String
$cshowsPrec :: Int -> Constructor -> String -> String
Show, Typeable, Typeable Constructor
Constr
DataType
Typeable Constructor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Constructor -> c Constructor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Constructor)
-> (Constructor -> Constr)
-> (Constructor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Constructor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Constructor))
-> ((forall b. Data b => b -> b) -> Constructor -> Constructor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Constructor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Constructor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Constructor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Constructor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Constructor -> m Constructor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Constructor -> m Constructor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Constructor -> m Constructor)
-> Data Constructor
Constructor -> Constr
Constructor -> DataType
(forall b. Data b => b -> b) -> Constructor -> Constructor
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constructor -> c Constructor
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constructor
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) -> Constructor -> u
forall u. (forall d. Data d => d -> u) -> Constructor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constructor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constructor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constructor -> m Constructor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constructor -> m Constructor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constructor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constructor -> c Constructor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constructor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Constructor)
$cConstructor :: Constr
$tConstructor :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Constructor -> m Constructor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constructor -> m Constructor
gmapMp :: (forall d. Data d => d -> m d) -> Constructor -> m Constructor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constructor -> m Constructor
gmapM :: (forall d. Data d => d -> m d) -> Constructor -> m Constructor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constructor -> m Constructor
gmapQi :: Int -> (forall d. Data d => d -> u) -> Constructor -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Constructor -> u
gmapQ :: (forall d. Data d => d -> u) -> Constructor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Constructor -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constructor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constructor -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constructor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constructor -> r
gmapT :: (forall b. Data b => b -> b) -> Constructor -> Constructor
$cgmapT :: (forall b. Data b => b -> b) -> Constructor -> Constructor
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Constructor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Constructor)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Constructor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constructor)
dataTypeOf :: Constructor -> DataType
$cdataTypeOf :: Constructor -> DataType
toConstr :: Constructor -> Constr
$ctoConstr :: Constructor -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constructor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constructor
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constructor -> c Constructor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constructor -> c Constructor
$cp1Data :: Typeable Constructor
Data)

mkConstructorE :: XmlId -> SymbolRole -> [Type] -> Constructor
mkConstructorE :: String -> SymbolRole -> [Type] -> Constructor
mkConstructorE = String -> SymbolRole -> [Type] -> Constructor
Constructor

mkConstructor :: XmlId -> [Type] -> Constructor
mkConstructor :: String -> [Type] -> Constructor
mkConstructor xid :: String
xid = String -> SymbolRole -> [Type] -> Constructor
Constructor String
xid SymbolRole
SRObject

-- | Insort
data Insort =
  Insort
    {
      Insort -> IRI
insortFor :: OMDocRef
    }
  deriving (Int -> Insort -> String -> String
[Insort] -> String -> String
Insort -> String
(Int -> Insort -> String -> String)
-> (Insort -> String)
-> ([Insort] -> String -> String)
-> Show Insort
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Insort] -> String -> String
$cshowList :: [Insort] -> String -> String
show :: Insort -> String
$cshow :: Insort -> String
showsPrec :: Int -> Insort -> String -> String
$cshowsPrec :: Int -> Insort -> String -> String
Show, Typeable, Typeable Insort
Constr
DataType
Typeable Insort =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Insort -> c Insort)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Insort)
-> (Insort -> Constr)
-> (Insort -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Insort))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Insort))
-> ((forall b. Data b => b -> b) -> Insort -> Insort)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Insort -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Insort -> r)
-> (forall u. (forall d. Data d => d -> u) -> Insort -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Insort -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Insort -> m Insort)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Insort -> m Insort)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Insort -> m Insort)
-> Data Insort
Insort -> Constr
Insort -> DataType
(forall b. Data b => b -> b) -> Insort -> Insort
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Insort -> c Insort
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Insort
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) -> Insort -> u
forall u. (forall d. Data d => d -> u) -> Insort -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Insort -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Insort -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Insort -> m Insort
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Insort -> m Insort
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Insort
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Insort -> c Insort
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Insort)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Insort)
$cInsort :: Constr
$tInsort :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Insort -> m Insort
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Insort -> m Insort
gmapMp :: (forall d. Data d => d -> m d) -> Insort -> m Insort
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Insort -> m Insort
gmapM :: (forall d. Data d => d -> m d) -> Insort -> m Insort
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Insort -> m Insort
gmapQi :: Int -> (forall d. Data d => d -> u) -> Insort -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Insort -> u
gmapQ :: (forall d. Data d => d -> u) -> Insort -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Insort -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Insort -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Insort -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Insort -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Insort -> r
gmapT :: (forall b. Data b => b -> b) -> Insort -> Insort
$cgmapT :: (forall b. Data b => b -> b) -> Insort -> Insort
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Insort)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Insort)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Insort)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Insort)
dataTypeOf :: Insort -> DataType
$cdataTypeOf :: Insort -> DataType
toConstr :: Insort -> Constr
$ctoConstr :: Insort -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Insort
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Insort
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Insort -> c Insort
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Insort -> c Insort
$cp1Data :: Typeable Insort
Data)

mkInsort :: OMDocRef -> Insort
mkInsort :: IRI -> Insort
mkInsort = IRI -> Insort
Insort

-- | Recognizer
data Recognizer =
  Recognizer
    {
      Recognizer -> String
recognizerName :: XmlId
    }
  deriving (Int -> Recognizer -> String -> String
[Recognizer] -> String -> String
Recognizer -> String
(Int -> Recognizer -> String -> String)
-> (Recognizer -> String)
-> ([Recognizer] -> String -> String)
-> Show Recognizer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Recognizer] -> String -> String
$cshowList :: [Recognizer] -> String -> String
show :: Recognizer -> String
$cshow :: Recognizer -> String
showsPrec :: Int -> Recognizer -> String -> String
$cshowsPrec :: Int -> Recognizer -> String -> String
Show, Typeable, Typeable Recognizer
Constr
DataType
Typeable Recognizer =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Recognizer -> c Recognizer)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Recognizer)
-> (Recognizer -> Constr)
-> (Recognizer -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Recognizer))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Recognizer))
-> ((forall b. Data b => b -> b) -> Recognizer -> Recognizer)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Recognizer -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Recognizer -> r)
-> (forall u. (forall d. Data d => d -> u) -> Recognizer -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Recognizer -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Recognizer -> m Recognizer)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Recognizer -> m Recognizer)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Recognizer -> m Recognizer)
-> Data Recognizer
Recognizer -> Constr
Recognizer -> DataType
(forall b. Data b => b -> b) -> Recognizer -> Recognizer
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recognizer -> c Recognizer
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Recognizer
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) -> Recognizer -> u
forall u. (forall d. Data d => d -> u) -> Recognizer -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Recognizer -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Recognizer -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Recognizer
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recognizer -> c Recognizer
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Recognizer)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Recognizer)
$cRecognizer :: Constr
$tRecognizer :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
gmapMp :: (forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
gmapM :: (forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Recognizer -> m Recognizer
gmapQi :: Int -> (forall d. Data d => d -> u) -> Recognizer -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Recognizer -> u
gmapQ :: (forall d. Data d => d -> u) -> Recognizer -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Recognizer -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Recognizer -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Recognizer -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Recognizer -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Recognizer -> r
gmapT :: (forall b. Data b => b -> b) -> Recognizer -> Recognizer
$cgmapT :: (forall b. Data b => b -> b) -> Recognizer -> Recognizer
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Recognizer)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Recognizer)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Recognizer)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Recognizer)
dataTypeOf :: Recognizer -> DataType
$cdataTypeOf :: Recognizer -> DataType
toConstr :: Recognizer -> Constr
$ctoConstr :: Recognizer -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Recognizer
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Recognizer
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recognizer -> c Recognizer
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Recognizer -> c Recognizer
$cp1Data :: Typeable Recognizer
Data)

mkRecognizer :: XmlId -> Recognizer
mkRecognizer :: String -> Recognizer
mkRecognizer = String -> Recognizer
Recognizer

-- | Inclusion-Conservativity
data Conservativity = CNone | CMonomorphism | CDefinitional | CConservative
  deriving (Conservativity -> Conservativity -> Bool
(Conservativity -> Conservativity -> Bool)
-> (Conservativity -> Conservativity -> Bool) -> Eq Conservativity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Conservativity -> Conservativity -> Bool
$c/= :: Conservativity -> Conservativity -> Bool
== :: Conservativity -> Conservativity -> Bool
$c== :: Conservativity -> Conservativity -> Bool
Eq, Eq Conservativity
Eq Conservativity =>
(Conservativity -> Conservativity -> Ordering)
-> (Conservativity -> Conservativity -> Bool)
-> (Conservativity -> Conservativity -> Bool)
-> (Conservativity -> Conservativity -> Bool)
-> (Conservativity -> Conservativity -> Bool)
-> (Conservativity -> Conservativity -> Conservativity)
-> (Conservativity -> Conservativity -> Conservativity)
-> Ord Conservativity
Conservativity -> Conservativity -> Bool
Conservativity -> Conservativity -> Ordering
Conservativity -> Conservativity -> Conservativity
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 :: Conservativity -> Conservativity -> Conservativity
$cmin :: Conservativity -> Conservativity -> Conservativity
max :: Conservativity -> Conservativity -> Conservativity
$cmax :: Conservativity -> Conservativity -> Conservativity
>= :: Conservativity -> Conservativity -> Bool
$c>= :: Conservativity -> Conservativity -> Bool
> :: Conservativity -> Conservativity -> Bool
$c> :: Conservativity -> Conservativity -> Bool
<= :: Conservativity -> Conservativity -> Bool
$c<= :: Conservativity -> Conservativity -> Bool
< :: Conservativity -> Conservativity -> Bool
$c< :: Conservativity -> Conservativity -> Bool
compare :: Conservativity -> Conservativity -> Ordering
$ccompare :: Conservativity -> Conservativity -> Ordering
$cp1Ord :: Eq Conservativity
Ord, Typeable, Typeable Conservativity
Constr
DataType
Typeable Conservativity =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Conservativity -> c Conservativity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Conservativity)
-> (Conservativity -> Constr)
-> (Conservativity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Conservativity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Conservativity))
-> ((forall b. Data b => b -> b)
    -> Conservativity -> Conservativity)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Conservativity -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Conservativity -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Conservativity -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Conservativity -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Conservativity -> m Conservativity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Conservativity -> m Conservativity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Conservativity -> m Conservativity)
-> Data Conservativity
Conservativity -> Constr
Conservativity -> DataType
(forall b. Data b => b -> b) -> Conservativity -> Conservativity
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conservativity -> c Conservativity
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conservativity
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) -> Conservativity -> u
forall u. (forall d. Data d => d -> u) -> Conservativity -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conservativity -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conservativity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conservativity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conservativity -> c Conservativity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Conservativity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Conservativity)
$cCConservative :: Constr
$cCDefinitional :: Constr
$cCMonomorphism :: Constr
$cCNone :: Constr
$tConservativity :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
gmapMp :: (forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
gmapM :: (forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Conservativity -> m Conservativity
gmapQi :: Int -> (forall d. Data d => d -> u) -> Conservativity -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Conservativity -> u
gmapQ :: (forall d. Data d => d -> u) -> Conservativity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Conservativity -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conservativity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Conservativity -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conservativity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Conservativity -> r
gmapT :: (forall b. Data b => b -> b) -> Conservativity -> Conservativity
$cgmapT :: (forall b. Data b => b -> b) -> Conservativity -> Conservativity
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Conservativity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Conservativity)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Conservativity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Conservativity)
dataTypeOf :: Conservativity -> DataType
$cdataTypeOf :: Conservativity -> DataType
toConstr :: Conservativity -> Constr
$ctoConstr :: Conservativity -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conservativity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Conservativity
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conservativity -> c Conservativity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Conservativity -> c Conservativity
$cp1Data :: Typeable Conservativity
Data)

instance Show Conservativity where
  show :: Conservativity -> String
show CNone = "none"
  show CMonomorphism = "monomorphism"
  show CDefinitional = "definitional"
  show CConservative = "conservative"

instance Read Conservativity where
  readsPrec :: Int -> ReadS Conservativity
readsPrec _ s :: String
s =
    case String
s of
      "monomorphism" -> [(Conservativity
CMonomorphism, "")]
      "definitional" -> [(Conservativity
CDefinitional, "")]
      "conservative" -> [(Conservativity
CConservative, "")]
      "none" -> [(Conservativity
CNone, "")]
      _ -> []

-- | Inclusions
data Inclusion =
    TheoryInclusion
      {
          Inclusion -> IRI
inclusionFrom :: OMDocRef
        , Inclusion -> IRI
inclusionTo :: OMDocRef
        , Inclusion -> Maybe Morphism
inclusionMorphism :: Maybe Morphism
        , Inclusion -> Maybe String
inclusionId :: Maybe XmlId
        , Inclusion -> Conservativity
inclusionConservativity :: Conservativity
      }
  | AxiomInclusion
      {
          inclusionFrom :: OMDocRef
        , inclusionTo :: OMDocRef
        , inclusionMorphism :: Maybe Morphism
        , inclusionId :: Maybe XmlId
        , inclusionConservativity :: Conservativity
      }
  deriving (Int -> Inclusion -> String -> String
[Inclusion] -> String -> String
Inclusion -> String
(Int -> Inclusion -> String -> String)
-> (Inclusion -> String)
-> ([Inclusion] -> String -> String)
-> Show Inclusion
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Inclusion] -> String -> String
$cshowList :: [Inclusion] -> String -> String
show :: Inclusion -> String
$cshow :: Inclusion -> String
showsPrec :: Int -> Inclusion -> String -> String
$cshowsPrec :: Int -> Inclusion -> String -> String
Show, Inclusion -> Inclusion -> Bool
(Inclusion -> Inclusion -> Bool)
-> (Inclusion -> Inclusion -> Bool) -> Eq Inclusion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Inclusion -> Inclusion -> Bool
$c/= :: Inclusion -> Inclusion -> Bool
== :: Inclusion -> Inclusion -> Bool
$c== :: Inclusion -> Inclusion -> Bool
Eq, Eq Inclusion
Eq Inclusion =>
(Inclusion -> Inclusion -> Ordering)
-> (Inclusion -> Inclusion -> Bool)
-> (Inclusion -> Inclusion -> Bool)
-> (Inclusion -> Inclusion -> Bool)
-> (Inclusion -> Inclusion -> Bool)
-> (Inclusion -> Inclusion -> Inclusion)
-> (Inclusion -> Inclusion -> Inclusion)
-> Ord Inclusion
Inclusion -> Inclusion -> Bool
Inclusion -> Inclusion -> Ordering
Inclusion -> Inclusion -> Inclusion
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 :: Inclusion -> Inclusion -> Inclusion
$cmin :: Inclusion -> Inclusion -> Inclusion
max :: Inclusion -> Inclusion -> Inclusion
$cmax :: Inclusion -> Inclusion -> Inclusion
>= :: Inclusion -> Inclusion -> Bool
$c>= :: Inclusion -> Inclusion -> Bool
> :: Inclusion -> Inclusion -> Bool
$c> :: Inclusion -> Inclusion -> Bool
<= :: Inclusion -> Inclusion -> Bool
$c<= :: Inclusion -> Inclusion -> Bool
< :: Inclusion -> Inclusion -> Bool
$c< :: Inclusion -> Inclusion -> Bool
compare :: Inclusion -> Inclusion -> Ordering
$ccompare :: Inclusion -> Inclusion -> Ordering
$cp1Ord :: Eq Inclusion
Ord, Typeable, Typeable Inclusion
Constr
DataType
Typeable Inclusion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Inclusion -> c Inclusion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inclusion)
-> (Inclusion -> Constr)
-> (Inclusion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inclusion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inclusion))
-> ((forall b. Data b => b -> b) -> Inclusion -> Inclusion)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Inclusion -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Inclusion -> r)
-> (forall u. (forall d. Data d => d -> u) -> Inclusion -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Inclusion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Inclusion -> m Inclusion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inclusion -> m Inclusion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Inclusion -> m Inclusion)
-> Data Inclusion
Inclusion -> Constr
Inclusion -> DataType
(forall b. Data b => b -> b) -> Inclusion -> Inclusion
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inclusion -> c Inclusion
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inclusion
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) -> Inclusion -> u
forall u. (forall d. Data d => d -> u) -> Inclusion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inclusion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inclusion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inclusion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inclusion -> c Inclusion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inclusion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inclusion)
$cAxiomInclusion :: Constr
$cTheoryInclusion :: Constr
$tInclusion :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
gmapMp :: (forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
gmapM :: (forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Inclusion -> m Inclusion
gmapQi :: Int -> (forall d. Data d => d -> u) -> Inclusion -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Inclusion -> u
gmapQ :: (forall d. Data d => d -> u) -> Inclusion -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Inclusion -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inclusion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inclusion -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inclusion -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inclusion -> r
gmapT :: (forall b. Data b => b -> b) -> Inclusion -> Inclusion
$cgmapT :: (forall b. Data b => b -> b) -> Inclusion -> Inclusion
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inclusion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inclusion)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Inclusion)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inclusion)
dataTypeOf :: Inclusion -> DataType
$cdataTypeOf :: Inclusion -> DataType
toConstr :: Inclusion -> Constr
$ctoConstr :: Inclusion -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inclusion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inclusion
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inclusion -> c Inclusion
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inclusion -> c Inclusion
$cp1Data :: Typeable Inclusion
Data)

instance Pretty Inclusion where
  pretty :: Inclusion -> Doc
pretty = String -> Doc
text (String -> Doc) -> (Inclusion -> String) -> Inclusion -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Inclusion -> String
forall a. Show a => a -> String
show

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

instance Pretty Morphism where
  pretty :: Morphism -> Doc
pretty m :: Morphism
m = String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ Morphism -> String
forall a. Show a => a -> String
show Morphism
m

-- Mathematical Text (incomplete)
data MText = MTextText String | MTextTerm String | MTextPhrase String | MTextOM OMObject
  deriving (Int -> MText -> String -> String
[MText] -> String -> String
MText -> String
(Int -> MText -> String -> String)
-> (MText -> String) -> ([MText] -> String -> String) -> Show MText
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [MText] -> String -> String
$cshowList :: [MText] -> String -> String
show :: MText -> String
$cshow :: MText -> String
showsPrec :: Int -> MText -> String -> String
$cshowsPrec :: Int -> MText -> String -> String
Show, MText -> MText -> Bool
(MText -> MText -> Bool) -> (MText -> MText -> Bool) -> Eq MText
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MText -> MText -> Bool
$c/= :: MText -> MText -> Bool
== :: MText -> MText -> Bool
$c== :: MText -> MText -> Bool
Eq, Eq MText
Eq MText =>
(MText -> MText -> Ordering)
-> (MText -> MText -> Bool)
-> (MText -> MText -> Bool)
-> (MText -> MText -> Bool)
-> (MText -> MText -> Bool)
-> (MText -> MText -> MText)
-> (MText -> MText -> MText)
-> Ord MText
MText -> MText -> Bool
MText -> MText -> Ordering
MText -> MText -> MText
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 :: MText -> MText -> MText
$cmin :: MText -> MText -> MText
max :: MText -> MText -> MText
$cmax :: MText -> MText -> MText
>= :: MText -> MText -> Bool
$c>= :: MText -> MText -> Bool
> :: MText -> MText -> Bool
$c> :: MText -> MText -> Bool
<= :: MText -> MText -> Bool
$c<= :: MText -> MText -> Bool
< :: MText -> MText -> Bool
$c< :: MText -> MText -> Bool
compare :: MText -> MText -> Ordering
$ccompare :: MText -> MText -> Ordering
$cp1Ord :: Eq MText
Ord, Typeable, Typeable MText
Constr
DataType
Typeable MText =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MText -> c MText)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MText)
-> (MText -> Constr)
-> (MText -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MText))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MText))
-> ((forall b. Data b => b -> b) -> MText -> MText)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r)
-> (forall u. (forall d. Data d => d -> u) -> MText -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MText -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MText -> m MText)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MText -> m MText)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MText -> m MText)
-> Data MText
MText -> Constr
MText -> DataType
(forall b. Data b => b -> b) -> MText -> MText
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MText -> c MText
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MText
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) -> MText -> u
forall u. (forall d. Data d => d -> u) -> MText -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MText -> m MText
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MText -> m MText
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MText
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MText -> c MText
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MText)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MText)
$cMTextOM :: Constr
$cMTextPhrase :: Constr
$cMTextTerm :: Constr
$cMTextText :: Constr
$tMText :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MText -> m MText
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MText -> m MText
gmapMp :: (forall d. Data d => d -> m d) -> MText -> m MText
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MText -> m MText
gmapM :: (forall d. Data d => d -> m d) -> MText -> m MText
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MText -> m MText
gmapQi :: Int -> (forall d. Data d => d -> u) -> MText -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MText -> u
gmapQ :: (forall d. Data d => d -> u) -> MText -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MText -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MText -> r
gmapT :: (forall b. Data b => b -> b) -> MText -> MText
$cgmapT :: (forall b. Data b => b -> b) -> MText -> MText
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MText)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MText)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MText)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MText)
dataTypeOf :: MText -> DataType
$cdataTypeOf :: MText -> DataType
toConstr :: MText -> Constr
$ctoConstr :: MText -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MText
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MText
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MText -> c MText
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MText -> c MText
$cp1Data :: Typeable MText
Data)

-- OMDoc Mathematical Object
data OMDocMathObject = OMOMOBJ OMObject | OMLegacy String | OMMath String
  deriving (Int -> OMDocMathObject -> String -> String
[OMDocMathObject] -> String -> String
OMDocMathObject -> String
(Int -> OMDocMathObject -> String -> String)
-> (OMDocMathObject -> String)
-> ([OMDocMathObject] -> String -> String)
-> Show OMDocMathObject
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [OMDocMathObject] -> String -> String
$cshowList :: [OMDocMathObject] -> String -> String
show :: OMDocMathObject -> String
$cshow :: OMDocMathObject -> String
showsPrec :: Int -> OMDocMathObject -> String -> String
$cshowsPrec :: Int -> OMDocMathObject -> String -> String
Show, OMDocMathObject -> OMDocMathObject -> Bool
(OMDocMathObject -> OMDocMathObject -> Bool)
-> (OMDocMathObject -> OMDocMathObject -> Bool)
-> Eq OMDocMathObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OMDocMathObject -> OMDocMathObject -> Bool
$c/= :: OMDocMathObject -> OMDocMathObject -> Bool
== :: OMDocMathObject -> OMDocMathObject -> Bool
$c== :: OMDocMathObject -> OMDocMathObject -> Bool
Eq, Eq OMDocMathObject
Eq OMDocMathObject =>
(OMDocMathObject -> OMDocMathObject -> Ordering)
-> (OMDocMathObject -> OMDocMathObject -> Bool)
-> (OMDocMathObject -> OMDocMathObject -> Bool)
-> (OMDocMathObject -> OMDocMathObject -> Bool)
-> (OMDocMathObject -> OMDocMathObject -> Bool)
-> (OMDocMathObject -> OMDocMathObject -> OMDocMathObject)
-> (OMDocMathObject -> OMDocMathObject -> OMDocMathObject)
-> Ord OMDocMathObject
OMDocMathObject -> OMDocMathObject -> Bool
OMDocMathObject -> OMDocMathObject -> Ordering
OMDocMathObject -> OMDocMathObject -> OMDocMathObject
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 :: OMDocMathObject -> OMDocMathObject -> OMDocMathObject
$cmin :: OMDocMathObject -> OMDocMathObject -> OMDocMathObject
max :: OMDocMathObject -> OMDocMathObject -> OMDocMathObject
$cmax :: OMDocMathObject -> OMDocMathObject -> OMDocMathObject
>= :: OMDocMathObject -> OMDocMathObject -> Bool
$c>= :: OMDocMathObject -> OMDocMathObject -> Bool
> :: OMDocMathObject -> OMDocMathObject -> Bool
$c> :: OMDocMathObject -> OMDocMathObject -> Bool
<= :: OMDocMathObject -> OMDocMathObject -> Bool
$c<= :: OMDocMathObject -> OMDocMathObject -> Bool
< :: OMDocMathObject -> OMDocMathObject -> Bool
$c< :: OMDocMathObject -> OMDocMathObject -> Bool
compare :: OMDocMathObject -> OMDocMathObject -> Ordering
$ccompare :: OMDocMathObject -> OMDocMathObject -> Ordering
$cp1Ord :: Eq OMDocMathObject
Ord, Typeable, Typeable OMDocMathObject
Constr
DataType
Typeable OMDocMathObject =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OMDocMathObject -> c OMDocMathObject)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OMDocMathObject)
-> (OMDocMathObject -> Constr)
-> (OMDocMathObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OMDocMathObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OMDocMathObject))
-> ((forall b. Data b => b -> b)
    -> OMDocMathObject -> OMDocMathObject)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> OMDocMathObject -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OMDocMathObject -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> OMDocMathObject -> m OMDocMathObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OMDocMathObject -> m OMDocMathObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OMDocMathObject -> m OMDocMathObject)
-> Data OMDocMathObject
OMDocMathObject -> Constr
OMDocMathObject -> DataType
(forall b. Data b => b -> b) -> OMDocMathObject -> OMDocMathObject
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDocMathObject -> c OMDocMathObject
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDocMathObject
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) -> OMDocMathObject -> u
forall u. (forall d. Data d => d -> u) -> OMDocMathObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDocMathObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDocMathObject -> c OMDocMathObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMDocMathObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OMDocMathObject)
$cOMMath :: Constr
$cOMLegacy :: Constr
$cOMOMOBJ :: Constr
$tOMDocMathObject :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
gmapMp :: (forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
gmapM :: (forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OMDocMathObject -> m OMDocMathObject
gmapQi :: Int -> (forall d. Data d => d -> u) -> OMDocMathObject -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OMDocMathObject -> u
gmapQ :: (forall d. Data d => d -> u) -> OMDocMathObject -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OMDocMathObject -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMDocMathObject -> r
gmapT :: (forall b. Data b => b -> b) -> OMDocMathObject -> OMDocMathObject
$cgmapT :: (forall b. Data b => b -> b) -> OMDocMathObject -> OMDocMathObject
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OMDocMathObject)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OMDocMathObject)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OMDocMathObject)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMDocMathObject)
dataTypeOf :: OMDocMathObject -> DataType
$cdataTypeOf :: OMDocMathObject -> DataType
toConstr :: OMDocMathObject -> Constr
$ctoConstr :: OMDocMathObject -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDocMathObject
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMDocMathObject
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDocMathObject -> c OMDocMathObject
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMDocMathObject -> c OMDocMathObject
$cp1Data :: Typeable OMDocMathObject
Data)

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

mkOMOBJ :: OMElementClass e => e -> OMObject
mkOMOBJ :: e -> OMObject
mkOMOBJ e :: e
e = OMElement -> OMObject
OMObject (e -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement e
e)

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

mkOMS :: Maybe OMDocRef -> XmlId -> XmlId -> OMSymbol
mkOMS :: Maybe IRI -> String -> String -> OMSymbol
mkOMS = Maybe IRI -> String -> String -> OMSymbol
OMS

mkOMSE :: Maybe OMDocRef -> XmlId -> XmlId -> OMElement
mkOMSE :: Maybe IRI -> String -> String -> OMElement
mkOMSE mref :: Maybe IRI
mref xcd :: String
xcd xid :: String
xid = OMSymbol -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMSymbol -> OMElement) -> OMSymbol -> OMElement
forall a b. (a -> b) -> a -> b
$ Maybe IRI -> String -> String -> OMSymbol
mkOMS Maybe IRI
mref String
xcd String
xid

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

mkOMI :: Int -> OMInteger
mkOMI :: Int -> OMInteger
mkOMI = Int -> OMInteger
OMI

mkOMIE :: Int -> OMElement
mkOMIE :: Int -> OMElement
mkOMIE i :: Int
i = OMInteger -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMInteger -> OMElement) -> OMInteger -> OMElement
forall a b. (a -> b) -> a -> b
$ Int -> OMInteger
mkOMI Int
i

-- | A Variable can be a OMV or an OMATTR
data OMVariable = OMVS OMSimpleVariable | OMVA OMAttribution
    deriving (Int -> OMVariable -> String -> String
[OMVariable] -> String -> String
OMVariable -> String
(Int -> OMVariable -> String -> String)
-> (OMVariable -> String)
-> ([OMVariable] -> String -> String)
-> Show OMVariable
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [OMVariable] -> String -> String
$cshowList :: [OMVariable] -> String -> String
show :: OMVariable -> String
$cshow :: OMVariable -> String
showsPrec :: Int -> OMVariable -> String -> String
$cshowsPrec :: Int -> OMVariable -> String -> String
Show, OMVariable -> OMVariable -> Bool
(OMVariable -> OMVariable -> Bool)
-> (OMVariable -> OMVariable -> Bool) -> Eq OMVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OMVariable -> OMVariable -> Bool
$c/= :: OMVariable -> OMVariable -> Bool
== :: OMVariable -> OMVariable -> Bool
$c== :: OMVariable -> OMVariable -> Bool
Eq, Eq OMVariable
Eq OMVariable =>
(OMVariable -> OMVariable -> Ordering)
-> (OMVariable -> OMVariable -> Bool)
-> (OMVariable -> OMVariable -> Bool)
-> (OMVariable -> OMVariable -> Bool)
-> (OMVariable -> OMVariable -> Bool)
-> (OMVariable -> OMVariable -> OMVariable)
-> (OMVariable -> OMVariable -> OMVariable)
-> Ord OMVariable
OMVariable -> OMVariable -> Bool
OMVariable -> OMVariable -> Ordering
OMVariable -> OMVariable -> OMVariable
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 :: OMVariable -> OMVariable -> OMVariable
$cmin :: OMVariable -> OMVariable -> OMVariable
max :: OMVariable -> OMVariable -> OMVariable
$cmax :: OMVariable -> OMVariable -> OMVariable
>= :: OMVariable -> OMVariable -> Bool
$c>= :: OMVariable -> OMVariable -> Bool
> :: OMVariable -> OMVariable -> Bool
$c> :: OMVariable -> OMVariable -> Bool
<= :: OMVariable -> OMVariable -> Bool
$c<= :: OMVariable -> OMVariable -> Bool
< :: OMVariable -> OMVariable -> Bool
$c< :: OMVariable -> OMVariable -> Bool
compare :: OMVariable -> OMVariable -> Ordering
$ccompare :: OMVariable -> OMVariable -> Ordering
$cp1Ord :: Eq OMVariable
Ord, Typeable, Typeable OMVariable
Constr
DataType
Typeable OMVariable =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OMVariable -> c OMVariable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OMVariable)
-> (OMVariable -> Constr)
-> (OMVariable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OMVariable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OMVariable))
-> ((forall b. Data b => b -> b) -> OMVariable -> OMVariable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OMVariable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OMVariable -> r)
-> (forall u. (forall d. Data d => d -> u) -> OMVariable -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OMVariable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OMVariable -> m OMVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMVariable -> m OMVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMVariable -> m OMVariable)
-> Data OMVariable
OMVariable -> Constr
OMVariable -> DataType
(forall b. Data b => b -> b) -> OMVariable -> OMVariable
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMVariable -> c OMVariable
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMVariable
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) -> OMVariable -> u
forall u. (forall d. Data d => d -> u) -> OMVariable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMVariable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMVariable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMVariable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMVariable -> c OMVariable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMVariable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMVariable)
$cOMVA :: Constr
$cOMVS :: Constr
$tOMVariable :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
gmapMp :: (forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
gmapM :: (forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMVariable -> m OMVariable
gmapQi :: Int -> (forall d. Data d => d -> u) -> OMVariable -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OMVariable -> u
gmapQ :: (forall d. Data d => d -> u) -> OMVariable -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OMVariable -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMVariable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMVariable -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMVariable -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMVariable -> r
gmapT :: (forall b. Data b => b -> b) -> OMVariable -> OMVariable
$cgmapT :: (forall b. Data b => b -> b) -> OMVariable -> OMVariable
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMVariable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMVariable)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OMVariable)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMVariable)
dataTypeOf :: OMVariable -> DataType
$cdataTypeOf :: OMVariable -> DataType
toConstr :: OMVariable -> Constr
$ctoConstr :: OMVariable -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMVariable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMVariable
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMVariable -> c OMVariable
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMVariable -> c OMVariable
$cp1Data :: Typeable OMVariable
Data)

-- | Class to use something as a Variable
class OMVariableClass a where
  toVariable :: a -> OMVariable
  fromVariable :: OMVariable -> Maybe a

instance OMVariableClass OMVariable where
  toVariable :: OMVariable -> OMVariable
toVariable = OMVariable -> OMVariable
forall a. a -> a
id
  fromVariable :: OMVariable -> Maybe OMVariable
fromVariable = OMVariable -> Maybe OMVariable
forall a. a -> Maybe a
Just (OMVariable -> Maybe OMVariable)
-> (OMVariable -> OMVariable) -> OMVariable -> Maybe OMVariable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OMVariable -> OMVariable
forall a. a -> a
id

instance OMVariableClass OMSimpleVariable where
  toVariable :: OMSimpleVariable -> OMVariable
toVariable = OMSimpleVariable -> OMVariable
OMVS
  fromVariable :: OMVariable -> Maybe OMSimpleVariable
fromVariable (OMVS x :: OMSimpleVariable
x) = OMSimpleVariable -> Maybe OMSimpleVariable
forall a. a -> Maybe a
Just OMSimpleVariable
x
  fromVariable _ = Maybe OMSimpleVariable
forall a. Maybe a
Nothing

mkOMVar :: Either OMSimpleVariable OMAttribution -> OMVariable
mkOMVar :: Either OMSimpleVariable OMAttribution -> OMVariable
mkOMVar (Left oms :: OMSimpleVariable
oms) = OMSimpleVariable -> OMVariable
OMVS OMSimpleVariable
oms
mkOMVar (Right omattr :: OMAttribution
omattr) = OMAttribution -> OMVariable
OMVA OMAttribution
omattr

mkOMVarE :: Either OMSimpleVariable OMAttribution -> OMElement
mkOMVarE :: Either OMSimpleVariable OMAttribution -> OMElement
mkOMVarE v :: Either OMSimpleVariable OMAttribution
v = OMVariable -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMVariable -> OMElement) -> OMVariable -> OMElement
forall a b. (a -> b) -> a -> b
$ Either OMSimpleVariable OMAttribution -> OMVariable
mkOMVar Either OMSimpleVariable OMAttribution
v

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


mkOMSimpleVar :: XmlString -> OMSimpleVariable
mkOMSimpleVar :: String -> OMSimpleVariable
mkOMSimpleVar = String -> OMSimpleVariable
OMV

mkOMSimpleVarE :: XmlString -> OMElement
mkOMSimpleVarE :: String -> OMElement
mkOMSimpleVarE xid :: String
xid = OMSimpleVariable -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMSimpleVariable -> OMElement) -> OMSimpleVariable -> OMElement
forall a b. (a -> b) -> a -> b
$ String -> OMSimpleVariable
mkOMSimpleVar String
xid

mkOMVSVar :: XmlString -> OMVariable
mkOMVSVar :: String -> OMVariable
mkOMVSVar = OMSimpleVariable -> OMVariable
OMVS (OMSimpleVariable -> OMVariable)
-> (String -> OMSimpleVariable) -> String -> OMVariable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> OMSimpleVariable
mkOMSimpleVar

mkOMVSVarE :: XmlString -> OMElement
mkOMVSVarE :: String -> OMElement
mkOMVSVarE xid :: String
xid = OMVariable -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMVariable -> OMElement) -> OMVariable -> OMElement
forall a b. (a -> b) -> a -> b
$ OMSimpleVariable -> OMVariable
OMVS (OMSimpleVariable -> OMVariable) -> OMSimpleVariable -> OMVariable
forall a b. (a -> b) -> a -> b
$ String -> OMSimpleVariable
mkOMSimpleVar String
xid

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

instance OMVariableClass OMAttribution where
  toVariable :: OMAttribution -> OMVariable
toVariable = OMAttribution -> OMVariable
OMVA
  fromVariable :: OMVariable -> Maybe OMAttribution
fromVariable (OMVA x :: OMAttribution
x) = OMAttribution -> Maybe OMAttribution
forall a. a -> Maybe a
Just OMAttribution
x
  fromVariable _ = Maybe OMAttribution
forall a. Maybe a
Nothing

mkOMATTR :: OMElementClass e => OMAttributionPart -> e -> OMAttribution
mkOMATTR :: OMAttributionPart -> e -> OMAttribution
mkOMATTR omatp :: OMAttributionPart
omatp ome :: e
ome = OMATTR :: OMAttributionPart -> OMElement -> OMAttribution
OMATTR { omattrATP :: OMAttributionPart
omattrATP = OMAttributionPart
omatp , omattrElem :: OMElement
omattrElem = e -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement e
ome }

mkOMATTRE :: OMElementClass e => OMAttributionPart -> e -> OMElement
mkOMATTRE :: OMAttributionPart -> e -> OMElement
mkOMATTRE omatp :: OMAttributionPart
omatp ome :: e
ome = OMAttribution -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMAttribution -> OMElement) -> OMAttribution -> OMElement
forall a b. (a -> b) -> a -> b
$ OMAttributionPart -> e -> OMAttribution
forall e.
OMElementClass e =>
OMAttributionPart -> e -> OMAttribution
mkOMATTR OMAttributionPart
omatp e
ome

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

mkOMATP :: OMElementClass e => [(OMSymbol, e)] -> OMAttributionPart
mkOMATP :: [(OMSymbol, e)] -> OMAttributionPart
mkOMATP = [(OMSymbol, OMElement)] -> OMAttributionPart
OMATP ([(OMSymbol, OMElement)] -> OMAttributionPart)
-> ([(OMSymbol, e)] -> [(OMSymbol, OMElement)])
-> [(OMSymbol, e)]
-> OMAttributionPart
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((OMSymbol, e) -> (OMSymbol, OMElement))
-> [(OMSymbol, e)] -> [(OMSymbol, OMElement)]
forall a b. (a -> b) -> [a] -> [b]
map (\ (s :: OMSymbol
s, e :: e
e) -> (OMSymbol
s, e -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement e
e))

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

mkOMBVAR :: OMVariableClass e => [e] -> OMBindingVariables
mkOMBVAR :: [e] -> OMBindingVariables
mkOMBVAR = [OMVariable] -> OMBindingVariables
OMBVAR ([OMVariable] -> OMBindingVariables)
-> ([e] -> [OMVariable]) -> [e] -> OMBindingVariables
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> OMVariable) -> [e] -> [OMVariable]
forall a b. (a -> b) -> [a] -> [b]
map e -> OMVariable
forall a. OMVariableClass a => a -> OMVariable
toVariable

{- |
  OMB is actually just a bytearray for storing data.
  [Char] representation is forced by export from Codec.Base64
-}
data OMBase64 =
  OMB
    {
      -- decoded Content
      OMBase64 -> [Word8]
ombContent :: [Word.Word8]
    }
    deriving (Int -> OMBase64 -> String -> String
[OMBase64] -> String -> String
OMBase64 -> String
(Int -> OMBase64 -> String -> String)
-> (OMBase64 -> String)
-> ([OMBase64] -> String -> String)
-> Show OMBase64
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [OMBase64] -> String -> String
$cshowList :: [OMBase64] -> String -> String
show :: OMBase64 -> String
$cshow :: OMBase64 -> String
showsPrec :: Int -> OMBase64 -> String -> String
$cshowsPrec :: Int -> OMBase64 -> String -> String
Show, OMBase64 -> OMBase64 -> Bool
(OMBase64 -> OMBase64 -> Bool)
-> (OMBase64 -> OMBase64 -> Bool) -> Eq OMBase64
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OMBase64 -> OMBase64 -> Bool
$c/= :: OMBase64 -> OMBase64 -> Bool
== :: OMBase64 -> OMBase64 -> Bool
$c== :: OMBase64 -> OMBase64 -> Bool
Eq, Eq OMBase64
Eq OMBase64 =>
(OMBase64 -> OMBase64 -> Ordering)
-> (OMBase64 -> OMBase64 -> Bool)
-> (OMBase64 -> OMBase64 -> Bool)
-> (OMBase64 -> OMBase64 -> Bool)
-> (OMBase64 -> OMBase64 -> Bool)
-> (OMBase64 -> OMBase64 -> OMBase64)
-> (OMBase64 -> OMBase64 -> OMBase64)
-> Ord OMBase64
OMBase64 -> OMBase64 -> Bool
OMBase64 -> OMBase64 -> Ordering
OMBase64 -> OMBase64 -> OMBase64
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 :: OMBase64 -> OMBase64 -> OMBase64
$cmin :: OMBase64 -> OMBase64 -> OMBase64
max :: OMBase64 -> OMBase64 -> OMBase64
$cmax :: OMBase64 -> OMBase64 -> OMBase64
>= :: OMBase64 -> OMBase64 -> Bool
$c>= :: OMBase64 -> OMBase64 -> Bool
> :: OMBase64 -> OMBase64 -> Bool
$c> :: OMBase64 -> OMBase64 -> Bool
<= :: OMBase64 -> OMBase64 -> Bool
$c<= :: OMBase64 -> OMBase64 -> Bool
< :: OMBase64 -> OMBase64 -> Bool
$c< :: OMBase64 -> OMBase64 -> Bool
compare :: OMBase64 -> OMBase64 -> Ordering
$ccompare :: OMBase64 -> OMBase64 -> Ordering
$cp1Ord :: Eq OMBase64
Ord, Typeable, Typeable OMBase64
Constr
DataType
Typeable OMBase64 =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OMBase64 -> c OMBase64)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OMBase64)
-> (OMBase64 -> Constr)
-> (OMBase64 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OMBase64))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMBase64))
-> ((forall b. Data b => b -> b) -> OMBase64 -> OMBase64)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OMBase64 -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OMBase64 -> r)
-> (forall u. (forall d. Data d => d -> u) -> OMBase64 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OMBase64 -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64)
-> Data OMBase64
OMBase64 -> Constr
OMBase64 -> DataType
(forall b. Data b => b -> b) -> OMBase64 -> OMBase64
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMBase64 -> c OMBase64
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMBase64
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) -> OMBase64 -> u
forall u. (forall d. Data d => d -> u) -> OMBase64 -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMBase64 -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMBase64 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMBase64
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMBase64 -> c OMBase64
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMBase64)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMBase64)
$cOMB :: Constr
$tOMBase64 :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
gmapMp :: (forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
gmapM :: (forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMBase64 -> m OMBase64
gmapQi :: Int -> (forall d. Data d => d -> u) -> OMBase64 -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OMBase64 -> u
gmapQ :: (forall d. Data d => d -> u) -> OMBase64 -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OMBase64 -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMBase64 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMBase64 -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMBase64 -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMBase64 -> r
gmapT :: (forall b. Data b => b -> b) -> OMBase64 -> OMBase64
$cgmapT :: (forall b. Data b => b -> b) -> OMBase64 -> OMBase64
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMBase64)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMBase64)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OMBase64)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMBase64)
dataTypeOf :: OMBase64 -> DataType
$cdataTypeOf :: OMBase64 -> DataType
toConstr :: OMBase64 -> Constr
$ctoConstr :: OMBase64 -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMBase64
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMBase64
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMBase64 -> c OMBase64
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMBase64 -> c OMBase64
$cp1Data :: Typeable OMBase64
Data)

mkOMB :: [Word.Word8] -> OMBase64
mkOMB :: [Word8] -> OMBase64
mkOMB = [Word8] -> OMBase64
OMB

mkOMBE :: [Word.Word8] -> OMElement
mkOMBE :: [Word8] -> OMElement
mkOMBE = OMBase64 -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMBase64 -> OMElement)
-> ([Word8] -> OMBase64) -> [Word8] -> OMElement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> OMBase64
mkOMB

mkOMBWords :: [Word.Word8] -> OMBase64
mkOMBWords :: [Word8] -> OMBase64
mkOMBWords = [Word8] -> OMBase64
OMB

mkOMBWordsE :: [Word.Word8] -> OMElement
mkOMBWordsE :: [Word8] -> OMElement
mkOMBWordsE = OMBase64 -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMBase64 -> OMElement)
-> ([Word8] -> OMBase64) -> [Word8] -> OMElement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> OMBase64
mkOMBWords

getOMBWords :: OMBase64 -> [Word.Word8]
getOMBWords :: OMBase64 -> [Word8]
getOMBWords = OMBase64 -> [Word8]
ombContent

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

mkOMSTR :: String -> OMString
mkOMSTR :: String -> OMString
mkOMSTR = String -> OMString
OMSTR

mkOMSTRE :: String -> OMElement
mkOMSTRE :: String -> OMElement
mkOMSTRE = OMString -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMString -> OMElement)
-> (String -> OMString) -> String -> OMElement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> OMString
mkOMSTR

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

mkOMF :: Float -> OMFloat
mkOMF :: Float -> OMFloat
mkOMF = Float -> OMFloat
OMF

mkOMFE :: Float -> OMElement
mkOMFE :: Float -> OMElement
mkOMFE = OMFloat -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMFloat -> OMElement) -> (Float -> OMFloat) -> Float -> OMElement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> OMFloat
mkOMF

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

mkOMA :: OMElementClass e => [e] -> OMApply
mkOMA :: [e] -> OMApply
mkOMA [] = String -> OMApply
forall a. HasCallStack => String -> a
error "Empty list of elements for OMA!"
mkOMA l :: [e]
l = [OMElement] -> OMApply
OMA ((e -> OMElement) -> [e] -> [OMElement]
forall a b. (a -> b) -> [a] -> [b]
map e -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement [e]
l)

mkOMAE :: OMElementClass e => [e] -> OMElement
mkOMAE :: [e] -> OMElement
mkOMAE = OMApply -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMApply -> OMElement) -> ([e] -> OMApply) -> [e] -> OMElement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [e] -> OMApply
forall e. OMElementClass e => [e] -> OMApply
mkOMA

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

mkOME :: OMElementClass e => OMSymbol -> [e] -> OMError
mkOME :: OMSymbol -> [e] -> OMError
mkOME _ [] = String -> OMError
forall a. HasCallStack => String -> a
error "Empty list of elements for OME!"
mkOME s :: OMSymbol
s e :: [e]
e = OMSymbol -> [OMElement] -> OMError
OME OMSymbol
s ((e -> OMElement) -> [e] -> [OMElement]
forall a b. (a -> b) -> [a] -> [b]
map e -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement [e]
e)

mkOMEE :: OMElementClass e => OMSymbol -> [e] -> OMElement
mkOMEE :: OMSymbol -> [e] -> OMElement
mkOMEE s :: OMSymbol
s e :: [e]
e = OMError -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMError -> OMElement) -> OMError -> OMElement
forall a b. (a -> b) -> a -> b
$ OMSymbol -> [e] -> OMError
forall e. OMElementClass e => OMSymbol -> [e] -> OMError
mkOME OMSymbol
s [e]
e

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

mkOMR :: IRI.IRI -> OMReference
mkOMR :: IRI -> OMReference
mkOMR = IRI -> OMReference
OMR

mkOMRE :: IRI.IRI -> OMElement
mkOMRE :: IRI -> OMElement
mkOMRE = OMReference -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMReference -> OMElement)
-> (IRI -> OMReference) -> IRI -> OMElement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IRI -> OMReference
mkOMR

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

mkOMBIND :: (OMElementClass e1, OMElementClass e2)
  => e1 -> OMBindingVariables -> e2 -> OMBind
mkOMBIND :: e1 -> OMBindingVariables -> e2 -> OMBind
mkOMBIND binder :: e1
binder bvars :: OMBindingVariables
bvars expr :: e2
expr =
  OMBIND :: OMElement -> OMBindingVariables -> OMElement -> OMBind
OMBIND
    {
        ombindBinder :: OMElement
ombindBinder = e1 -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement e1
binder
     , ombindVariables :: OMBindingVariables
ombindVariables = OMBindingVariables
bvars
      , ombindExpression :: OMElement
ombindExpression = e2 -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement e2
expr
    }

mkOMBINDE :: (OMElementClass e1, OMElementClass e2)
  => e1 -> OMBindingVariables -> e2 -> OMElement
mkOMBINDE :: e1 -> OMBindingVariables -> e2 -> OMElement
mkOMBINDE binder :: e1
binder vars :: OMBindingVariables
vars expr :: e2
expr = OMBind -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement (OMBind -> OMElement) -> OMBind -> OMElement
forall a b. (a -> b) -> a -> b
$ e1 -> OMBindingVariables -> e2 -> OMBind
forall e1 e2.
(OMElementClass e1, OMElementClass e2) =>
e1 -> OMBindingVariables -> e2 -> OMBind
mkOMBIND e1
binder OMBindingVariables
vars e2
expr

-- | Elements for Open Math
data OMElement =
    OMES OMSymbol
  | OMEV OMSimpleVariable
  | OMEI OMInteger
  | OMEB OMBase64
  | OMESTR OMString
  | OMEF OMFloat
  | OMEA OMApply
  | OMEBIND OMBind
  | OMEE OMError
  | OMEATTR OMAttribution
  | OMER OMReference
  | OMEC (Maybe OMElement) String
  deriving (Int -> OMElement -> String -> String
[OMElement] -> String -> String
OMElement -> String
(Int -> OMElement -> String -> String)
-> (OMElement -> String)
-> ([OMElement] -> String -> String)
-> Show OMElement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [OMElement] -> String -> String
$cshowList :: [OMElement] -> String -> String
show :: OMElement -> String
$cshow :: OMElement -> String
showsPrec :: Int -> OMElement -> String -> String
$cshowsPrec :: Int -> OMElement -> String -> String
Show, OMElement -> OMElement -> Bool
(OMElement -> OMElement -> Bool)
-> (OMElement -> OMElement -> Bool) -> Eq OMElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OMElement -> OMElement -> Bool
$c/= :: OMElement -> OMElement -> Bool
== :: OMElement -> OMElement -> Bool
$c== :: OMElement -> OMElement -> Bool
Eq, Eq OMElement
Eq OMElement =>
(OMElement -> OMElement -> Ordering)
-> (OMElement -> OMElement -> Bool)
-> (OMElement -> OMElement -> Bool)
-> (OMElement -> OMElement -> Bool)
-> (OMElement -> OMElement -> Bool)
-> (OMElement -> OMElement -> OMElement)
-> (OMElement -> OMElement -> OMElement)
-> Ord OMElement
OMElement -> OMElement -> Bool
OMElement -> OMElement -> Ordering
OMElement -> OMElement -> OMElement
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 :: OMElement -> OMElement -> OMElement
$cmin :: OMElement -> OMElement -> OMElement
max :: OMElement -> OMElement -> OMElement
$cmax :: OMElement -> OMElement -> OMElement
>= :: OMElement -> OMElement -> Bool
$c>= :: OMElement -> OMElement -> Bool
> :: OMElement -> OMElement -> Bool
$c> :: OMElement -> OMElement -> Bool
<= :: OMElement -> OMElement -> Bool
$c<= :: OMElement -> OMElement -> Bool
< :: OMElement -> OMElement -> Bool
$c< :: OMElement -> OMElement -> Bool
compare :: OMElement -> OMElement -> Ordering
$ccompare :: OMElement -> OMElement -> Ordering
$cp1Ord :: Eq OMElement
Ord, Typeable, Typeable OMElement
Constr
DataType
Typeable OMElement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OMElement -> c OMElement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OMElement)
-> (OMElement -> Constr)
-> (OMElement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OMElement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMElement))
-> ((forall b. Data b => b -> b) -> OMElement -> OMElement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OMElement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OMElement -> r)
-> (forall u. (forall d. Data d => d -> u) -> OMElement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OMElement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OMElement -> m OMElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMElement -> m OMElement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OMElement -> m OMElement)
-> Data OMElement
OMElement -> Constr
OMElement -> DataType
(forall b. Data b => b -> b) -> OMElement -> OMElement
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMElement -> c OMElement
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMElement
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) -> OMElement -> u
forall u. (forall d. Data d => d -> u) -> OMElement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMElement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMElement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMElement -> m OMElement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMElement -> m OMElement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMElement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMElement -> c OMElement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMElement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMElement)
$cOMEC :: Constr
$cOMER :: Constr
$cOMEATTR :: Constr
$cOMEE :: Constr
$cOMEBIND :: Constr
$cOMEA :: Constr
$cOMEF :: Constr
$cOMESTR :: Constr
$cOMEB :: Constr
$cOMEI :: Constr
$cOMEV :: Constr
$cOMES :: Constr
$tOMElement :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OMElement -> m OMElement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMElement -> m OMElement
gmapMp :: (forall d. Data d => d -> m d) -> OMElement -> m OMElement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OMElement -> m OMElement
gmapM :: (forall d. Data d => d -> m d) -> OMElement -> m OMElement
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OMElement -> m OMElement
gmapQi :: Int -> (forall d. Data d => d -> u) -> OMElement -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OMElement -> u
gmapQ :: (forall d. Data d => d -> u) -> OMElement -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OMElement -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMElement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OMElement -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMElement -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OMElement -> r
gmapT :: (forall b. Data b => b -> b) -> OMElement -> OMElement
$cgmapT :: (forall b. Data b => b -> b) -> OMElement -> OMElement
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMElement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OMElement)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OMElement)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OMElement)
dataTypeOf :: OMElement -> DataType
$cdataTypeOf :: OMElement -> DataType
toConstr :: OMElement -> Constr
$ctoConstr :: OMElement -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMElement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OMElement
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMElement -> c OMElement
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OMElement -> c OMElement
$cp1Data :: Typeable OMElement
Data)

-- | insert a comment into an open-math structure (use with caution...)
mkOMComment :: String -> OMElement
mkOMComment :: String -> OMElement
mkOMComment = Maybe OMElement -> String -> OMElement
OMEC Maybe OMElement
forall a. Maybe a
Nothing

mkOMCommented :: OMElementClass e => String -> e -> OMElement
mkOMCommented :: String -> e -> OMElement
mkOMCommented cmt :: String
cmt e :: e
e = Maybe OMElement -> String -> OMElement
OMEC (OMElement -> Maybe OMElement
forall a. a -> Maybe a
Just (e -> OMElement
forall a. OMElementClass a => a -> OMElement
toElement e
e)) String
cmt

-- | Class of Elements for Open Math
class OMElementClass a where
  toElement :: a -> OMElement
  fromElement :: OMElement -> Maybe a

instance OMElementClass OMSymbol where
  toElement :: OMSymbol -> OMElement
toElement = OMSymbol -> OMElement
OMES
  fromElement :: OMElement -> Maybe OMSymbol
fromElement (OMES oms :: OMSymbol
oms) = OMSymbol -> Maybe OMSymbol
forall a. a -> Maybe a
Just OMSymbol
oms
  fromElement _ = Maybe OMSymbol
forall a. Maybe a
Nothing

instance OMElementClass OMInteger where
  toElement :: OMInteger -> OMElement
toElement = OMInteger -> OMElement
OMEI
  fromElement :: OMElement -> Maybe OMInteger
fromElement (OMEI x :: OMInteger
x) = OMInteger -> Maybe OMInteger
forall a. a -> Maybe a
Just OMInteger
x
  fromElement _ = Maybe OMInteger
forall a. Maybe a
Nothing

instance OMElementClass OMVariable where
  toElement :: OMVariable -> OMElement
toElement (OMVS omv :: OMSimpleVariable
omv) = OMSimpleVariable -> OMElement
OMEV OMSimpleVariable
omv
  toElement (OMVA omattr :: OMAttribution
omattr) = OMAttribution -> OMElement
OMEATTR OMAttribution
omattr
  fromElement :: OMElement -> Maybe OMVariable
fromElement (OMEV omv :: OMSimpleVariable
omv) = OMVariable -> Maybe OMVariable
forall a. a -> Maybe a
Just (OMSimpleVariable -> OMVariable
OMVS OMSimpleVariable
omv)
  fromElement (OMEATTR omattr :: OMAttribution
omattr) = OMVariable -> Maybe OMVariable
forall a. a -> Maybe a
Just (OMAttribution -> OMVariable
OMVA OMAttribution
omattr)
  fromElement _ = Maybe OMVariable
forall a. Maybe a
Nothing

instance OMElementClass OMSimpleVariable where
  toElement :: OMSimpleVariable -> OMElement
toElement = OMSimpleVariable -> OMElement
OMEV
  fromElement :: OMElement -> Maybe OMSimpleVariable
fromElement (OMEV omv :: OMSimpleVariable
omv) = OMSimpleVariable -> Maybe OMSimpleVariable
forall a. a -> Maybe a
Just OMSimpleVariable
omv
  fromElement _ = Maybe OMSimpleVariable
forall a. Maybe a
Nothing

instance OMElementClass OMAttribution where
  toElement :: OMAttribution -> OMElement
toElement = OMAttribution -> OMElement
OMEATTR
  fromElement :: OMElement -> Maybe OMAttribution
fromElement (OMEATTR x :: OMAttribution
x) = OMAttribution -> Maybe OMAttribution
forall a. a -> Maybe a
Just OMAttribution
x
  fromElement _ = Maybe OMAttribution
forall a. Maybe a
Nothing

instance OMElementClass OMBase64 where
  toElement :: OMBase64 -> OMElement
toElement = OMBase64 -> OMElement
OMEB
  fromElement :: OMElement -> Maybe OMBase64
fromElement (OMEB x :: OMBase64
x) = OMBase64 -> Maybe OMBase64
forall a. a -> Maybe a
Just OMBase64
x
  fromElement _ = Maybe OMBase64
forall a. Maybe a
Nothing

instance OMElementClass OMString where
  toElement :: OMString -> OMElement
toElement = OMString -> OMElement
OMESTR
  fromElement :: OMElement -> Maybe OMString
fromElement (OMESTR x :: OMString
x) = OMString -> Maybe OMString
forall a. a -> Maybe a
Just OMString
x
  fromElement _ = Maybe OMString
forall a. Maybe a
Nothing

instance OMElementClass OMFloat where
  toElement :: OMFloat -> OMElement
toElement = OMFloat -> OMElement
OMEF
  fromElement :: OMElement -> Maybe OMFloat
fromElement (OMEF x :: OMFloat
x) = OMFloat -> Maybe OMFloat
forall a. a -> Maybe a
Just OMFloat
x
  fromElement _ = Maybe OMFloat
forall a. Maybe a
Nothing

instance OMElementClass OMApply where
  toElement :: OMApply -> OMElement
toElement = OMApply -> OMElement
OMEA
  fromElement :: OMElement -> Maybe OMApply
fromElement (OMEA x :: OMApply
x) = OMApply -> Maybe OMApply
forall a. a -> Maybe a
Just OMApply
x
  fromElement _ = Maybe OMApply
forall a. Maybe a
Nothing

instance OMElementClass OMError where
  toElement :: OMError -> OMElement
toElement = OMError -> OMElement
OMEE
  fromElement :: OMElement -> Maybe OMError
fromElement (OMEE x :: OMError
x) = OMError -> Maybe OMError
forall a. a -> Maybe a
Just OMError
x
  fromElement _ = Maybe OMError
forall a. Maybe a
Nothing

instance OMElementClass OMReference where
  toElement :: OMReference -> OMElement
toElement = OMReference -> OMElement
OMER
  fromElement :: OMElement -> Maybe OMReference
fromElement (OMER x :: OMReference
x) = OMReference -> Maybe OMReference
forall a. a -> Maybe a
Just OMReference
x
  fromElement _ = Maybe OMReference
forall a. Maybe a
Nothing

instance OMElementClass OMBind where
  toElement :: OMBind -> OMElement
toElement = OMBind -> OMElement
OMEBIND
  fromElement :: OMElement -> Maybe OMBind
fromElement (OMEBIND x :: OMBind
x) = OMBind -> Maybe OMBind
forall a. a -> Maybe a
Just OMBind
x
  fromElement _ = Maybe OMBind
forall a. Maybe a
Nothing

instance OMElementClass OMElement where
  toElement :: OMElement -> OMElement
toElement = OMElement -> OMElement
forall a. a -> a
id
  fromElement :: OMElement -> Maybe OMElement
fromElement = OMElement -> Maybe OMElement
forall a. a -> Maybe a
Just (OMElement -> Maybe OMElement)
-> (OMElement -> OMElement) -> OMElement -> Maybe OMElement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OMElement -> OMElement
forall a. a -> a
id