{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./CommonLogic/AS_CommonLogic.der.hs
Description :  Abstract syntax for common logic
Copyright   :  (c) Karl Luc, DFKI Bremen 2010, Eugen Kuksa and Uni Bremen 2011
License     :  GPLv2 or higher, see LICENSE.txt

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

Definition of abstract syntax for common logic
-}

{-
  Ref.
  ISO/IEC IS 24707:2007(E)
-}

module CommonLogic.AS_CommonLogic where

import Common.Id as Id
import Common.IRI
import Common.Doc
import Common.DocUtils
import Common.Keywords
import qualified Common.AS_Annotation as AS_Anno

import Data.Data
import Data.Set (Set)

-- DrIFT command
{-! global: GetRange !-}

newtype BASIC_SPEC = Basic_spec [AS_Anno.Annoted BASIC_ITEMS]
                     deriving (Int -> BASIC_SPEC -> ShowS
[BASIC_SPEC] -> ShowS
BASIC_SPEC -> String
(Int -> BASIC_SPEC -> ShowS)
-> (BASIC_SPEC -> String)
-> ([BASIC_SPEC] -> ShowS)
-> Show BASIC_SPEC
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BASIC_SPEC] -> ShowS
$cshowList :: [BASIC_SPEC] -> ShowS
show :: BASIC_SPEC -> String
$cshow :: BASIC_SPEC -> String
showsPrec :: Int -> BASIC_SPEC -> ShowS
$cshowsPrec :: Int -> BASIC_SPEC -> ShowS
Show, Eq BASIC_SPEC
Eq BASIC_SPEC =>
(BASIC_SPEC -> BASIC_SPEC -> Ordering)
-> (BASIC_SPEC -> BASIC_SPEC -> Bool)
-> (BASIC_SPEC -> BASIC_SPEC -> Bool)
-> (BASIC_SPEC -> BASIC_SPEC -> Bool)
-> (BASIC_SPEC -> BASIC_SPEC -> Bool)
-> (BASIC_SPEC -> BASIC_SPEC -> BASIC_SPEC)
-> (BASIC_SPEC -> BASIC_SPEC -> BASIC_SPEC)
-> Ord BASIC_SPEC
BASIC_SPEC -> BASIC_SPEC -> Bool
BASIC_SPEC -> BASIC_SPEC -> Ordering
BASIC_SPEC -> BASIC_SPEC -> BASIC_SPEC
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 :: BASIC_SPEC -> BASIC_SPEC -> BASIC_SPEC
$cmin :: BASIC_SPEC -> BASIC_SPEC -> BASIC_SPEC
max :: BASIC_SPEC -> BASIC_SPEC -> BASIC_SPEC
$cmax :: BASIC_SPEC -> BASIC_SPEC -> BASIC_SPEC
>= :: BASIC_SPEC -> BASIC_SPEC -> Bool
$c>= :: BASIC_SPEC -> BASIC_SPEC -> Bool
> :: BASIC_SPEC -> BASIC_SPEC -> Bool
$c> :: BASIC_SPEC -> BASIC_SPEC -> Bool
<= :: BASIC_SPEC -> BASIC_SPEC -> Bool
$c<= :: BASIC_SPEC -> BASIC_SPEC -> Bool
< :: BASIC_SPEC -> BASIC_SPEC -> Bool
$c< :: BASIC_SPEC -> BASIC_SPEC -> Bool
compare :: BASIC_SPEC -> BASIC_SPEC -> Ordering
$ccompare :: BASIC_SPEC -> BASIC_SPEC -> Ordering
$cp1Ord :: Eq BASIC_SPEC
Ord, BASIC_SPEC -> BASIC_SPEC -> Bool
(BASIC_SPEC -> BASIC_SPEC -> Bool)
-> (BASIC_SPEC -> BASIC_SPEC -> Bool) -> Eq BASIC_SPEC
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BASIC_SPEC -> BASIC_SPEC -> Bool
$c/= :: BASIC_SPEC -> BASIC_SPEC -> Bool
== :: BASIC_SPEC -> BASIC_SPEC -> Bool
$c== :: BASIC_SPEC -> BASIC_SPEC -> Bool
Eq, Typeable)

data BASIC_ITEMS = Axiom_items [AS_Anno.Annoted TEXT_META]
                   deriving (Int -> BASIC_ITEMS -> ShowS
[BASIC_ITEMS] -> ShowS
BASIC_ITEMS -> String
(Int -> BASIC_ITEMS -> ShowS)
-> (BASIC_ITEMS -> String)
-> ([BASIC_ITEMS] -> ShowS)
-> Show BASIC_ITEMS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BASIC_ITEMS] -> ShowS
$cshowList :: [BASIC_ITEMS] -> ShowS
show :: BASIC_ITEMS -> String
$cshow :: BASIC_ITEMS -> String
showsPrec :: Int -> BASIC_ITEMS -> ShowS
$cshowsPrec :: Int -> BASIC_ITEMS -> ShowS
Show, Eq BASIC_ITEMS
Eq BASIC_ITEMS =>
(BASIC_ITEMS -> BASIC_ITEMS -> Ordering)
-> (BASIC_ITEMS -> BASIC_ITEMS -> Bool)
-> (BASIC_ITEMS -> BASIC_ITEMS -> Bool)
-> (BASIC_ITEMS -> BASIC_ITEMS -> Bool)
-> (BASIC_ITEMS -> BASIC_ITEMS -> Bool)
-> (BASIC_ITEMS -> BASIC_ITEMS -> BASIC_ITEMS)
-> (BASIC_ITEMS -> BASIC_ITEMS -> BASIC_ITEMS)
-> Ord BASIC_ITEMS
BASIC_ITEMS -> BASIC_ITEMS -> Bool
BASIC_ITEMS -> BASIC_ITEMS -> Ordering
BASIC_ITEMS -> BASIC_ITEMS -> BASIC_ITEMS
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 :: BASIC_ITEMS -> BASIC_ITEMS -> BASIC_ITEMS
$cmin :: BASIC_ITEMS -> BASIC_ITEMS -> BASIC_ITEMS
max :: BASIC_ITEMS -> BASIC_ITEMS -> BASIC_ITEMS
$cmax :: BASIC_ITEMS -> BASIC_ITEMS -> BASIC_ITEMS
>= :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
$c>= :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
> :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
$c> :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
<= :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
$c<= :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
< :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
$c< :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
compare :: BASIC_ITEMS -> BASIC_ITEMS -> Ordering
$ccompare :: BASIC_ITEMS -> BASIC_ITEMS -> Ordering
$cp1Ord :: Eq BASIC_ITEMS
Ord, BASIC_ITEMS -> BASIC_ITEMS -> Bool
(BASIC_ITEMS -> BASIC_ITEMS -> Bool)
-> (BASIC_ITEMS -> BASIC_ITEMS -> Bool) -> Eq BASIC_ITEMS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
$c/= :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
== :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
$c== :: BASIC_ITEMS -> BASIC_ITEMS -> Bool
Eq, Typeable)

