{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./OWL2/Sign.hs
Copyright   :  Heng Jiang, Uni Bremen 2007
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  Christian.Maeder@dfki.de
Stability   :  provisional
Portability :  portable

OWL 2 signature and sentences
-}

module OWL2.Sign where


import Common.IRI
import OWL2.AS

import qualified Data.Set as Set
import qualified Data.Map as Map

import Common.Lib.State
import Common.Result

import Control.Monad

import Data.Data

data Sign = Sign
            { Sign -> Set Class
concepts :: Set.Set Class
              -- classes
            , Sign -> Set Class
datatypes :: Set.Set Datatype -- datatypes
            , Sign -> Set Class
objectProperties :: Set.Set ObjectProperty
              -- object properties
            , Sign -> Set Class
dataProperties :: Set.Set DataProperty
              -- data properties
            , Sign -> Set Class
annotationRoles :: Set.Set AnnotationProperty
              -- annotation properties
            , Sign -> Set Class
individuals :: Set.Set NamedIndividual  -- named individuals
            , Sign -> Map Class String
labelMap :: Map.Map IRI String -- labels (for better readability)
            , Sign -> PrefixMap
prefixMap :: PrefixMap
            } deriving (Int -> Sign -> ShowS
[Sign] -> ShowS
Sign -> String
(Int -> Sign -> ShowS)
-> (Sign -> String) -> ([Sign] -> ShowS) -> Show Sign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sign] -> ShowS
$cshowList :: [Sign] -> ShowS
show :: Sign -> String
$cshow :: Sign -> String
showsPrec :: Int -> Sign -> ShowS
$cshowsPrec :: Int -> Sign -> ShowS
Show, Typeable, Typeable Sign
Constr
DataType
Typeable Sign =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Sign -> c Sign)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Sign)
-> (Sign -> Constr)
-> (Sign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Sign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign))
-> ((forall b. Data b => b -> b) -> Sign -> Sign)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> Data Sign
Sign -> Constr
Sign -> DataType
(forall b. Data b => b -> b) -> Sign -> Sign
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
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) -> Sign -> u
forall u. (forall d. Data d => d -> u) -> Sign -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cSign :: Constr
$tSign :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapMp :: (forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapM :: (forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
gmapQ :: (forall d. Data d => d -> u) -> Sign -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
$cgmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Sign)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
dataTypeOf :: Sign -> DataType
$cdataTypeOf :: Sign -> DataType
toConstr :: Sign -> Constr
$ctoConstr :: Sign -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cp1Data :: Typeable Sign
Data)

instance Ord Sign where
  compare :: Sign -> Sign -> Ordering
compare (Sign c1 :: Set Class
c1 d1 :: Set Class
d1 op1 :: Set Class
op1 dp1 :: Set Class
dp1 ar1 :: Set Class
ar1 iv1 :: Set Class
iv1 _ _) (Sign c2 :: Set Class
c2 d2 :: Set Class
d2 op2 :: Set Class
op2 dp2 :: Set Class
dp2 ar2 :: Set Class
ar2 iv2 :: Set Class
iv2 _ _)
    = (Set Class, Set Class, Set Class, Set Class, Set Class, Set Class)
-> (Set Class, Set Class, Set Class, Set Class, Set Class,
    Set Class)
-> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Set Class
c1, Set Class
d1, Set Class
op1, Set Class
dp1, Set Class
ar1, Set Class
iv1) (Set Class
c2, Set Class
d2, Set Class
op2, Set Class
dp2, Set Class
ar2, Set Class
iv2)

instance Eq Sign where
  s1 :: Sign
s1 == :: Sign -> Sign -> Bool
== s2 :: Sign
s2 = Sign -> Sign -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Sign
s1 Sign
s2 Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ

data SignAxiom =
    Subconcept ClassExpression ClassExpression   -- subclass, superclass
  | Role (DomainOrRangeOrFunc (RoleKind, RoleType)) ObjectPropertyExpression
  | Data (DomainOrRangeOrFunc ()) DataPropertyExpression
  | Conceptmembership Individual ClassExpression
    deriving (Int -> SignAxiom -> ShowS
[SignAxiom] -> ShowS
SignAxiom -> String
(Int -> SignAxiom -> ShowS)
-> (SignAxiom -> String)
-> ([SignAxiom] -> ShowS)
-> Show SignAxiom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SignAxiom] -> ShowS
$cshowList :: [SignAxiom] -> ShowS
show :: SignAxiom -> String
$cshow :: SignAxiom -> String
showsPrec :: Int -> SignAxiom -> ShowS
$cshowsPrec :: Int -> SignAxiom -> ShowS
Show, SignAxiom -> SignAxiom -> Bool
(SignAxiom -> SignAxiom -> Bool)
-> (SignAxiom -> SignAxiom -> Bool) -> Eq SignAxiom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SignAxiom -> SignAxiom -> Bool
$c/= :: SignAxiom -> SignAxiom -> Bool
== :: SignAxiom -> SignAxiom -> Bool
$c== :: SignAxiom -> SignAxiom -> Bool
Eq, Eq SignAxiom
Eq SignAxiom =>
(SignAxiom -> SignAxiom -> Ordering)
-> (SignAxiom -> SignAxiom -> Bool)
-> (SignAxiom -> SignAxiom -> Bool)
-> (SignAxiom -> SignAxiom -> Bool)
-> (SignAxiom -> SignAxiom -> Bool)
-> (SignAxiom -> SignAxiom -> SignAxiom)
-> (SignAxiom -> SignAxiom -> SignAxiom)
-> Ord SignAxiom
SignAxiom -> SignAxiom -> Bool
SignAxiom -> SignAxiom -> Ordering
SignAxiom -> SignAxiom -> SignAxiom
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 :: SignAxiom -> SignAxiom -> SignAxiom
$cmin :: SignAxiom -> SignAxiom -> SignAxiom
max :: SignAxiom -> SignAxiom -> SignAxiom
$cmax :: SignAxiom -> SignAxiom -> SignAxiom
>= :: SignAxiom -> SignAxiom -> Bool
$c>= :: SignAxiom -> SignAxiom -> Bool
> :: SignAxiom -> SignAxiom -> Bool
$c> :: SignAxiom -> SignAxiom -> Bool
<= :: SignAxiom -> SignAxiom -> Bool
$c<= :: SignAxiom -> SignAxiom -> Bool
< :: SignAxiom -> SignAxiom -> Bool
$c< :: SignAxiom -> SignAxiom -> Bool
compare :: SignAxiom -> SignAxiom -> Ordering
$ccompare :: SignAxiom -> SignAxiom -> Ordering
$cp1Ord :: Eq SignAxiom
Ord, Typeable, Typeable SignAxiom
Constr
DataType
Typeable SignAxiom =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SignAxiom -> c SignAxiom)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SignAxiom)
-> (SignAxiom -> Constr)
-> (SignAxiom -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SignAxiom))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SignAxiom))
-> ((forall b. Data b => b -> b) -> SignAxiom -> SignAxiom)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SignAxiom -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SignAxiom -> r)
-> (forall u. (forall d. Data d => d -> u) -> SignAxiom -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SignAxiom -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom)
-> Data SignAxiom
SignAxiom -> Constr
SignAxiom -> DataType
(forall b. Data b => b -> b) -> SignAxiom -> SignAxiom
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignAxiom -> c SignAxiom
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignAxiom
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) -> SignAxiom -> u
forall u. (forall d. Data d => d -> u) -> SignAxiom -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignAxiom -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignAxiom -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignAxiom
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignAxiom -> c SignAxiom
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignAxiom)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SignAxiom)
$cConceptmembership :: Constr
$cData :: Constr
$cRole :: Constr
$cSubconcept :: Constr
$tSignAxiom :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
gmapMp :: (forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
gmapM :: (forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SignAxiom -> m SignAxiom
gmapQi :: Int -> (forall d. Data d => d -> u) -> SignAxiom -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SignAxiom -> u
gmapQ :: (forall d. Data d => d -> u) -> SignAxiom -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SignAxiom -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignAxiom -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignAxiom -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignAxiom -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignAxiom -> r
gmapT :: (forall b. Data b => b -> b) -> SignAxiom -> SignAxiom
$cgmapT :: (forall b. Data b => b -> b) -> SignAxiom -> SignAxiom
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SignAxiom)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SignAxiom)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SignAxiom)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignAxiom)
dataTypeOf :: SignAxiom -> DataType
$cdataTypeOf :: SignAxiom -> DataType
toConstr :: SignAxiom -> Constr
$ctoConstr :: SignAxiom -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignAxiom
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignAxiom
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignAxiom -> c SignAxiom
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignAxiom -> c SignAxiom
$cp1Data :: Typeable SignAxiom
Data)

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

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

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

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