type PrefixMapping = (String, IRI)

emptyTextMeta :: TEXT_META
emptyTextMeta :: TEXT_META
emptyTextMeta = Text_meta :: TEXT
-> Maybe IRI -> Maybe (Set NAME) -> [PrefixMapping] -> TEXT_META
Text_meta { getText :: TEXT
getText = [PHRASE] -> Range -> TEXT
Text [] Range
nullRange
                          , textIri :: Maybe IRI
textIri = Maybe IRI
forall a. Maybe a
Nothing
                          , nondiscourseNames :: Maybe (Set NAME)
nondiscourseNames = Maybe (Set NAME)
forall a. Maybe a
Nothing
                          , prefix_map :: [PrefixMapping]
prefix_map = [] }

data TEXT_META = Text_meta { TEXT_META -> TEXT
getText :: TEXT
                           , TEXT_META -> Maybe IRI
textIri :: Maybe IRI
                           , TEXT_META -> Maybe (Set NAME)
nondiscourseNames :: Maybe (Set NAME)
                           , TEXT_META -> [PrefixMapping]
prefix_map :: [PrefixMapping]
                           } deriving (Int -> TEXT_META -> ShowS
[TEXT_META] -> ShowS
TEXT_META -> String
(Int -> TEXT_META -> ShowS)
-> (TEXT_META -> String)
-> ([TEXT_META] -> ShowS)
-> Show TEXT_META
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TEXT_META] -> ShowS
$cshowList :: [TEXT_META] -> ShowS
show :: TEXT_META -> String
$cshow :: TEXT_META -> String
showsPrec :: Int -> TEXT_META -> ShowS
$cshowsPrec :: Int -> TEXT_META -> ShowS
Show, TEXT_META -> TEXT_META -> Bool
(TEXT_META -> TEXT_META -> Bool)
-> (TEXT_META -> TEXT_META -> Bool) -> Eq TEXT_META
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TEXT_META -> TEXT_META -> Bool
$c/= :: TEXT_META -> TEXT_META -> Bool
== :: TEXT_META -> TEXT_META -> Bool
$c== :: TEXT_META -> TEXT_META -> Bool
Eq, Eq TEXT_META
Eq TEXT_META =>
(TEXT_META -> TEXT_META -> Ordering)
-> (TEXT_META -> TEXT_META -> Bool)
-> (TEXT_META -> TEXT_META -> Bool)
-> (TEXT_META -> TEXT_META -> Bool)
-> (TEXT_META -> TEXT_META -> Bool)
-> (TEXT_META -> TEXT_META -> TEXT_META)
-> (TEXT_META -> TEXT_META -> TEXT_META)
-> Ord TEXT_META
TEXT_META -> TEXT_META -> Bool
TEXT_META -> TEXT_META -> Ordering
TEXT_META -> TEXT_META -> TEXT_META
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 :: TEXT_META -> TEXT_META -> TEXT_META
$cmin :: TEXT_META -> TEXT_META -> TEXT_META
max :: TEXT_META -> TEXT_META -> TEXT_META
$cmax :: TEXT_META -> TEXT_META -> TEXT_META
>= :: TEXT_META -> TEXT_META -> Bool
$c>= :: TEXT_META -> TEXT_META -> Bool
> :: TEXT_META -> TEXT_META -> Bool
$c> :: TEXT_META -> TEXT_META -> Bool
<= :: TEXT_META -> TEXT_META -> Bool
$c<= :: TEXT_META -> TEXT_META -> Bool
< :: TEXT_META -> TEXT_META -> Bool
$c< :: TEXT_META -> TEXT_META -> Bool
compare :: TEXT_META -> TEXT_META -> Ordering
$ccompare :: TEXT_META -> TEXT_META -> Ordering
$cp1Ord :: Eq TEXT_META
Ord, Typeable, Typeable TEXT_META
Constr
DataType
Typeable TEXT_META =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TEXT_META -> c TEXT_META)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TEXT_META)
-> (TEXT_META -> Constr)
-> (TEXT_META -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TEXT_META))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TEXT_META))
-> ((forall b. Data b => b -> b) -> TEXT_META -> TEXT_META)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TEXT_META -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TEXT_META -> r)
-> (forall u. (forall d. Data d => d -> u) -> TEXT_META -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TEXT_META -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META)
-> Data TEXT_META
TEXT_META -> Constr
TEXT_META -> DataType
(forall b. Data b => b -> b) -> TEXT_META -> TEXT_META
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TEXT_META -> c TEXT_META
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TEXT_META
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) -> TEXT_META -> u
forall u. (forall d. Data d => d -> u) -> TEXT_META -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TEXT_META -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TEXT_META -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TEXT_META
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TEXT_META -> c TEXT_META
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TEXT_META)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TEXT_META)
$cText_meta :: Constr
$tTEXT_META :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
gmapMp :: (forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
gmapM :: (forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TEXT_META -> m TEXT_META
gmapQi :: Int -> (forall d. Data d => d -> u) -> TEXT_META -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TEXT_META -> u
gmapQ :: (forall d. Data d => d -> u) -> TEXT_META -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TEXT_META -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TEXT_META -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TEXT_META -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TEXT_META -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TEXT_META -> r
gmapT :: (forall b. Data b => b -> b) -> TEXT_META -> TEXT_META
$cgmapT :: (forall b. Data b => b -> b) -> TEXT_META -> TEXT_META
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TEXT_META)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TEXT_META)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TEXT_META)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TEXT_META)
dataTypeOf :: TEXT_META -> DataType
$cdataTypeOf :: TEXT_META -> DataType
toConstr :: TEXT_META -> Constr
$ctoConstr :: TEXT_META -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TEXT_META
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TEXT_META
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TEXT_META -> c TEXT_META
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TEXT_META -> c TEXT_META
$cp1Data :: Typeable TEXT_META
Data)
{- TODO: check static analysis and other features on discourse names,
as soon as parsers of segregated dialects are implemented -}

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