emptySign :: Sign
emptySign :: Sign
emptySign = Sign :: Set Class
-> Set Class
-> Set Class
-> Set Class
-> Set Class
-> Set Class
-> Map Class String
-> PrefixMap
-> Sign
Sign
  { concepts :: Set Class
concepts = Set Class
forall a. Set a
Set.empty
  , datatypes :: Set Class
datatypes = Set Class
forall a. Set a
Set.empty
  , objectProperties :: Set Class
objectProperties = Set Class
forall a. Set a
Set.empty
  , dataProperties :: Set Class
dataProperties = Set Class
forall a. Set a
Set.empty
  , annotationRoles :: Set Class
annotationRoles = Set Class
forall a. Set a
Set.empty
  , individuals :: Set Class
individuals = Set Class
forall a. Set a
Set.empty
  , labelMap :: Map Class String
labelMap = Map Class String
forall k a. Map k a
Map.empty
  , prefixMap :: PrefixMap
prefixMap = PrefixMap
forall k a. Map k a
Map.empty
  }

diffSig :: Sign -> Sign -> Sign
diffSig :: Sign -> Sign -> Sign
diffSig a :: Sign
a b :: Sign
b =
    Sign
a { concepts :: Set Class
concepts = Sign -> Set Class
concepts Sign
a Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Sign -> Set Class
concepts Sign
b
      , datatypes :: Set Class
datatypes = Sign -> Set Class
datatypes Sign
a Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Sign -> Set Class
datatypes Sign
b
      , objectProperties :: Set Class
objectProperties = Sign -> Set Class
objectProperties Sign
a
            Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Sign -> Set Class
objectProperties Sign
b
      , dataProperties :: Set Class
dataProperties = Sign -> Set Class
dataProperties Sign
a Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Sign -> Set Class
dataProperties Sign
b
      , annotationRoles :: Set Class
annotationRoles = Sign -> Set Class
annotationRoles Sign
a Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Sign -> Set Class
annotationRoles Sign
b
      , individuals :: Set Class
individuals = Sign -> Set Class
individuals Sign
a Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` Sign -> Set Class
individuals Sign
b
      }

addSymbToSign :: Sign -> Entity -> Result Sign
addSymbToSign :: Sign -> Entity -> Result Sign
addSymbToSign sig :: Sign
sig ent :: Entity
ent =
 case Entity
ent of
   Entity _ Class eIri :: Class
eIri ->
    Sign -> Result Sign
forall (m :: * -> *) a. Monad m => a -> m a
return Sign
sig {concepts :: Set Class
concepts = Class -> Set Class -> Set Class
forall a. Ord a => a -> Set a -> Set a
Set.insert Class
eIri (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
concepts Sign
sig}
   Entity _ ObjectProperty eIri :: Class
eIri ->
    Sign -> Result Sign
forall (m :: * -> *) a. Monad m => a -> m a
return Sign
sig {objectProperties :: Set Class
objectProperties = Class -> Set Class -> Set Class
forall a. Ord a => a -> Set a -> Set a
Set.insert Class
eIri (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
objectProperties Sign
sig}
   Entity _ NamedIndividual eIri :: Class
eIri ->
    Sign -> Result Sign
forall (m :: * -> *) a. Monad m => a -> m a
return Sign
sig {individuals :: Set Class
individuals = Class -> Set Class -> Set Class
forall a. Ord a => a -> Set a -> Set a
Set.insert Class
eIri (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
individuals Sign
sig}
   _ -> Sign -> Result Sign
forall (m :: * -> *) a. Monad m => a -> m a
return Sign
sig

addSign :: Sign -> Sign -> Sign
addSign :: Sign -> Sign -> Sign
addSign toIns :: Sign
toIns totalSign :: Sign
totalSign =
    Sign
totalSign {
                concepts :: Set Class
concepts = Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
Set.union (Sign -> Set Class
concepts Sign
totalSign)
                                     (Sign -> Set Class
concepts Sign
toIns),
                datatypes :: Set Class
datatypes = Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
Set.union (Sign -> Set Class
datatypes Sign
totalSign)
                                      (Sign -> Set Class
datatypes Sign
toIns),
                objectProperties :: Set Class
objectProperties = Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
Set.union (Sign -> Set Class
objectProperties Sign
totalSign)
                                           (Sign -> Set Class
objectProperties Sign
toIns),
                dataProperties :: Set Class
dataProperties = Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
Set.union (Sign -> Set Class
dataProperties Sign
totalSign)
                                            (Sign -> Set Class
dataProperties Sign
toIns),
                annotationRoles :: Set Class
annotationRoles = Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
Set.union (Sign -> Set Class
annotationRoles Sign
totalSign)
                                            (Sign -> Set Class
annotationRoles Sign
toIns),
                individuals :: Set Class
individuals = Set Class -> Set Class -> Set Class
forall a. Ord a => Set a -> Set a -> Set a
Set.union (Sign -> Set Class
individuals Sign
totalSign)
                                        (Sign -> Set Class
individuals Sign
toIns)
              }

isSubSign :: Sign -> Sign -> Bool
isSubSign :: Sign -> Sign -> Bool
isSubSign a :: Sign
a b :: Sign
b =
    Set Class -> Set Class -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf (Sign -> Set Class
concepts Sign
a) (Sign -> Set Class
concepts Sign
b)
       Bool -> Bool -> Bool
&& Set Class -> Set Class -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf (Sign -> Set Class
datatypes Sign
a) (Sign -> Set Class
datatypes Sign
b)
       Bool -> Bool -> Bool
&& Set Class -> Set Class -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf (Sign -> Set Class
objectProperties Sign
a) (Sign -> Set Class
objectProperties Sign
b)
       Bool -> Bool -> Bool
&& Set Class -> Set Class -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf (Sign -> Set Class
dataProperties Sign
a) (Sign -> Set Class
dataProperties Sign
b)
       Bool -> Bool -> Bool
&& Set Class -> Set Class -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf (Sign -> Set Class
annotationRoles Sign
a) (Sign -> Set Class
annotationRoles Sign
b)
       Bool -> Bool -> Bool
&& Set Class -> Set Class -> Bool
forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf (Sign -> Set Class
individuals Sign
a) (Sign -> Set Class
individuals Sign
b)

symOf :: Sign -> Set.Set Entity
symOf :: Sign -> Set Entity
symOf s :: Sign
s = [Set Entity] -> Set Entity
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions
  [ (Class -> Entity) -> Set Class -> Set Entity
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\ ir :: Class
ir -> Maybe String -> EntityType -> Class -> Entity
Entity (Class -> Map Class String -> Maybe String
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Class
ir (Map Class String -> Maybe String)
-> Map Class String -> Maybe String
forall a b. (a -> b) -> a -> b
$ Sign -> Map Class String
labelMap Sign
s) EntityType
Class Class
ir) (Set Class -> Set Entity) -> Set Class -> Set Entity
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
concepts Sign
s
  , (Class -> Entity) -> Set Class -> Set Entity
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (EntityType -> Class -> Entity
mkEntity EntityType
Datatype) (Set Class -> Set Entity) -> Set Class -> Set Entity
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
datatypes Sign
s
  , (Class -> Entity) -> Set Class -> Set Entity
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (EntityType -> Class -> Entity
mkEntity EntityType
ObjectProperty) (Set Class -> Set Entity) -> Set Class -> Set Entity
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
objectProperties Sign
s
  , (Class -> Entity) -> Set Class -> Set Entity
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (EntityType -> Class -> Entity
mkEntity EntityType
DataProperty) (Set Class -> Set Entity) -> Set Class -> Set Entity
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
dataProperties Sign
s
  , (Class -> Entity) -> Set Class -> Set Entity
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (EntityType -> Class -> Entity
mkEntity EntityType
NamedIndividual) (Set Class -> Set Entity) -> Set Class -> Set Entity
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
individuals Sign
s
  , (Class -> Entity) -> Set Class -> Set Entity
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (EntityType -> Class -> Entity
mkEntity EntityType
AnnotationProperty) (Set Class -> Set Entity) -> Set Class -> Set Entity
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
annotationRoles Sign
s ]

-- | takes an entity and modifies the sign according to the given function
modEntity :: (IRI -> Set.Set IRI -> Set.Set IRI) -> Entity -> State Sign ()
modEntity :: (Class -> Set Class -> Set Class) -> Entity -> State Sign ()
modEntity f :: Class -> Set Class -> Set Class
f (Entity _ ty :: EntityType
ty u :: Class
u) = do
  Sign
s <- State Sign Sign
forall s. State s s
get
  let chg :: Set Class -> Set Class
chg = Class -> Set Class -> Set Class
f Class
u
  Bool -> State Sign () -> State Sign ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Class -> Bool
isDatatypeKey Class
u Bool -> Bool -> Bool
|| Class -> Bool
isThing Class
u) (State Sign () -> State Sign ()) -> State Sign () -> State Sign ()
forall a b. (a -> b) -> a -> b
$ Sign -> State Sign ()
forall s. s -> State s ()
put (Sign -> State Sign ()) -> Sign -> State Sign ()
forall a b. (a -> b) -> a -> b
$ case EntityType
ty of
    Datatype -> Sign
s { datatypes :: Set Class
datatypes = Set Class -> Set Class
chg (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
datatypes Sign
s }
    Class -> Sign
s { concepts :: Set Class
concepts = Set Class -> Set Class
chg (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
concepts Sign
s }
    ObjectProperty -> Sign
s { objectProperties :: Set Class
objectProperties = Set Class -> Set Class
chg (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
objectProperties Sign
s }
    DataProperty -> Sign
s { dataProperties :: Set Class
dataProperties = Set Class -> Set Class
chg (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
dataProperties Sign
s }
    NamedIndividual -> if Class -> Bool
isAnonymous Class
u then Sign
s
         else Sign
s { individuals :: Set Class
individuals = Set Class -> Set Class
chg (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
individuals Sign
s }
    AnnotationProperty -> Sign
s {annotationRoles :: Set Class
annotationRoles = Set Class -> Set Class
chg (Set Class -> Set Class) -> Set Class -> Set Class
forall a b. (a -> b) -> a -> b
$ Sign -> Set Class
annotationRoles Sign
s}

-- | adding entities to the signature
addEntity :: Entity -> State Sign ()
addEntity :: Entity -> State Sign ()
addEntity = (Class -> Set Class -> Set Class) -> Entity -> State Sign ()
modEntity Class -> Set Class -> Set Class
forall a. Ord a => a -> Set a -> Set a
Set.insert