data PHRASE = Module MODULE
            | Sentence SENTENCE
            | Importation IMPORTATION
            | Comment_text COMMENT TEXT Id.Range
              deriving (Int -> PHRASE -> ShowS
[PHRASE] -> ShowS
PHRASE -> String
(Int -> PHRASE -> ShowS)
-> (PHRASE -> String) -> ([PHRASE] -> ShowS) -> Show PHRASE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PHRASE] -> ShowS
$cshowList :: [PHRASE] -> ShowS
show :: PHRASE -> String
$cshow :: PHRASE -> String
showsPrec :: Int -> PHRASE -> ShowS
$cshowsPrec :: Int -> PHRASE -> ShowS
Show, Eq PHRASE
Eq PHRASE =>
(PHRASE -> PHRASE -> Ordering)
-> (PHRASE -> PHRASE -> Bool)
-> (PHRASE -> PHRASE -> Bool)
-> (PHRASE -> PHRASE -> Bool)
-> (PHRASE -> PHRASE -> Bool)
-> (PHRASE -> PHRASE -> PHRASE)
-> (PHRASE -> PHRASE -> PHRASE)
-> Ord PHRASE
PHRASE -> PHRASE -> Bool
PHRASE -> PHRASE -> Ordering
PHRASE -> PHRASE -> PHRASE
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 :: PHRASE -> PHRASE -> PHRASE
$cmin :: PHRASE -> PHRASE -> PHRASE
max :: PHRASE -> PHRASE -> PHRASE
$cmax :: PHRASE -> PHRASE -> PHRASE
>= :: PHRASE -> PHRASE -> Bool
$c>= :: PHRASE -> PHRASE -> Bool
> :: PHRASE -> PHRASE -> Bool
$c> :: PHRASE -> PHRASE -> Bool
<= :: PHRASE -> PHRASE -> Bool
$c<= :: PHRASE -> PHRASE -> Bool
< :: PHRASE -> PHRASE -> Bool
$c< :: PHRASE -> PHRASE -> Bool
compare :: PHRASE -> PHRASE -> Ordering
$ccompare :: PHRASE -> PHRASE -> Ordering
$cp1Ord :: Eq PHRASE
Ord, PHRASE -> PHRASE -> Bool
(PHRASE -> PHRASE -> Bool)
-> (PHRASE -> PHRASE -> Bool) -> Eq PHRASE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PHRASE -> PHRASE -> Bool
$c/= :: PHRASE -> PHRASE -> Bool
== :: PHRASE -> PHRASE -> Bool
$c== :: PHRASE -> PHRASE -> Bool
Eq, Typeable, Typeable PHRASE
Constr
DataType
Typeable PHRASE =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PHRASE -> c PHRASE)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PHRASE)
-> (PHRASE -> Constr)
-> (PHRASE -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PHRASE))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PHRASE))
-> ((forall b. Data b => b -> b) -> PHRASE -> PHRASE)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PHRASE -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PHRASE -> r)
-> (forall u. (forall d. Data d => d -> u) -> PHRASE -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PHRASE -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PHRASE -> m PHRASE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PHRASE -> m PHRASE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PHRASE -> m PHRASE)
-> Data PHRASE
PHRASE -> Constr
PHRASE -> DataType
(forall b. Data b => b -> b) -> PHRASE -> PHRASE
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PHRASE -> c PHRASE
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PHRASE
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) -> PHRASE -> u
forall u. (forall d. Data d => d -> u) -> PHRASE -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PHRASE -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PHRASE -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PHRASE
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PHRASE -> c PHRASE
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PHRASE)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PHRASE)
$cComment_text :: Constr
$cImportation :: Constr
$cSentence :: Constr
$cModule :: Constr
$tPHRASE :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
gmapMp :: (forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
gmapM :: (forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PHRASE -> m PHRASE
gmapQi :: Int -> (forall d. Data d => d -> u) -> PHRASE -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PHRASE -> u
gmapQ :: (forall d. Data d => d -> u) -> PHRASE -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PHRASE -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PHRASE -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PHRASE -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PHRASE -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PHRASE -> r
gmapT :: (forall b. Data b => b -> b) -> PHRASE -> PHRASE
$cgmapT :: (forall b. Data b => b -> b) -> PHRASE -> PHRASE
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PHRASE)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PHRASE)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PHRASE)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PHRASE)
dataTypeOf :: PHRASE -> DataType
$cdataTypeOf :: PHRASE -> DataType
toConstr :: PHRASE -> Constr
$ctoConstr :: PHRASE -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PHRASE
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PHRASE
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PHRASE -> c PHRASE
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PHRASE -> c PHRASE
$cp1Data :: Typeable PHRASE
Data)

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

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

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

data SENTENCE = Quant_sent QUANT [NAME_OR_SEQMARK] SENTENCE Id.Range
              | Bool_sent BOOL_SENT Id.Range
              | Atom_sent ATOM Id.Range
              | Comment_sent COMMENT SENTENCE Id.Range
              | Irregular_sent SENTENCE Id.Range
                deriving (Int -> SENTENCE -> ShowS
[SENTENCE] -> ShowS
SENTENCE -> String
(Int -> SENTENCE -> ShowS)
-> (SENTENCE -> String) -> ([SENTENCE] -> ShowS) -> Show SENTENCE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SENTENCE] -> ShowS
$cshowList :: [SENTENCE] -> ShowS
show :: SENTENCE -> String
$cshow :: SENTENCE -> String
showsPrec :: Int -> SENTENCE -> ShowS
$cshowsPrec :: Int -> SENTENCE -> ShowS
Show, Eq SENTENCE
Eq SENTENCE =>
(SENTENCE -> SENTENCE -> Ordering)
-> (SENTENCE -> SENTENCE -> Bool)
-> (SENTENCE -> SENTENCE -> Bool)
-> (SENTENCE -> SENTENCE -> Bool)
-> (SENTENCE -> SENTENCE -> Bool)
-> (SENTENCE -> SENTENCE -> SENTENCE)
-> (SENTENCE -> SENTENCE -> SENTENCE)
-> Ord SENTENCE
SENTENCE -> SENTENCE -> Bool
SENTENCE -> SENTENCE -> Ordering
SENTENCE -> SENTENCE -> SENTENCE
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 :: SENTENCE -> SENTENCE -> SENTENCE
$cmin :: SENTENCE -> SENTENCE -> SENTENCE
max :: SENTENCE -> SENTENCE -> SENTENCE
$cmax :: SENTENCE -> SENTENCE -> SENTENCE
>= :: SENTENCE -> SENTENCE -> Bool
$c>= :: SENTENCE -> SENTENCE -> Bool
> :: SENTENCE -> SENTENCE -> Bool
$c> :: SENTENCE -> SENTENCE -> Bool
<= :: SENTENCE -> SENTENCE -> Bool
$c<= :: SENTENCE -> SENTENCE -> Bool
< :: SENTENCE -> SENTENCE -> Bool
$c< :: SENTENCE -> SENTENCE -> Bool
compare :: SENTENCE -> SENTENCE -> Ordering
$ccompare :: SENTENCE -> SENTENCE -> Ordering
$cp1Ord :: Eq SENTENCE
Ord, SENTENCE -> SENTENCE -> Bool
(SENTENCE -> SENTENCE -> Bool)
-> (SENTENCE -> SENTENCE -> Bool) -> Eq SENTENCE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SENTENCE -> SENTENCE -> Bool
$c/= :: SENTENCE -> SENTENCE -> Bool
== :: SENTENCE -> SENTENCE -> Bool
$c== :: SENTENCE -> SENTENCE -> Bool
Eq, Typeable, Typeable SENTENCE
Constr
DataType
Typeable SENTENCE =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SENTENCE -> c SENTENCE)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SENTENCE)
-> (SENTENCE -> Constr)
-> (SENTENCE -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SENTENCE))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SENTENCE))
-> ((forall b. Data b => b -> b) -> SENTENCE -> SENTENCE)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SENTENCE -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SENTENCE -> r)
-> (forall u. (forall d. Data d => d -> u) -> SENTENCE -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SENTENCE -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE)
-> Data SENTENCE
SENTENCE -> Constr
SENTENCE -> DataType
(forall b. Data b => b -> b) -> SENTENCE -> SENTENCE
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SENTENCE -> c SENTENCE
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SENTENCE
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) -> SENTENCE -> u
forall u. (forall d. Data d => d -> u) -> SENTENCE -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SENTENCE -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SENTENCE -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SENTENCE
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SENTENCE -> c SENTENCE
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SENTENCE)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SENTENCE)
$cIrregular_sent :: Constr
$cComment_sent :: Constr
$cAtom_sent :: Constr
$cBool_sent :: Constr
$cQuant_sent :: Constr
$tSENTENCE :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
gmapMp :: (forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
gmapM :: (forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SENTENCE -> m SENTENCE
gmapQi :: Int -> (forall d. Data d => d -> u) -> SENTENCE -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SENTENCE -> u
gmapQ :: (forall d. Data d => d -> u) -> SENTENCE -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SENTENCE -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SENTENCE -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SENTENCE -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SENTENCE -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SENTENCE -> r
gmapT :: (forall b. Data b => b -> b) -> SENTENCE -> SENTENCE
$cgmapT :: (forall b. Data b => b -> b) -> SENTENCE -> SENTENCE
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SENTENCE)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SENTENCE)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SENTENCE)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SENTENCE)
dataTypeOf :: SENTENCE -> DataType
$cdataTypeOf :: SENTENCE -> DataType
toConstr :: SENTENCE -> Constr
$ctoConstr :: SENTENCE -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SENTENCE
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SENTENCE
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SENTENCE -> c SENTENCE
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SENTENCE -> c SENTENCE
$cp1Data :: Typeable SENTENCE
Data)

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

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

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

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

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

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

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


type NAME = Id.Token
type SEQ_MARK = Id.Token

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

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

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

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


-- pretty printing using CLIF
instance Pretty BASIC_SPEC where
    pretty :: BASIC_SPEC -> Doc
pretty = BASIC_SPEC -> Doc
printBasicSpec
instance Pretty BASIC_ITEMS where
    pretty :: BASIC_ITEMS -> Doc
pretty = BASIC_ITEMS -> Doc
printBasicItems
instance Pretty TEXT_META where
   pretty :: TEXT_META -> Doc
pretty = TEXT_META -> Doc
printTextMeta
instance Pretty TEXT where
   pretty :: TEXT -> Doc
pretty = TEXT -> Doc
printText
instance Pretty PHRASE where
   pretty :: PHRASE -> Doc
pretty = PHRASE -> Doc
printPhrase
instance Pretty MODULE where
   pretty :: MODULE -> Doc
pretty = MODULE -> Doc
printModule
instance Pretty IMPORTATION where
   pretty :: IMPORTATION -> Doc
pretty = IMPORTATION -> Doc
printImportation
instance Pretty SENTENCE where
   pretty :: SENTENCE -> Doc
pretty = SENTENCE -> Doc
printSentence
instance Pretty BOOL_SENT where
   pretty :: BOOL_SENT -> Doc
pretty = BOOL_SENT -> Doc
printBoolSent
instance Pretty AndOr where
   pretty :: AndOr -> Doc
pretty = AndOr -> Doc
printAndOr
instance Pretty ImplEq where
   pretty :: ImplEq -> Doc
pretty = ImplEq -> Doc
printImplEq
instance Pretty QUANT where
   pretty :: QUANT -> Doc
pretty = QUANT -> Doc
printQuant
instance Pretty ATOM where
   pretty :: ATOM -> Doc
pretty = ATOM -> Doc
printAtom
instance Pretty TERM where
   pretty :: TERM -> Doc
pretty = TERM -> Doc
printTerm
instance Pretty TERM_SEQ where
   pretty :: TERM_SEQ -> Doc
pretty = TERM_SEQ -> Doc
printTermSeq
instance Pretty COMMENT where
   pretty :: COMMENT -> Doc
pretty = COMMENT -> Doc
printComment
instance Pretty NAME_OR_SEQMARK where
   pretty :: NAME_OR_SEQMARK -> Doc
pretty = NAME_OR_SEQMARK -> Doc
printNameOrSeqMark
instance Pretty SYMB_OR_MAP where
   pretty :: SYMB_OR_MAP -> Doc
pretty = SYMB_OR_MAP -> Doc
printSymbOrMap
instance Pretty SYMB_MAP_ITEMS where
   pretty :: SYMB_MAP_ITEMS -> Doc
pretty = SYMB_MAP_ITEMS -> Doc
printSymbMapItems
instance Pretty SYMB_ITEMS where
   pretty :: SYMB_ITEMS -> Doc
pretty = SYMB_ITEMS -> Doc
printSymbItems

printBasicSpec :: BASIC_SPEC -> Doc
printBasicSpec :: BASIC_SPEC -> Doc
printBasicSpec (Basic_spec xs :: [Annoted BASIC_ITEMS]
xs) = [Doc] -> Doc
vcat ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (Annoted BASIC_ITEMS -> Doc) -> [Annoted BASIC_ITEMS] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map Annoted BASIC_ITEMS -> Doc
forall a. Pretty a => a -> Doc
pretty [Annoted BASIC_ITEMS]
xs

printBasicItems :: BASIC_ITEMS -> Doc
printBasicItems :: BASIC_ITEMS -> Doc
printBasicItems (Axiom_items xs :: [Annoted TEXT_META]
xs) = [Doc] -> Doc
vcat ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (Annoted TEXT_META -> Doc) -> [Annoted TEXT_META] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map Annoted TEXT_META -> Doc
forall a. Pretty a => a -> Doc
pretty [Annoted TEXT_META]
xs

printTextMeta :: TEXT_META -> Doc
printTextMeta :: TEXT_META -> Doc
printTextMeta tm :: TEXT_META
tm = TEXT -> Doc
forall a. Pretty a => a -> Doc
pretty (TEXT -> Doc) -> TEXT -> Doc
forall a b. (a -> b) -> a -> b
$ TEXT_META -> TEXT
getText TEXT_META
tm

-- print basic spec as pure clif-texts, without any annotations
exportCLIF :: [AS_Anno.Named TEXT_META] -> Doc
exportCLIF :: [Named TEXT_META] -> Doc
exportCLIF xs :: [Named TEXT_META]
xs = [Doc] -> Doc
vsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (Named TEXT_META -> Doc) -> [Named TEXT_META] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (TEXT_META -> Doc
exportTextMeta (TEXT_META -> Doc)
-> (Named TEXT_META -> TEXT_META) -> Named TEXT_META -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Named TEXT_META -> TEXT_META
forall s a. SenAttr s a -> s
AS_Anno.sentence) [Named TEXT_META]
xs

exportBasicSpec :: BASIC_SPEC -> Doc
exportBasicSpec :: BASIC_SPEC -> Doc
exportBasicSpec (Basic_spec xs :: [Annoted BASIC_ITEMS]
xs) =
  [Doc] -> Doc
vsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (Annoted BASIC_ITEMS -> Doc) -> [Annoted BASIC_ITEMS] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (BASIC_ITEMS -> Doc
exportBasicItems (BASIC_ITEMS -> Doc)
-> (Annoted BASIC_ITEMS -> BASIC_ITEMS)
-> Annoted BASIC_ITEMS
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annoted BASIC_ITEMS -> BASIC_ITEMS
forall a. Annoted a -> a
AS_Anno.item) [Annoted BASIC_ITEMS]
xs

exportBasicItems :: BASIC_ITEMS -> Doc
exportBasicItems :: BASIC_ITEMS -> Doc
exportBasicItems (Axiom_items xs :: [Annoted TEXT_META]
xs) =
  [Doc] -> Doc
vsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (Annoted TEXT_META -> Doc) -> [Annoted TEXT_META] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (TEXT_META -> Doc
exportTextMeta (TEXT_META -> Doc)
-> (Annoted TEXT_META -> TEXT_META) -> Annoted TEXT_META -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annoted TEXT_META -> TEXT_META
forall a. Annoted a -> a
AS_Anno.item) [Annoted TEXT_META]
xs

exportTextMeta :: TEXT_META -> Doc
exportTextMeta :: TEXT_META -> Doc
exportTextMeta = TEXT -> Doc
forall a. Pretty a => a -> Doc
pretty (TEXT -> Doc) -> (TEXT_META -> TEXT) -> TEXT_META -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TEXT_META -> TEXT
getText

-- using pure clif syntax from here
printText :: TEXT -> Doc
printText :: TEXT -> Doc
printText s :: TEXT
s = case TEXT
s of
  Text x :: [PHRASE]
x _ -> [Doc] -> Doc
fsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (PHRASE -> Doc) -> [PHRASE] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map PHRASE -> Doc
forall a. Pretty a => a -> Doc
pretty [PHRASE]
x
  Named_text x :: NAME
x y :: TEXT
y _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
clTextS Doc -> Doc -> Doc
<+> NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
x Doc -> Doc -> Doc
<+> TEXT -> Doc
forall a. Pretty a => a -> Doc
pretty TEXT
y

printPhrase :: PHRASE -> Doc
printPhrase :: PHRASE -> Doc
printPhrase s :: PHRASE
s = case PHRASE
s of
  Module x :: MODULE
x -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
clModuleS Doc -> Doc -> Doc
<+> MODULE -> Doc
forall a. Pretty a => a -> Doc
pretty MODULE
x
  Sentence x :: SENTENCE
x -> SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
x
  Importation x :: IMPORTATION
x -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
clImportS Doc -> Doc -> Doc
<+> IMPORTATION -> Doc
forall a. Pretty a => a -> Doc
pretty IMPORTATION
x
  Comment_text x :: COMMENT
x y :: TEXT
y _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
clCommentS Doc -> Doc -> Doc
<+> COMMENT -> Doc
forall a. Pretty a => a -> Doc
pretty COMMENT
x Doc -> Doc -> Doc
<+> TEXT -> Doc
forall a. Pretty a => a -> Doc
pretty TEXT
y

printModule :: MODULE -> Doc
printModule :: MODULE -> Doc
printModule (Mod x :: NAME
x z :: TEXT
z _) = NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
x Doc -> Doc -> Doc
<+> TEXT -> Doc
forall a. Pretty a => a -> Doc
pretty TEXT
z
printModule (Mod_ex x :: NAME
x y :: [NAME]
y z :: TEXT
z _) =
  NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
x Doc -> Doc -> Doc
<+> Doc -> Doc
parens (String -> Doc
text String
clExcludeS Doc -> Doc -> Doc
<+> [Doc] -> Doc
fsep ((NAME -> Doc) -> [NAME] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map NAME -> Doc
forall a. Pretty a => a -> Doc
pretty [NAME]
y)) Doc -> Doc -> Doc
<+> TEXT -> Doc
forall a. Pretty a => a -> Doc
pretty TEXT
z

printImportation :: IMPORTATION -> Doc
printImportation :: IMPORTATION -> Doc
printImportation (Imp_name x :: NAME
x) = NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
x

printSentence :: SENTENCE -> Doc
printSentence :: SENTENCE -> Doc
printSentence s :: SENTENCE
s = case SENTENCE
s of
    Quant_sent q :: QUANT
q vs :: [NAME_OR_SEQMARK]
vs is :: SENTENCE
is _ ->
      Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ QUANT -> Doc
forall a. Pretty a => a -> Doc
pretty QUANT
q Doc -> Doc -> Doc
<+> Doc -> Doc
parens ([Doc] -> Doc
sep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (NAME_OR_SEQMARK -> Doc) -> [NAME_OR_SEQMARK] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map NAME_OR_SEQMARK -> Doc
forall a. Pretty a => a -> Doc
pretty [NAME_OR_SEQMARK]
vs) Doc -> Doc -> Doc
<+> SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
is
    Bool_sent xs :: BOOL_SENT
xs _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ BOOL_SENT -> Doc
forall a. Pretty a => a -> Doc
pretty BOOL_SENT
xs
    Atom_sent xs :: ATOM
xs _ -> ATOM -> Doc
forall a. Pretty a => a -> Doc
pretty ATOM
xs
    Comment_sent x :: COMMENT
x y :: SENTENCE
y _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
clCommentS Doc -> Doc -> Doc
<+> COMMENT -> Doc
forall a. Pretty a => a -> Doc
pretty COMMENT
x Doc -> Doc -> Doc
<+> SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
y
    Irregular_sent xs :: SENTENCE
xs _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
xs

printComment :: COMMENT -> Doc
printComment :: COMMENT -> Doc
printComment s :: COMMENT
s = case COMMENT
s of
   Comment x :: String
x _ -> String -> Doc
text String
x

printQuant :: QUANT -> Doc
printQuant :: QUANT -> Doc
printQuant s :: QUANT
s = case QUANT
s of
  Universal -> String -> Doc
text String
forallS
  Existential -> String -> Doc
text String
existsS

printBoolSent :: BOOL_SENT -> Doc
printBoolSent :: BOOL_SENT -> Doc
printBoolSent s :: BOOL_SENT
s = case BOOL_SENT
s of
   Junction q :: AndOr
q xs :: [SENTENCE]
xs -> AndOr -> Doc
forall a. Pretty a => a -> Doc
pretty AndOr
q Doc -> Doc -> Doc
<+> [Doc] -> Doc
fsep ((SENTENCE -> Doc) -> [SENTENCE] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty [SENTENCE]
xs)
   Negation xs :: SENTENCE
xs -> String -> Doc
text String
notS Doc -> Doc -> Doc
<+> SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
xs
   BinOp q :: ImplEq
q x :: SENTENCE
x y :: SENTENCE
y -> ImplEq -> Doc
forall a. Pretty a => a -> Doc
pretty ImplEq
q Doc -> Doc -> Doc
<+> SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
x Doc -> Doc -> Doc
<+> SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
y

printAndOr :: AndOr -> Doc
printAndOr :: AndOr -> Doc
printAndOr s :: AndOr
s = case AndOr
s of
  Conjunction -> String -> Doc
text String
andS
  Disjunction -> String -> Doc
text String
orS

printImplEq :: ImplEq -> Doc
printImplEq :: ImplEq -> Doc
printImplEq s :: ImplEq
s = case ImplEq
s of
  Implication -> String -> Doc
text String
ifS
  Biconditional -> String -> Doc
text String
iffS

printAtom :: ATOM -> Doc
printAtom :: ATOM -> Doc
printAtom s :: ATOM
s = case ATOM
s of
   Equation a :: TERM
a b :: TERM
b -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ Doc
equals Doc -> Doc -> Doc
<+> TERM -> Doc
forall a. Pretty a => a -> Doc
pretty TERM
a Doc -> Doc -> Doc
<+> TERM -> Doc
forall a. Pretty a => a -> Doc
pretty TERM
b
   Atom t :: TERM
t ts :: [TERM_SEQ]
ts -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ TERM -> Doc
forall a. Pretty a => a -> Doc
pretty TERM
t Doc -> Doc -> Doc
<+> [Doc] -> Doc
sep ((TERM_SEQ -> Doc) -> [TERM_SEQ] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map TERM_SEQ -> Doc
forall a. Pretty a => a -> Doc
pretty [TERM_SEQ]
ts)

printTerm :: TERM -> Doc
printTerm :: TERM -> Doc
printTerm s :: TERM
s = case TERM
s of
   Name_term a :: NAME
a -> NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
a
   Funct_term t :: TERM
t ts :: [TERM_SEQ]
ts _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ TERM -> Doc
forall a. Pretty a => a -> Doc
pretty TERM
t Doc -> Doc -> Doc
<+> [Doc] -> Doc
fsep ((TERM_SEQ -> Doc) -> [TERM_SEQ] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map TERM_SEQ -> Doc
forall a. Pretty a => a -> Doc
pretty [TERM_SEQ]
ts)
   Comment_term t :: TERM
t c :: COMMENT
c _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
clCommentS Doc -> Doc -> Doc
<+> COMMENT -> Doc
forall a. Pretty a => a -> Doc
pretty COMMENT
c Doc -> Doc -> Doc
<+> TERM -> Doc
forall a. Pretty a => a -> Doc
pretty TERM
t
   That_term sent :: SENTENCE
sent _ -> Doc -> Doc
parens (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text "that" Doc -> Doc -> Doc
<+> SENTENCE -> Doc
forall a. Pretty a => a -> Doc
pretty SENTENCE
sent

printTermSeq :: TERM_SEQ -> Doc
printTermSeq :: TERM_SEQ -> Doc
printTermSeq s :: TERM_SEQ
s = case TERM_SEQ
s of
  Term_seq t :: TERM
t -> TERM -> Doc
forall a. Pretty a => a -> Doc
pretty TERM
t
  Seq_marks m :: NAME
m -> NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
m

-- Binding Seq
printNameOrSeqMark :: NAME_OR_SEQMARK -> Doc
printNameOrSeqMark :: NAME_OR_SEQMARK -> Doc
printNameOrSeqMark s :: NAME_OR_SEQMARK
s = case NAME_OR_SEQMARK
s of
  Name x :: NAME
x -> NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
x
  SeqMark x :: NAME
x -> NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
x
  -- Alt x y -> pretty x <+> pretty y

printSymbOrMap :: SYMB_OR_MAP -> Doc
printSymbOrMap :: SYMB_OR_MAP -> Doc
printSymbOrMap (Symb nos :: NAME_OR_SEQMARK
nos) = NAME_OR_SEQMARK -> Doc
forall a. Pretty a => a -> Doc
pretty NAME_OR_SEQMARK
nos
printSymbOrMap (Symb_mapN source :: NAME
source dest :: NAME
dest _) =
  NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
source Doc -> Doc -> Doc
<+> Doc
mapsto Doc -> Doc -> Doc
<+> NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
dest Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> Doc
space
printSymbOrMap (Symb_mapS source :: NAME
source dest :: NAME
dest _) =
  NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
source Doc -> Doc -> Doc
<+> Doc
mapsto Doc -> Doc -> Doc
<+> NAME -> Doc
forall a. Pretty a => a -> Doc
pretty NAME
dest Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> Doc
space
{- space needed. without space the comma (from printSymbMapItems)
would be part of the name @dest@ -}

printSymbMapItems :: SYMB_MAP_ITEMS -> Doc
printSymbMapItems :: SYMB_MAP_ITEMS -> Doc
printSymbMapItems (Symb_map_items xs :: [SYMB_OR_MAP]
xs _) = [SYMB_OR_MAP] -> Doc
forall a. Pretty a => [a] -> Doc
ppWithCommas [SYMB_OR_MAP]
xs

printSymbItems :: SYMB_ITEMS -> Doc
printSymbItems :: SYMB_ITEMS -> Doc
printSymbItems (Symb_items xs :: [NAME_OR_SEQMARK]
xs _) = [Doc] -> Doc
fsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (NAME_OR_SEQMARK -> Doc) -> [NAME_OR_SEQMARK] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map NAME_OR_SEQMARK -> Doc
forall a. Pretty a => a -> Doc
pretty [NAME_OR_SEQMARK]
xs

-- keywords, reservednames in CLIF
orS :: String
orS :: String
orS = "or"

iffS :: String
iffS :: String
iffS = "iff"

clCommentS :: String
clCommentS :: String
clCommentS = "cl-comment"

clTextS :: String
clTextS :: String
clTextS = "cl-text"

clImportS :: String
clImportS :: String
clImportS = "cl-imports"

clModuleS :: String
clModuleS :: String
clModuleS = "cl-module"

clExcludeS :: String
clExcludeS :: String
clExcludeS = "cl-excludes"

-- Generated by DrIFT, look but don't touch!

instance GetRange BASIC_SPEC where
  getRange :: BASIC_SPEC -> Range
getRange = Range -> BASIC_SPEC -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: BASIC_SPEC -> [Pos]
rangeSpan x :: BASIC_SPEC
x = case BASIC_SPEC
x of
    Basic_spec a :: [Annoted BASIC_ITEMS]
a -> [[Pos]] -> [Pos]
joinRanges [[Annoted BASIC_ITEMS] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted BASIC_ITEMS]
a]

instance GetRange BASIC_ITEMS where
  getRange :: BASIC_ITEMS -> Range
getRange = Range -> BASIC_ITEMS -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: BASIC_ITEMS -> [Pos]
rangeSpan x :: BASIC_ITEMS
x = case BASIC_ITEMS
x of
    Axiom_items a :: [Annoted TEXT_META]
a -> [[Pos]] -> [Pos]
joinRanges [[Annoted TEXT_META] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted TEXT_META]
a]

instance GetRange TEXT_META where
  getRange :: TEXT_META -> Range
getRange = Range -> TEXT_META -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TEXT_META -> [Pos]
rangeSpan x :: TEXT_META
x = case TEXT_META
x of
    Text_meta a :: TEXT
a b :: Maybe IRI
b c :: Maybe (Set NAME)
c d :: [PrefixMapping]
d -> [[Pos]] -> [Pos]
joinRanges [TEXT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TEXT
a, Maybe IRI -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe IRI
b,
                                     Maybe (Set NAME) -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe (Set NAME)
c, [PrefixMapping] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [PrefixMapping]
d]

instance GetRange TEXT where
  getRange :: TEXT -> Range
getRange = Range -> TEXT -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TEXT -> [Pos]
rangeSpan x :: TEXT
x = case TEXT
x of
    Text a :: [PHRASE]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[PHRASE] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [PHRASE]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Named_text a :: NAME
a b :: TEXT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a, TEXT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TEXT
b,
                                    Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

instance GetRange PHRASE where
  getRange :: PHRASE -> Range
getRange = Range -> PHRASE -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: PHRASE -> [Pos]
rangeSpan x :: PHRASE
x = case PHRASE
x of
    Module a :: MODULE
a -> [[Pos]] -> [Pos]
joinRanges [MODULE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan MODULE
a]
    Sentence a :: SENTENCE
a -> [[Pos]] -> [Pos]
joinRanges [SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
a]
    Importation a :: IMPORTATION
a -> [[Pos]] -> [Pos]
joinRanges [IMPORTATION -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan IMPORTATION
a]
    Comment_text a :: COMMENT
a b :: TEXT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [COMMENT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan COMMENT
a, TEXT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TEXT
b,
                                      Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

instance GetRange COMMENT where
  getRange :: COMMENT -> Range
getRange = Range -> COMMENT -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: COMMENT -> [Pos]
rangeSpan x :: COMMENT
x = case COMMENT
x of
    Comment a :: String
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [String -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan String
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange MODULE where
  getRange :: MODULE -> Range
getRange = Range -> MODULE -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: MODULE -> [Pos]
rangeSpan x :: MODULE
x = case MODULE
x of
    Mod a :: NAME
a b :: TEXT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a, TEXT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TEXT
b, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Mod_ex a :: NAME
a b :: [NAME]
b c :: TEXT
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a, [NAME] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [NAME]
b,
                                  TEXT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TEXT
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]

instance GetRange IMPORTATION where
  getRange :: IMPORTATION -> Range
getRange = Range -> IMPORTATION -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: IMPORTATION -> [Pos]
rangeSpan x :: IMPORTATION
x = case IMPORTATION
x of
    Imp_name a :: NAME
a -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a]

instance GetRange SENTENCE where
  getRange :: SENTENCE -> Range
getRange = Range -> SENTENCE -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: SENTENCE -> [Pos]
rangeSpan x :: SENTENCE
x = case SENTENCE
x of
    Quant_sent a :: QUANT
a b :: [NAME_OR_SEQMARK]
b c :: SENTENCE
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [QUANT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan QUANT
a, [NAME_OR_SEQMARK] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [NAME_OR_SEQMARK]
b,
                                      SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Bool_sent a :: BOOL_SENT
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [BOOL_SENT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan BOOL_SENT
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Atom_sent a :: ATOM
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [ATOM -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan ATOM
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Comment_sent a :: COMMENT
a b :: SENTENCE
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [COMMENT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan COMMENT
a, SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
b,
                                      Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Irregular_sent a :: SENTENCE
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange QUANT where
  getRange :: QUANT -> Range
getRange = Range -> QUANT -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: QUANT -> [Pos]
rangeSpan x :: QUANT
x = case QUANT
x of
    Universal -> []
    Existential -> []

instance GetRange BOOL_SENT where
  getRange :: BOOL_SENT -> Range
getRange = Range -> BOOL_SENT -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: BOOL_SENT -> [Pos]
rangeSpan x :: BOOL_SENT
x = case BOOL_SENT
x of
    Junction a :: AndOr
a b :: [SENTENCE]
b -> [[Pos]] -> [Pos]
joinRanges [AndOr -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AndOr
a, [SENTENCE] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SENTENCE]
b]
    Negation a :: SENTENCE
a -> [[Pos]] -> [Pos]
joinRanges [SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
a]
    BinOp a :: ImplEq
a b :: SENTENCE
b c :: SENTENCE
c -> [[Pos]] -> [Pos]
joinRanges [ImplEq -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan ImplEq
a, SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
b, SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
c]

instance GetRange AndOr where
  getRange :: AndOr -> Range
getRange = Range -> AndOr -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: AndOr -> [Pos]
rangeSpan x :: AndOr
x = case AndOr
x of
    Conjunction -> []
    Disjunction -> []

instance GetRange ImplEq where
  getRange :: ImplEq -> Range
getRange = Range -> ImplEq -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: ImplEq -> [Pos]
rangeSpan x :: ImplEq
x = case ImplEq
x of
    Implication -> []
    Biconditional -> []

instance GetRange ATOM where
  getRange :: ATOM -> Range
getRange = Range -> ATOM -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: ATOM -> [Pos]
rangeSpan x :: ATOM
x = case ATOM
x of
    Equation a :: TERM
a b :: TERM
b -> [[Pos]] -> [Pos]
joinRanges [TERM -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM
a, TERM -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM
b]
    Atom a :: TERM
a b :: [TERM_SEQ]
b -> [[Pos]] -> [Pos]
joinRanges [TERM -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM
a, [TERM_SEQ] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM_SEQ]
b]

instance GetRange TERM where
  getRange :: TERM -> Range
getRange = Range -> TERM -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TERM -> [Pos]
rangeSpan x :: TERM
x = case TERM
x of
    Name_term a :: NAME
a -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a]
    Funct_term a :: TERM
a b :: [TERM_SEQ]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [TERM -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM
a, [TERM_SEQ] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM_SEQ]
b,
                                    Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Comment_term a :: TERM
a b :: COMMENT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [TERM -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM
a, COMMENT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan COMMENT
b,
                                      Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    That_term a :: SENTENCE
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [SENTENCE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SENTENCE
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange TERM_SEQ where
  getRange :: TERM_SEQ -> Range
getRange = Range -> TERM_SEQ -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TERM_SEQ -> [Pos]
rangeSpan x :: TERM_SEQ
x = case TERM_SEQ
x of
    Term_seq a :: TERM
a -> [[Pos]] -> [Pos]
joinRanges [TERM -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM
a]
    Seq_marks a :: NAME
a -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a]

instance GetRange NAME_OR_SEQMARK where
  getRange :: NAME_OR_SEQMARK -> Range
getRange = Range -> NAME_OR_SEQMARK -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: NAME_OR_SEQMARK -> [Pos]
rangeSpan x :: NAME_OR_SEQMARK
x = case NAME_OR_SEQMARK
x of
    Name a :: NAME
a -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a]
    SeqMark a :: NAME
a -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a]

instance GetRange SYMB_MAP_ITEMS where
  getRange :: SYMB_MAP_ITEMS -> Range
getRange = Range -> SYMB_MAP_ITEMS -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: SYMB_MAP_ITEMS -> [Pos]
rangeSpan x :: SYMB_MAP_ITEMS
x = case SYMB_MAP_ITEMS
x of
    Symb_map_items a :: [SYMB_OR_MAP]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[SYMB_OR_MAP] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SYMB_OR_MAP]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange SYMB_OR_MAP where
  getRange :: SYMB_OR_MAP -> Range
getRange = Range -> SYMB_OR_MAP -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: SYMB_OR_MAP -> [Pos]
rangeSpan x :: SYMB_OR_MAP
x = case SYMB_OR_MAP
x of
    Symb a :: NAME_OR_SEQMARK
a -> [[Pos]] -> [Pos]
joinRanges [NAME_OR_SEQMARK -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME_OR_SEQMARK
a]
    Symb_mapN a :: NAME
a b :: NAME
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a, NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
b,
                                   Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Symb_mapS a :: NAME
a b :: NAME
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
a, NAME -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan NAME
b,
                                   Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

instance GetRange SYMB_ITEMS where
  getRange :: SYMB_ITEMS -> Range
getRange = Range -> SYMB_ITEMS -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: SYMB_ITEMS -> [Pos]
rangeSpan x :: SYMB_ITEMS
x = case SYMB_ITEMS
x of
    Symb_items a :: [NAME_OR_SEQMARK]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[NAME_OR_SEQMARK] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [NAME_OR_SEQMARK]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]