{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./THF/As.der.hs
Description :  A abstract syntax for the TPTP-THF Syntax
Copyright   :  (c) A. Tsogias, DFKI Bremen 2011
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  Alexis.Tsogias@dfki.de
Stability   :  provisional
Portability :  portable

A Abstract Syntax for the TPTP-THF Input Syntax v5.1.0.2 taken from
<http://www.cs.miami.edu/~tptp/TPTP/SyntaxBNF.html>
In addition the Syntax for THF0 taken from
<http://www.ags.uni-sb.de/~chris/papers/C25.pdf> P. 15-16
has been added where needed.
-}

module THF.As where

import Common.Id

import Data.Data

{-! global: GetRange !-}

{- ---------------------------------------------------------------------------
Abstract Syntax for THF in general and THF0
For Explanation of the data types refer to the comments in ParseTHF
------------------------------------------------------------------------------
Questions:
at the example of <source>: Sould <general_term> be also
tried when all ather variations fail?
----------------------------------------------------------------------------- -}

data TPTP_THF =
    TPTP_THF_Annotated_Formula { TPTP_THF -> Name
nameAF :: Name
                                , TPTP_THF -> FormulaRole
formulaRoleAF :: FormulaRole
                                , TPTP_THF -> THFFormula
thfFormulaAF :: THFFormula
                                , TPTP_THF -> Annotations
annotationsAF :: Annotations}
  | TPTP_Include Include
  | TPTP_Comment Comment
  | TPTP_Defined_Comment DefinedComment
  | TPTP_System_Comment SystemComment
  | TPTP_Header [Comment]
    deriving (Int -> TPTP_THF -> ShowS
[TPTP_THF] -> ShowS
TPTP_THF -> String
(Int -> TPTP_THF -> ShowS)
-> (TPTP_THF -> String) -> ([TPTP_THF] -> ShowS) -> Show TPTP_THF
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TPTP_THF] -> ShowS
$cshowList :: [TPTP_THF] -> ShowS
show :: TPTP_THF -> String
$cshow :: TPTP_THF -> String
showsPrec :: Int -> TPTP_THF -> ShowS
$cshowsPrec :: Int -> TPTP_THF -> ShowS
Show, TPTP_THF -> TPTP_THF -> Bool
(TPTP_THF -> TPTP_THF -> Bool)
-> (TPTP_THF -> TPTP_THF -> Bool) -> Eq TPTP_THF
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TPTP_THF -> TPTP_THF -> Bool
$c/= :: TPTP_THF -> TPTP_THF -> Bool
== :: TPTP_THF -> TPTP_THF -> Bool
$c== :: TPTP_THF -> TPTP_THF -> Bool
Eq, Eq TPTP_THF
Eq TPTP_THF =>
(TPTP_THF -> TPTP_THF -> Ordering)
-> (TPTP_THF -> TPTP_THF -> Bool)
-> (TPTP_THF -> TPTP_THF -> Bool)
-> (TPTP_THF -> TPTP_THF -> Bool)
-> (TPTP_THF -> TPTP_THF -> Bool)
-> (TPTP_THF -> TPTP_THF -> TPTP_THF)
-> (TPTP_THF -> TPTP_THF -> TPTP_THF)
-> Ord TPTP_THF
TPTP_THF -> TPTP_THF -> Bool
TPTP_THF -> TPTP_THF -> Ordering
TPTP_THF -> TPTP_THF -> TPTP_THF
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 :: TPTP_THF -> TPTP_THF -> TPTP_THF
$cmin :: TPTP_THF -> TPTP_THF -> TPTP_THF
max :: TPTP_THF -> TPTP_THF -> TPTP_THF
$cmax :: TPTP_THF -> TPTP_THF -> TPTP_THF
>= :: TPTP_THF -> TPTP_THF -> Bool
$c>= :: TPTP_THF -> TPTP_THF -> Bool
> :: TPTP_THF -> TPTP_THF -> Bool
$c> :: TPTP_THF -> TPTP_THF -> Bool
<= :: TPTP_THF -> TPTP_THF -> Bool
$c<= :: TPTP_THF -> TPTP_THF -> Bool
< :: TPTP_THF -> TPTP_THF -> Bool
$c< :: TPTP_THF -> TPTP_THF -> Bool
compare :: TPTP_THF -> TPTP_THF -> Ordering
$ccompare :: TPTP_THF -> TPTP_THF -> Ordering
$cp1Ord :: Eq TPTP_THF
Ord, Typeable, Typeable TPTP_THF
Constr
DataType
Typeable TPTP_THF =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TPTP_THF -> c TPTP_THF)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TPTP_THF)
-> (TPTP_THF -> Constr)
-> (TPTP_THF -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TPTP_THF))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TPTP_THF))
-> ((forall b. Data b => b -> b) -> TPTP_THF -> TPTP_THF)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r)
-> (forall u. (forall d. Data d => d -> u) -> TPTP_THF -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TPTP_THF -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF)
-> Data TPTP_THF
TPTP_THF -> Constr
TPTP_THF -> DataType
(forall b. Data b => b -> b) -> TPTP_THF -> TPTP_THF
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_THF -> c TPTP_THF
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_THF
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) -> TPTP_THF -> u
forall u. (forall d. Data d => d -> u) -> TPTP_THF -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_THF
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_THF -> c TPTP_THF
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TPTP_THF)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TPTP_THF)
$cTPTP_Header :: Constr
$cTPTP_System_Comment :: Constr
$cTPTP_Defined_Comment :: Constr
$cTPTP_Comment :: Constr
$cTPTP_Include :: Constr
$cTPTP_THF_Annotated_Formula :: Constr
$tTPTP_THF :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
gmapMp :: (forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
gmapM :: (forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TPTP_THF -> m TPTP_THF
gmapQi :: Int -> (forall d. Data d => d -> u) -> TPTP_THF -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TPTP_THF -> u
gmapQ :: (forall d. Data d => d -> u) -> TPTP_THF -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TPTP_THF -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_THF -> r
gmapT :: (forall b. Data b => b -> b) -> TPTP_THF -> TPTP_THF
$cgmapT :: (forall b. Data b => b -> b) -> TPTP_THF -> TPTP_THF
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TPTP_THF)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TPTP_THF)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TPTP_THF)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TPTP_THF)
dataTypeOf :: TPTP_THF -> DataType
$cdataTypeOf :: TPTP_THF -> DataType
toConstr :: TPTP_THF -> Constr
$ctoConstr :: TPTP_THF -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_THF
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_THF
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_THF -> c TPTP_THF
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_THF -> c TPTP_THF
$cp1Data :: Typeable TPTP_THF
Data)

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

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

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

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

data FormulaRole =
    Axiom | Hypothesis | Definition | Assumption
  | Lemma | Theorem | Conjecture | Negated_Conjecture
  | Plain | Fi_Domain | Fi_Functors | Fi_Predicates
  | Type | Unknown
    deriving (Int -> FormulaRole -> ShowS
[FormulaRole] -> ShowS
FormulaRole -> String
(Int -> FormulaRole -> ShowS)
-> (FormulaRole -> String)
-> ([FormulaRole] -> ShowS)
-> Show FormulaRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormulaRole] -> ShowS
$cshowList :: [FormulaRole] -> ShowS
show :: FormulaRole -> String
$cshow :: FormulaRole -> String
showsPrec :: Int -> FormulaRole -> ShowS
$cshowsPrec :: Int -> FormulaRole -> ShowS
Show, FormulaRole -> FormulaRole -> Bool
(FormulaRole -> FormulaRole -> Bool)
-> (FormulaRole -> FormulaRole -> Bool) -> Eq FormulaRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormulaRole -> FormulaRole -> Bool
$c/= :: FormulaRole -> FormulaRole -> Bool
== :: FormulaRole -> FormulaRole -> Bool
$c== :: FormulaRole -> FormulaRole -> Bool
Eq, Eq FormulaRole
Eq FormulaRole =>
(FormulaRole -> FormulaRole -> Ordering)
-> (FormulaRole -> FormulaRole -> Bool)
-> (FormulaRole -> FormulaRole -> Bool)
-> (FormulaRole -> FormulaRole -> Bool)
-> (FormulaRole -> FormulaRole -> Bool)
-> (FormulaRole -> FormulaRole -> FormulaRole)
-> (FormulaRole -> FormulaRole -> FormulaRole)
-> Ord FormulaRole
FormulaRole -> FormulaRole -> Bool
FormulaRole -> FormulaRole -> Ordering
FormulaRole -> FormulaRole -> FormulaRole
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 :: FormulaRole -> FormulaRole -> FormulaRole
$cmin :: FormulaRole -> FormulaRole -> FormulaRole
max :: FormulaRole -> FormulaRole -> FormulaRole
$cmax :: FormulaRole -> FormulaRole -> FormulaRole
>= :: FormulaRole -> FormulaRole -> Bool
$c>= :: FormulaRole -> FormulaRole -> Bool
> :: FormulaRole -> FormulaRole -> Bool
$c> :: FormulaRole -> FormulaRole -> Bool
<= :: FormulaRole -> FormulaRole -> Bool
$c<= :: FormulaRole -> FormulaRole -> Bool
< :: FormulaRole -> FormulaRole -> Bool
$c< :: FormulaRole -> FormulaRole -> Bool
compare :: FormulaRole -> FormulaRole -> Ordering
$ccompare :: FormulaRole -> FormulaRole -> Ordering
$cp1Ord :: Eq FormulaRole
Ord, Typeable, Typeable FormulaRole
Constr
DataType
Typeable FormulaRole =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FormulaRole -> c FormulaRole)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FormulaRole)
-> (FormulaRole -> Constr)
-> (FormulaRole -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FormulaRole))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FormulaRole))
-> ((forall b. Data b => b -> b) -> FormulaRole -> FormulaRole)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FormulaRole -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FormulaRole -> r)
-> (forall u. (forall d. Data d => d -> u) -> FormulaRole -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FormulaRole -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole)
-> Data FormulaRole
FormulaRole -> Constr
FormulaRole -> DataType
(forall b. Data b => b -> b) -> FormulaRole -> FormulaRole
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormulaRole -> c FormulaRole
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormulaRole
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) -> FormulaRole -> u
forall u. (forall d. Data d => d -> u) -> FormulaRole -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormulaRole -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormulaRole -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormulaRole
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormulaRole -> c FormulaRole
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FormulaRole)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FormulaRole)
$cUnknown :: Constr
$cType :: Constr
$cFi_Predicates :: Constr
$cFi_Functors :: Constr
$cFi_Domain :: Constr
$cPlain :: Constr
$cNegated_Conjecture :: Constr
$cConjecture :: Constr
$cTheorem :: Constr
$cLemma :: Constr
$cAssumption :: Constr
$cDefinition :: Constr
$cHypothesis :: Constr
$cAxiom :: Constr
$tFormulaRole :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
gmapMp :: (forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
gmapM :: (forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormulaRole -> m FormulaRole
gmapQi :: Int -> (forall d. Data d => d -> u) -> FormulaRole -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FormulaRole -> u
gmapQ :: (forall d. Data d => d -> u) -> FormulaRole -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FormulaRole -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormulaRole -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormulaRole -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormulaRole -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormulaRole -> r
gmapT :: (forall b. Data b => b -> b) -> FormulaRole -> FormulaRole
$cgmapT :: (forall b. Data b => b -> b) -> FormulaRole -> FormulaRole
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FormulaRole)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FormulaRole)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FormulaRole)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FormulaRole)
dataTypeOf :: FormulaRole -> DataType
$cdataTypeOf :: FormulaRole -> DataType
toConstr :: FormulaRole -> Constr
$ctoConstr :: FormulaRole -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormulaRole
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormulaRole
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormulaRole -> c FormulaRole
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormulaRole -> c FormulaRole
$cp1Data :: Typeable FormulaRole
Data)

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

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

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

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

data THFUnitaryFormula =
    TUF_THF_Quantified_Formula THFQuantifiedFormula
  | TUF_THF_Unary_Formula THFUnaryConnective THFLogicFormula
  | TUF_THF_Atom THFAtom
  | TUF_THF_Tuple THFTuple
  | TUF_THF_Conditional THFLogicFormula THFLogicFormula THFLogicFormula
  | TUF_THF_Logic_Formula_Par THFLogicFormula
  | T0UF_THF_Abstraction THFVariableList THFUnitaryFormula
    deriving (Int -> THFUnitaryFormula -> ShowS
[THFUnitaryFormula] -> ShowS
THFUnitaryFormula -> String
(Int -> THFUnitaryFormula -> ShowS)
-> (THFUnitaryFormula -> String)
-> ([THFUnitaryFormula] -> ShowS)
-> Show THFUnitaryFormula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THFUnitaryFormula] -> ShowS
$cshowList :: [THFUnitaryFormula] -> ShowS
show :: THFUnitaryFormula -> String
$cshow :: THFUnitaryFormula -> String
showsPrec :: Int -> THFUnitaryFormula -> ShowS
$cshowsPrec :: Int -> THFUnitaryFormula -> ShowS
Show, THFUnitaryFormula -> THFUnitaryFormula -> Bool
(THFUnitaryFormula -> THFUnitaryFormula -> Bool)
-> (THFUnitaryFormula -> THFUnitaryFormula -> Bool)
-> Eq THFUnitaryFormula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
$c/= :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
== :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
$c== :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
Eq, Eq THFUnitaryFormula
Eq THFUnitaryFormula =>
(THFUnitaryFormula -> THFUnitaryFormula -> Ordering)
-> (THFUnitaryFormula -> THFUnitaryFormula -> Bool)
-> (THFUnitaryFormula -> THFUnitaryFormula -> Bool)
-> (THFUnitaryFormula -> THFUnitaryFormula -> Bool)
-> (THFUnitaryFormula -> THFUnitaryFormula -> Bool)
-> (THFUnitaryFormula -> THFUnitaryFormula -> THFUnitaryFormula)
-> (THFUnitaryFormula -> THFUnitaryFormula -> THFUnitaryFormula)
-> Ord THFUnitaryFormula
THFUnitaryFormula -> THFUnitaryFormula -> Bool
THFUnitaryFormula -> THFUnitaryFormula -> Ordering
THFUnitaryFormula -> THFUnitaryFormula -> THFUnitaryFormula
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 :: THFUnitaryFormula -> THFUnitaryFormula -> THFUnitaryFormula
$cmin :: THFUnitaryFormula -> THFUnitaryFormula -> THFUnitaryFormula
max :: THFUnitaryFormula -> THFUnitaryFormula -> THFUnitaryFormula
$cmax :: THFUnitaryFormula -> THFUnitaryFormula -> THFUnitaryFormula
>= :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
$c>= :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
> :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
$c> :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
<= :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
$c<= :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
< :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
$c< :: THFUnitaryFormula -> THFUnitaryFormula -> Bool
compare :: THFUnitaryFormula -> THFUnitaryFormula -> Ordering
$ccompare :: THFUnitaryFormula -> THFUnitaryFormula -> Ordering
$cp1Ord :: Eq THFUnitaryFormula
Ord, Typeable, Typeable THFUnitaryFormula
Constr
DataType
Typeable THFUnitaryFormula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> THFUnitaryFormula
 -> c THFUnitaryFormula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THFUnitaryFormula)
-> (THFUnitaryFormula -> Constr)
-> (THFUnitaryFormula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THFUnitaryFormula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THFUnitaryFormula))
-> ((forall b. Data b => b -> b)
    -> THFUnitaryFormula -> THFUnitaryFormula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THFUnitaryFormula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THFUnitaryFormula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THFUnitaryFormula -> m THFUnitaryFormula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFUnitaryFormula -> m THFUnitaryFormula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFUnitaryFormula -> m THFUnitaryFormula)
-> Data THFUnitaryFormula
THFUnitaryFormula -> Constr
THFUnitaryFormula -> DataType
(forall b. Data b => b -> b)
-> THFUnitaryFormula -> THFUnitaryFormula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryFormula -> c THFUnitaryFormula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryFormula
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) -> THFUnitaryFormula -> u
forall u. (forall d. Data d => d -> u) -> THFUnitaryFormula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryFormula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryFormula -> c THFUnitaryFormula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFUnitaryFormula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFUnitaryFormula)
$cT0UF_THF_Abstraction :: Constr
$cTUF_THF_Logic_Formula_Par :: Constr
$cTUF_THF_Conditional :: Constr
$cTUF_THF_Tuple :: Constr
$cTUF_THF_Atom :: Constr
$cTUF_THF_Unary_Formula :: Constr
$cTUF_THF_Quantified_Formula :: Constr
$tTHFUnitaryFormula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
gmapMp :: (forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
gmapM :: (forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFUnitaryFormula -> m THFUnitaryFormula
gmapQi :: Int -> (forall d. Data d => d -> u) -> THFUnitaryFormula -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THFUnitaryFormula -> u
gmapQ :: (forall d. Data d => d -> u) -> THFUnitaryFormula -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THFUnitaryFormula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryFormula -> r
gmapT :: (forall b. Data b => b -> b)
-> THFUnitaryFormula -> THFUnitaryFormula
$cgmapT :: (forall b. Data b => b -> b)
-> THFUnitaryFormula -> THFUnitaryFormula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFUnitaryFormula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFUnitaryFormula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THFUnitaryFormula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFUnitaryFormula)
dataTypeOf :: THFUnitaryFormula -> DataType
$cdataTypeOf :: THFUnitaryFormula -> DataType
toConstr :: THFUnitaryFormula -> Constr
$ctoConstr :: THFUnitaryFormula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryFormula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryFormula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryFormula -> c THFUnitaryFormula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryFormula -> c THFUnitaryFormula
$cp1Data :: Typeable THFUnitaryFormula
Data)

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

type THFVariableList = [THFVariable]

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

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

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

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

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

data THFTopLevelType =
    TTLT_THF_Logic_Formula THFLogicFormula
  | T0TLT_Constant Constant
  | T0TLT_Variable Token
  | T0TLT_Defined_Type DefinedType
  | T0TLT_System_Type Token
  | T0TLT_THF_Binary_Type THFBinaryType
    deriving (Int -> THFTopLevelType -> ShowS
[THFTopLevelType] -> ShowS
THFTopLevelType -> String
(Int -> THFTopLevelType -> ShowS)
-> (THFTopLevelType -> String)
-> ([THFTopLevelType] -> ShowS)
-> Show THFTopLevelType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THFTopLevelType] -> ShowS
$cshowList :: [THFTopLevelType] -> ShowS
show :: THFTopLevelType -> String
$cshow :: THFTopLevelType -> String
showsPrec :: Int -> THFTopLevelType -> ShowS
$cshowsPrec :: Int -> THFTopLevelType -> ShowS
Show, THFTopLevelType -> THFTopLevelType -> Bool
(THFTopLevelType -> THFTopLevelType -> Bool)
-> (THFTopLevelType -> THFTopLevelType -> Bool)
-> Eq THFTopLevelType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THFTopLevelType -> THFTopLevelType -> Bool
$c/= :: THFTopLevelType -> THFTopLevelType -> Bool
== :: THFTopLevelType -> THFTopLevelType -> Bool
$c== :: THFTopLevelType -> THFTopLevelType -> Bool
Eq, Eq THFTopLevelType
Eq THFTopLevelType =>
(THFTopLevelType -> THFTopLevelType -> Ordering)
-> (THFTopLevelType -> THFTopLevelType -> Bool)
-> (THFTopLevelType -> THFTopLevelType -> Bool)
-> (THFTopLevelType -> THFTopLevelType -> Bool)
-> (THFTopLevelType -> THFTopLevelType -> Bool)
-> (THFTopLevelType -> THFTopLevelType -> THFTopLevelType)
-> (THFTopLevelType -> THFTopLevelType -> THFTopLevelType)
-> Ord THFTopLevelType
THFTopLevelType -> THFTopLevelType -> Bool
THFTopLevelType -> THFTopLevelType -> Ordering
THFTopLevelType -> THFTopLevelType -> THFTopLevelType
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 :: THFTopLevelType -> THFTopLevelType -> THFTopLevelType
$cmin :: THFTopLevelType -> THFTopLevelType -> THFTopLevelType
max :: THFTopLevelType -> THFTopLevelType -> THFTopLevelType
$cmax :: THFTopLevelType -> THFTopLevelType -> THFTopLevelType
>= :: THFTopLevelType -> THFTopLevelType -> Bool
$c>= :: THFTopLevelType -> THFTopLevelType -> Bool
> :: THFTopLevelType -> THFTopLevelType -> Bool
$c> :: THFTopLevelType -> THFTopLevelType -> Bool
<= :: THFTopLevelType -> THFTopLevelType -> Bool
$c<= :: THFTopLevelType -> THFTopLevelType -> Bool
< :: THFTopLevelType -> THFTopLevelType -> Bool
$c< :: THFTopLevelType -> THFTopLevelType -> Bool
compare :: THFTopLevelType -> THFTopLevelType -> Ordering
$ccompare :: THFTopLevelType -> THFTopLevelType -> Ordering
$cp1Ord :: Eq THFTopLevelType
Ord, Typeable, Typeable THFTopLevelType
Constr
DataType
Typeable THFTopLevelType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THFTopLevelType -> c THFTopLevelType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THFTopLevelType)
-> (THFTopLevelType -> Constr)
-> (THFTopLevelType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THFTopLevelType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THFTopLevelType))
-> ((forall b. Data b => b -> b)
    -> THFTopLevelType -> THFTopLevelType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THFTopLevelType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THFTopLevelType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THFTopLevelType -> m THFTopLevelType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFTopLevelType -> m THFTopLevelType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFTopLevelType -> m THFTopLevelType)
-> Data THFTopLevelType
THFTopLevelType -> Constr
THFTopLevelType -> DataType
(forall b. Data b => b -> b) -> THFTopLevelType -> THFTopLevelType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFTopLevelType -> c THFTopLevelType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFTopLevelType
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) -> THFTopLevelType -> u
forall u. (forall d. Data d => d -> u) -> THFTopLevelType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFTopLevelType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFTopLevelType -> c THFTopLevelType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFTopLevelType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFTopLevelType)
$cT0TLT_THF_Binary_Type :: Constr
$cT0TLT_System_Type :: Constr
$cT0TLT_Defined_Type :: Constr
$cT0TLT_Variable :: Constr
$cT0TLT_Constant :: Constr
$cTTLT_THF_Logic_Formula :: Constr
$tTHFTopLevelType :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
gmapMp :: (forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
gmapM :: (forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFTopLevelType -> m THFTopLevelType
gmapQi :: Int -> (forall d. Data d => d -> u) -> THFTopLevelType -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THFTopLevelType -> u
gmapQ :: (forall d. Data d => d -> u) -> THFTopLevelType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THFTopLevelType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFTopLevelType -> r
gmapT :: (forall b. Data b => b -> b) -> THFTopLevelType -> THFTopLevelType
$cgmapT :: (forall b. Data b => b -> b) -> THFTopLevelType -> THFTopLevelType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFTopLevelType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFTopLevelType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THFTopLevelType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFTopLevelType)
dataTypeOf :: THFTopLevelType -> DataType
$cdataTypeOf :: THFTopLevelType -> DataType
toConstr :: THFTopLevelType -> Constr
$ctoConstr :: THFTopLevelType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFTopLevelType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFTopLevelType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFTopLevelType -> c THFTopLevelType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFTopLevelType -> c THFTopLevelType
$cp1Data :: Typeable THFTopLevelType
Data)

data THFUnitaryType =
    TUT_THF_Unitary_Formula THFUnitaryFormula
  | T0UT_Constant Constant
  | T0UT_Variable Token
  | T0UT_Defined_Type DefinedType
  | T0UT_System_Type Token
  | T0UT_THF_Binary_Type_Par THFBinaryType
    deriving (Int -> THFUnitaryType -> ShowS
[THFUnitaryType] -> ShowS
THFUnitaryType -> String
(Int -> THFUnitaryType -> ShowS)
-> (THFUnitaryType -> String)
-> ([THFUnitaryType] -> ShowS)
-> Show THFUnitaryType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THFUnitaryType] -> ShowS
$cshowList :: [THFUnitaryType] -> ShowS
show :: THFUnitaryType -> String
$cshow :: THFUnitaryType -> String
showsPrec :: Int -> THFUnitaryType -> ShowS
$cshowsPrec :: Int -> THFUnitaryType -> ShowS
Show, THFUnitaryType -> THFUnitaryType -> Bool
(THFUnitaryType -> THFUnitaryType -> Bool)
-> (THFUnitaryType -> THFUnitaryType -> Bool) -> Eq THFUnitaryType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THFUnitaryType -> THFUnitaryType -> Bool
$c/= :: THFUnitaryType -> THFUnitaryType -> Bool
== :: THFUnitaryType -> THFUnitaryType -> Bool
$c== :: THFUnitaryType -> THFUnitaryType -> Bool
Eq, Eq THFUnitaryType
Eq THFUnitaryType =>
(THFUnitaryType -> THFUnitaryType -> Ordering)
-> (THFUnitaryType -> THFUnitaryType -> Bool)
-> (THFUnitaryType -> THFUnitaryType -> Bool)
-> (THFUnitaryType -> THFUnitaryType -> Bool)
-> (THFUnitaryType -> THFUnitaryType -> Bool)
-> (THFUnitaryType -> THFUnitaryType -> THFUnitaryType)
-> (THFUnitaryType -> THFUnitaryType -> THFUnitaryType)
-> Ord THFUnitaryType
THFUnitaryType -> THFUnitaryType -> Bool
THFUnitaryType -> THFUnitaryType -> Ordering
THFUnitaryType -> THFUnitaryType -> THFUnitaryType
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 :: THFUnitaryType -> THFUnitaryType -> THFUnitaryType
$cmin :: THFUnitaryType -> THFUnitaryType -> THFUnitaryType
max :: THFUnitaryType -> THFUnitaryType -> THFUnitaryType
$cmax :: THFUnitaryType -> THFUnitaryType -> THFUnitaryType
>= :: THFUnitaryType -> THFUnitaryType -> Bool
$c>= :: THFUnitaryType -> THFUnitaryType -> Bool
> :: THFUnitaryType -> THFUnitaryType -> Bool
$c> :: THFUnitaryType -> THFUnitaryType -> Bool
<= :: THFUnitaryType -> THFUnitaryType -> Bool
$c<= :: THFUnitaryType -> THFUnitaryType -> Bool
< :: THFUnitaryType -> THFUnitaryType -> Bool
$c< :: THFUnitaryType -> THFUnitaryType -> Bool
compare :: THFUnitaryType -> THFUnitaryType -> Ordering
$ccompare :: THFUnitaryType -> THFUnitaryType -> Ordering
$cp1Ord :: Eq THFUnitaryType
Ord, Typeable, Typeable THFUnitaryType
Constr
DataType
Typeable THFUnitaryType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THFUnitaryType -> c THFUnitaryType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THFUnitaryType)
-> (THFUnitaryType -> Constr)
-> (THFUnitaryType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THFUnitaryType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THFUnitaryType))
-> ((forall b. Data b => b -> b)
    -> THFUnitaryType -> THFUnitaryType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THFUnitaryType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THFUnitaryType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THFUnitaryType -> m THFUnitaryType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFUnitaryType -> m THFUnitaryType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFUnitaryType -> m THFUnitaryType)
-> Data THFUnitaryType
THFUnitaryType -> Constr
THFUnitaryType -> DataType
(forall b. Data b => b -> b) -> THFUnitaryType -> THFUnitaryType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryType -> c THFUnitaryType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryType
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) -> THFUnitaryType -> u
forall u. (forall d. Data d => d -> u) -> THFUnitaryType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryType -> c THFUnitaryType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFUnitaryType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFUnitaryType)
$cT0UT_THF_Binary_Type_Par :: Constr
$cT0UT_System_Type :: Constr
$cT0UT_Defined_Type :: Constr
$cT0UT_Variable :: Constr
$cT0UT_Constant :: Constr
$cTUT_THF_Unitary_Formula :: Constr
$tTHFUnitaryType :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
gmapMp :: (forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
gmapM :: (forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFUnitaryType -> m THFUnitaryType
gmapQi :: Int -> (forall d. Data d => d -> u) -> THFUnitaryType -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THFUnitaryType -> u
gmapQ :: (forall d. Data d => d -> u) -> THFUnitaryType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THFUnitaryType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFUnitaryType -> r
gmapT :: (forall b. Data b => b -> b) -> THFUnitaryType -> THFUnitaryType
$cgmapT :: (forall b. Data b => b -> b) -> THFUnitaryType -> THFUnitaryType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFUnitaryType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFUnitaryType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THFUnitaryType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFUnitaryType)
dataTypeOf :: THFUnitaryType -> DataType
$cdataTypeOf :: THFUnitaryType -> DataType
toConstr :: THFUnitaryType -> Constr
$ctoConstr :: THFUnitaryType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFUnitaryType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryType -> c THFUnitaryType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFUnitaryType -> c THFUnitaryType
$cp1Data :: Typeable THFUnitaryType
Data)

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

data THFAtom =
    TA_Term Term
  | TA_THF_Conn_Term THFConnTerm
  | TA_Defined_Type DefinedType
  | TA_Defined_Plain_Formula DefinedPlainFormula
  | TA_System_Type Token
  | TA_System_Atomic_Formula SystemTerm
  | T0A_Constant Constant
  | T0A_Defined_Constant Token
  | T0A_System_Constant Token
  | T0A_Variable Token
    deriving (Int -> THFAtom -> ShowS
[THFAtom] -> ShowS
THFAtom -> String
(Int -> THFAtom -> ShowS)
-> (THFAtom -> String) -> ([THFAtom] -> ShowS) -> Show THFAtom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THFAtom] -> ShowS
$cshowList :: [THFAtom] -> ShowS
show :: THFAtom -> String
$cshow :: THFAtom -> String
showsPrec :: Int -> THFAtom -> ShowS
$cshowsPrec :: Int -> THFAtom -> ShowS
Show, THFAtom -> THFAtom -> Bool
(THFAtom -> THFAtom -> Bool)
-> (THFAtom -> THFAtom -> Bool) -> Eq THFAtom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THFAtom -> THFAtom -> Bool
$c/= :: THFAtom -> THFAtom -> Bool
== :: THFAtom -> THFAtom -> Bool
$c== :: THFAtom -> THFAtom -> Bool
Eq, Eq THFAtom
Eq THFAtom =>
(THFAtom -> THFAtom -> Ordering)
-> (THFAtom -> THFAtom -> Bool)
-> (THFAtom -> THFAtom -> Bool)
-> (THFAtom -> THFAtom -> Bool)
-> (THFAtom -> THFAtom -> Bool)
-> (THFAtom -> THFAtom -> THFAtom)
-> (THFAtom -> THFAtom -> THFAtom)
-> Ord THFAtom
THFAtom -> THFAtom -> Bool
THFAtom -> THFAtom -> Ordering
THFAtom -> THFAtom -> THFAtom
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 :: THFAtom -> THFAtom -> THFAtom
$cmin :: THFAtom -> THFAtom -> THFAtom
max :: THFAtom -> THFAtom -> THFAtom
$cmax :: THFAtom -> THFAtom -> THFAtom
>= :: THFAtom -> THFAtom -> Bool
$c>= :: THFAtom -> THFAtom -> Bool
> :: THFAtom -> THFAtom -> Bool
$c> :: THFAtom -> THFAtom -> Bool
<= :: THFAtom -> THFAtom -> Bool
$c<= :: THFAtom -> THFAtom -> Bool
< :: THFAtom -> THFAtom -> Bool
$c< :: THFAtom -> THFAtom -> Bool
compare :: THFAtom -> THFAtom -> Ordering
$ccompare :: THFAtom -> THFAtom -> Ordering
$cp1Ord :: Eq THFAtom
Ord, Typeable, Typeable THFAtom
Constr
DataType
Typeable THFAtom =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THFAtom -> c THFAtom)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THFAtom)
-> (THFAtom -> Constr)
-> (THFAtom -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THFAtom))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THFAtom))
-> ((forall b. Data b => b -> b) -> THFAtom -> THFAtom)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THFAtom -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THFAtom -> r)
-> (forall u. (forall d. Data d => d -> u) -> THFAtom -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> THFAtom -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> THFAtom -> m THFAtom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THFAtom -> m THFAtom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THFAtom -> m THFAtom)
-> Data THFAtom
THFAtom -> Constr
THFAtom -> DataType
(forall b. Data b => b -> b) -> THFAtom -> THFAtom
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFAtom -> c THFAtom
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFAtom
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) -> THFAtom -> u
forall u. (forall d. Data d => d -> u) -> THFAtom -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFAtom -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFAtom -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFAtom
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFAtom -> c THFAtom
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFAtom)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THFAtom)
$cT0A_Variable :: Constr
$cT0A_System_Constant :: Constr
$cT0A_Defined_Constant :: Constr
$cT0A_Constant :: Constr
$cTA_System_Atomic_Formula :: Constr
$cTA_System_Type :: Constr
$cTA_Defined_Plain_Formula :: Constr
$cTA_Defined_Type :: Constr
$cTA_THF_Conn_Term :: Constr
$cTA_Term :: Constr
$tTHFAtom :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
gmapMp :: (forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
gmapM :: (forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THFAtom -> m THFAtom
gmapQi :: Int -> (forall d. Data d => d -> u) -> THFAtom -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> THFAtom -> u
gmapQ :: (forall d. Data d => d -> u) -> THFAtom -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THFAtom -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFAtom -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFAtom -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFAtom -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFAtom -> r
gmapT :: (forall b. Data b => b -> b) -> THFAtom -> THFAtom
$cgmapT :: (forall b. Data b => b -> b) -> THFAtom -> THFAtom
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THFAtom)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THFAtom)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THFAtom)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFAtom)
dataTypeOf :: THFAtom -> DataType
$cdataTypeOf :: THFAtom -> DataType
toConstr :: THFAtom -> Constr
$ctoConstr :: THFAtom -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFAtom
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFAtom
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFAtom -> c THFAtom
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFAtom -> c THFAtom
$cp1Data :: Typeable THFAtom
Data)

type THFTuple = [THFLogicFormula]

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

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

data THFQuantifier =
    TQ_ForAll                   -- !
  | TQ_Exists                   -- ?
  | TQ_Lambda_Binder            -- ^
  | TQ_Dependent_Product        -- !>
  | TQ_Dependent_Sum            -- ?*
  | TQ_Indefinite_Description   -- @+
  | TQ_Definite_Description     -- @-
  | T0Q_PiForAll                -- !!
  | T0Q_SigmaExists             -- ??
    deriving (Int -> THFQuantifier -> ShowS
[THFQuantifier] -> ShowS
THFQuantifier -> String
(Int -> THFQuantifier -> ShowS)
-> (THFQuantifier -> String)
-> ([THFQuantifier] -> ShowS)
-> Show THFQuantifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THFQuantifier] -> ShowS
$cshowList :: [THFQuantifier] -> ShowS
show :: THFQuantifier -> String
$cshow :: THFQuantifier -> String
showsPrec :: Int -> THFQuantifier -> ShowS
$cshowsPrec :: Int -> THFQuantifier -> ShowS
Show, THFQuantifier -> THFQuantifier -> Bool
(THFQuantifier -> THFQuantifier -> Bool)
-> (THFQuantifier -> THFQuantifier -> Bool) -> Eq THFQuantifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THFQuantifier -> THFQuantifier -> Bool
$c/= :: THFQuantifier -> THFQuantifier -> Bool
== :: THFQuantifier -> THFQuantifier -> Bool
$c== :: THFQuantifier -> THFQuantifier -> Bool
Eq, Eq THFQuantifier
Eq THFQuantifier =>
(THFQuantifier -> THFQuantifier -> Ordering)
-> (THFQuantifier -> THFQuantifier -> Bool)
-> (THFQuantifier -> THFQuantifier -> Bool)
-> (THFQuantifier -> THFQuantifier -> Bool)
-> (THFQuantifier -> THFQuantifier -> Bool)
-> (THFQuantifier -> THFQuantifier -> THFQuantifier)
-> (THFQuantifier -> THFQuantifier -> THFQuantifier)
-> Ord THFQuantifier
THFQuantifier -> THFQuantifier -> Bool
THFQuantifier -> THFQuantifier -> Ordering
THFQuantifier -> THFQuantifier -> THFQuantifier
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 :: THFQuantifier -> THFQuantifier -> THFQuantifier
$cmin :: THFQuantifier -> THFQuantifier -> THFQuantifier
max :: THFQuantifier -> THFQuantifier -> THFQuantifier
$cmax :: THFQuantifier -> THFQuantifier -> THFQuantifier
>= :: THFQuantifier -> THFQuantifier -> Bool
$c>= :: THFQuantifier -> THFQuantifier -> Bool
> :: THFQuantifier -> THFQuantifier -> Bool
$c> :: THFQuantifier -> THFQuantifier -> Bool
<= :: THFQuantifier -> THFQuantifier -> Bool
$c<= :: THFQuantifier -> THFQuantifier -> Bool
< :: THFQuantifier -> THFQuantifier -> Bool
$c< :: THFQuantifier -> THFQuantifier -> Bool
compare :: THFQuantifier -> THFQuantifier -> Ordering
$ccompare :: THFQuantifier -> THFQuantifier -> Ordering
$cp1Ord :: Eq THFQuantifier
Ord, Typeable, Typeable THFQuantifier
Constr
DataType
Typeable THFQuantifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THFQuantifier -> c THFQuantifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THFQuantifier)
-> (THFQuantifier -> Constr)
-> (THFQuantifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THFQuantifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THFQuantifier))
-> ((forall b. Data b => b -> b) -> THFQuantifier -> THFQuantifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r)
-> (forall u. (forall d. Data d => d -> u) -> THFQuantifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THFQuantifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier)
-> Data THFQuantifier
THFQuantifier -> Constr
THFQuantifier -> DataType
(forall b. Data b => b -> b) -> THFQuantifier -> THFQuantifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFQuantifier -> c THFQuantifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFQuantifier
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) -> THFQuantifier -> u
forall u. (forall d. Data d => d -> u) -> THFQuantifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFQuantifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFQuantifier -> c THFQuantifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFQuantifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFQuantifier)
$cT0Q_SigmaExists :: Constr
$cT0Q_PiForAll :: Constr
$cTQ_Definite_Description :: Constr
$cTQ_Indefinite_Description :: Constr
$cTQ_Dependent_Sum :: Constr
$cTQ_Dependent_Product :: Constr
$cTQ_Lambda_Binder :: Constr
$cTQ_Exists :: Constr
$cTQ_ForAll :: Constr
$tTHFQuantifier :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
gmapMp :: (forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
gmapM :: (forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THFQuantifier -> m THFQuantifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> THFQuantifier -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> THFQuantifier -> u
gmapQ :: (forall d. Data d => d -> u) -> THFQuantifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THFQuantifier -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFQuantifier -> r
gmapT :: (forall b. Data b => b -> b) -> THFQuantifier -> THFQuantifier
$cgmapT :: (forall b. Data b => b -> b) -> THFQuantifier -> THFQuantifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFQuantifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFQuantifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THFQuantifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFQuantifier)
dataTypeOf :: THFQuantifier -> DataType
$cdataTypeOf :: THFQuantifier -> DataType
toConstr :: THFQuantifier -> Constr
$ctoConstr :: THFQuantifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFQuantifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFQuantifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFQuantifier -> c THFQuantifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFQuantifier -> c THFQuantifier
$cp1Data :: Typeable THFQuantifier
Data)

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

data THFPairConnective =
    Infix_Equality          -- =
  | Infix_Inequality        -- !=
  | Equivalent              -- <=>
  | Implication             -- =>
  | IF                      -- <=
  | XOR                     -- <~>
  | NOR                     -- ~|
  | NAND                    -- ~&
    deriving (Int -> THFPairConnective -> ShowS
[THFPairConnective] -> ShowS
THFPairConnective -> String
(Int -> THFPairConnective -> ShowS)
-> (THFPairConnective -> String)
-> ([THFPairConnective] -> ShowS)
-> Show THFPairConnective
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THFPairConnective] -> ShowS
$cshowList :: [THFPairConnective] -> ShowS
show :: THFPairConnective -> String
$cshow :: THFPairConnective -> String
showsPrec :: Int -> THFPairConnective -> ShowS
$cshowsPrec :: Int -> THFPairConnective -> ShowS
Show, THFPairConnective -> THFPairConnective -> Bool
(THFPairConnective -> THFPairConnective -> Bool)
-> (THFPairConnective -> THFPairConnective -> Bool)
-> Eq THFPairConnective
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THFPairConnective -> THFPairConnective -> Bool
$c/= :: THFPairConnective -> THFPairConnective -> Bool
== :: THFPairConnective -> THFPairConnective -> Bool
$c== :: THFPairConnective -> THFPairConnective -> Bool
Eq, Eq THFPairConnective
Eq THFPairConnective =>
(THFPairConnective -> THFPairConnective -> Ordering)
-> (THFPairConnective -> THFPairConnective -> Bool)
-> (THFPairConnective -> THFPairConnective -> Bool)
-> (THFPairConnective -> THFPairConnective -> Bool)
-> (THFPairConnective -> THFPairConnective -> Bool)
-> (THFPairConnective -> THFPairConnective -> THFPairConnective)
-> (THFPairConnective -> THFPairConnective -> THFPairConnective)
-> Ord THFPairConnective
THFPairConnective -> THFPairConnective -> Bool
THFPairConnective -> THFPairConnective -> Ordering
THFPairConnective -> THFPairConnective -> THFPairConnective
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 :: THFPairConnective -> THFPairConnective -> THFPairConnective
$cmin :: THFPairConnective -> THFPairConnective -> THFPairConnective
max :: THFPairConnective -> THFPairConnective -> THFPairConnective
$cmax :: THFPairConnective -> THFPairConnective -> THFPairConnective
>= :: THFPairConnective -> THFPairConnective -> Bool
$c>= :: THFPairConnective -> THFPairConnective -> Bool
> :: THFPairConnective -> THFPairConnective -> Bool
$c> :: THFPairConnective -> THFPairConnective -> Bool
<= :: THFPairConnective -> THFPairConnective -> Bool
$c<= :: THFPairConnective -> THFPairConnective -> Bool
< :: THFPairConnective -> THFPairConnective -> Bool
$c< :: THFPairConnective -> THFPairConnective -> Bool
compare :: THFPairConnective -> THFPairConnective -> Ordering
$ccompare :: THFPairConnective -> THFPairConnective -> Ordering
$cp1Ord :: Eq THFPairConnective
Ord, Typeable, Typeable THFPairConnective
Constr
DataType
Typeable THFPairConnective =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> THFPairConnective
 -> c THFPairConnective)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THFPairConnective)
-> (THFPairConnective -> Constr)
-> (THFPairConnective -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THFPairConnective))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THFPairConnective))
-> ((forall b. Data b => b -> b)
    -> THFPairConnective -> THFPairConnective)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THFPairConnective -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THFPairConnective -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THFPairConnective -> m THFPairConnective)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFPairConnective -> m THFPairConnective)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THFPairConnective -> m THFPairConnective)
-> Data THFPairConnective
THFPairConnective -> Constr
THFPairConnective -> DataType
(forall b. Data b => b -> b)
-> THFPairConnective -> THFPairConnective
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFPairConnective -> c THFPairConnective
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFPairConnective
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) -> THFPairConnective -> u
forall u. (forall d. Data d => d -> u) -> THFPairConnective -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFPairConnective
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFPairConnective -> c THFPairConnective
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFPairConnective)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFPairConnective)
$cNAND :: Constr
$cNOR :: Constr
$cXOR :: Constr
$cIF :: Constr
$cImplication :: Constr
$cEquivalent :: Constr
$cInfix_Inequality :: Constr
$cInfix_Equality :: Constr
$tTHFPairConnective :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
gmapMp :: (forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
gmapM :: (forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THFPairConnective -> m THFPairConnective
gmapQi :: Int -> (forall d. Data d => d -> u) -> THFPairConnective -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THFPairConnective -> u
gmapQ :: (forall d. Data d => d -> u) -> THFPairConnective -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THFPairConnective -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THFPairConnective -> r
gmapT :: (forall b. Data b => b -> b)
-> THFPairConnective -> THFPairConnective
$cgmapT :: (forall b. Data b => b -> b)
-> THFPairConnective -> THFPairConnective
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFPairConnective)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THFPairConnective)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THFPairConnective)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THFPairConnective)
dataTypeOf :: THFPairConnective -> DataType
$cdataTypeOf :: THFPairConnective -> DataType
toConstr :: THFPairConnective -> Constr
$ctoConstr :: THFPairConnective -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFPairConnective
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THFPairConnective
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFPairConnective -> c THFPairConnective
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THFPairConnective -> c THFPairConnective
$cp1Data :: Typeable THFPairConnective
Data)

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

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

data DefinedType =
    DT_oType | DT_o | DT_iType | DT_i
  | DT_tType | DT_real | DT_rat | DT_int
    deriving (Int -> DefinedType -> ShowS
[DefinedType] -> ShowS
DefinedType -> String
(Int -> DefinedType -> ShowS)
-> (DefinedType -> String)
-> ([DefinedType] -> ShowS)
-> Show DefinedType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DefinedType] -> ShowS
$cshowList :: [DefinedType] -> ShowS
show :: DefinedType -> String
$cshow :: DefinedType -> String
showsPrec :: Int -> DefinedType -> ShowS
$cshowsPrec :: Int -> DefinedType -> ShowS
Show, DefinedType -> DefinedType -> Bool
(DefinedType -> DefinedType -> Bool)
-> (DefinedType -> DefinedType -> Bool) -> Eq DefinedType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DefinedType -> DefinedType -> Bool
$c/= :: DefinedType -> DefinedType -> Bool
== :: DefinedType -> DefinedType -> Bool
$c== :: DefinedType -> DefinedType -> Bool
Eq, Eq DefinedType
Eq DefinedType =>
(DefinedType -> DefinedType -> Ordering)
-> (DefinedType -> DefinedType -> Bool)
-> (DefinedType -> DefinedType -> Bool)
-> (DefinedType -> DefinedType -> Bool)
-> (DefinedType -> DefinedType -> Bool)
-> (DefinedType -> DefinedType -> DefinedType)
-> (DefinedType -> DefinedType -> DefinedType)
-> Ord DefinedType
DefinedType -> DefinedType -> Bool
DefinedType -> DefinedType -> Ordering
DefinedType -> DefinedType -> DefinedType
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 :: DefinedType -> DefinedType -> DefinedType
$cmin :: DefinedType -> DefinedType -> DefinedType
max :: DefinedType -> DefinedType -> DefinedType
$cmax :: DefinedType -> DefinedType -> DefinedType
>= :: DefinedType -> DefinedType -> Bool
$c>= :: DefinedType -> DefinedType -> Bool
> :: DefinedType -> DefinedType -> Bool
$c> :: DefinedType -> DefinedType -> Bool
<= :: DefinedType -> DefinedType -> Bool
$c<= :: DefinedType -> DefinedType -> Bool
< :: DefinedType -> DefinedType -> Bool
$c< :: DefinedType -> DefinedType -> Bool
compare :: DefinedType -> DefinedType -> Ordering
$ccompare :: DefinedType -> DefinedType -> Ordering
$cp1Ord :: Eq DefinedType
Ord, Typeable, Typeable DefinedType
Constr
DataType
Typeable DefinedType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DefinedType -> c DefinedType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DefinedType)
-> (DefinedType -> Constr)
-> (DefinedType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DefinedType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DefinedType))
-> ((forall b. Data b => b -> b) -> DefinedType -> DefinedType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefinedType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefinedType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DefinedType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DefinedType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DefinedType -> m DefinedType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefinedType -> m DefinedType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DefinedType -> m DefinedType)
-> Data DefinedType
DefinedType -> Constr
DefinedType -> DataType
(forall b. Data b => b -> b) -> DefinedType -> DefinedType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedType -> c DefinedType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedType
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) -> DefinedType -> u
forall u. (forall d. Data d => d -> u) -> DefinedType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedType -> c DefinedType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefinedType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefinedType)
$cDT_int :: Constr
$cDT_rat :: Constr
$cDT_real :: Constr
$cDT_tType :: Constr
$cDT_i :: Constr
$cDT_iType :: Constr
$cDT_o :: Constr
$cDT_oType :: Constr
$tDefinedType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
gmapMp :: (forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
gmapM :: (forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefinedType -> m DefinedType
gmapQi :: Int -> (forall d. Data d => d -> u) -> DefinedType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefinedType -> u
gmapQ :: (forall d. Data d => d -> u) -> DefinedType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DefinedType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedType -> r
gmapT :: (forall b. Data b => b -> b) -> DefinedType -> DefinedType
$cgmapT :: (forall b. Data b => b -> b) -> DefinedType -> DefinedType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefinedType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefinedType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DefinedType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefinedType)
dataTypeOf :: DefinedType -> DataType
$cdataTypeOf :: DefinedType -> DataType
toConstr :: DefinedType -> Constr
$ctoConstr :: DefinedType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedType -> c DefinedType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedType -> c DefinedType
$cp1Data :: Typeable DefinedType
Data)

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

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

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

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

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

type Constant = AtomicWord

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

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

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

data DefinedFunctor =
    UMinus | Sum | Difference | Product |
    Quotient | Quotient_e | Quotient_t | Quotient_f |
    Remainder_e | Remainder_t | Remainder_f |
    Floor | Ceiling | Truncate | Round |
    To_int | To_rat | To_real
    deriving (Int -> DefinedFunctor -> ShowS
[DefinedFunctor] -> ShowS
DefinedFunctor -> String
(Int -> DefinedFunctor -> ShowS)
-> (DefinedFunctor -> String)
-> ([DefinedFunctor] -> ShowS)
-> Show DefinedFunctor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DefinedFunctor] -> ShowS
$cshowList :: [DefinedFunctor] -> ShowS
show :: DefinedFunctor -> String
$cshow :: DefinedFunctor -> String
showsPrec :: Int -> DefinedFunctor -> ShowS
$cshowsPrec :: Int -> DefinedFunctor -> ShowS
Show, DefinedFunctor -> DefinedFunctor -> Bool
(DefinedFunctor -> DefinedFunctor -> Bool)
-> (DefinedFunctor -> DefinedFunctor -> Bool) -> Eq DefinedFunctor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DefinedFunctor -> DefinedFunctor -> Bool
$c/= :: DefinedFunctor -> DefinedFunctor -> Bool
== :: DefinedFunctor -> DefinedFunctor -> Bool
$c== :: DefinedFunctor -> DefinedFunctor -> Bool
Eq, Eq DefinedFunctor
Eq DefinedFunctor =>
(DefinedFunctor -> DefinedFunctor -> Ordering)
-> (DefinedFunctor -> DefinedFunctor -> Bool)
-> (DefinedFunctor -> DefinedFunctor -> Bool)
-> (DefinedFunctor -> DefinedFunctor -> Bool)
-> (DefinedFunctor -> DefinedFunctor -> Bool)
-> (DefinedFunctor -> DefinedFunctor -> DefinedFunctor)
-> (DefinedFunctor -> DefinedFunctor -> DefinedFunctor)
-> Ord DefinedFunctor
DefinedFunctor -> DefinedFunctor -> Bool
DefinedFunctor -> DefinedFunctor -> Ordering
DefinedFunctor -> DefinedFunctor -> DefinedFunctor
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 :: DefinedFunctor -> DefinedFunctor -> DefinedFunctor
$cmin :: DefinedFunctor -> DefinedFunctor -> DefinedFunctor
max :: DefinedFunctor -> DefinedFunctor -> DefinedFunctor
$cmax :: DefinedFunctor -> DefinedFunctor -> DefinedFunctor
>= :: DefinedFunctor -> DefinedFunctor -> Bool
$c>= :: DefinedFunctor -> DefinedFunctor -> Bool
> :: DefinedFunctor -> DefinedFunctor -> Bool
$c> :: DefinedFunctor -> DefinedFunctor -> Bool
<= :: DefinedFunctor -> DefinedFunctor -> Bool
$c<= :: DefinedFunctor -> DefinedFunctor -> Bool
< :: DefinedFunctor -> DefinedFunctor -> Bool
$c< :: DefinedFunctor -> DefinedFunctor -> Bool
compare :: DefinedFunctor -> DefinedFunctor -> Ordering
$ccompare :: DefinedFunctor -> DefinedFunctor -> Ordering
$cp1Ord :: Eq DefinedFunctor
Ord, Typeable, Typeable DefinedFunctor
Constr
DataType
Typeable DefinedFunctor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DefinedFunctor -> c DefinedFunctor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DefinedFunctor)
-> (DefinedFunctor -> Constr)
-> (DefinedFunctor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DefinedFunctor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DefinedFunctor))
-> ((forall b. Data b => b -> b)
    -> DefinedFunctor -> DefinedFunctor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DefinedFunctor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DefinedFunctor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DefinedFunctor -> m DefinedFunctor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DefinedFunctor -> m DefinedFunctor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DefinedFunctor -> m DefinedFunctor)
-> Data DefinedFunctor
DefinedFunctor -> Constr
DefinedFunctor -> DataType
(forall b. Data b => b -> b) -> DefinedFunctor -> DefinedFunctor
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedFunctor -> c DefinedFunctor
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedFunctor
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) -> DefinedFunctor -> u
forall u. (forall d. Data d => d -> u) -> DefinedFunctor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedFunctor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedFunctor -> c DefinedFunctor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefinedFunctor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefinedFunctor)
$cTo_real :: Constr
$cTo_rat :: Constr
$cTo_int :: Constr
$cRound :: Constr
$cTruncate :: Constr
$cCeiling :: Constr
$cFloor :: Constr
$cRemainder_f :: Constr
$cRemainder_t :: Constr
$cRemainder_e :: Constr
$cQuotient_f :: Constr
$cQuotient_t :: Constr
$cQuotient_e :: Constr
$cQuotient :: Constr
$cProduct :: Constr
$cDifference :: Constr
$cSum :: Constr
$cUMinus :: Constr
$tDefinedFunctor :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
gmapMp :: (forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
gmapM :: (forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DefinedFunctor -> m DefinedFunctor
gmapQi :: Int -> (forall d. Data d => d -> u) -> DefinedFunctor -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DefinedFunctor -> u
gmapQ :: (forall d. Data d => d -> u) -> DefinedFunctor -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DefinedFunctor -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefinedFunctor -> r
gmapT :: (forall b. Data b => b -> b) -> DefinedFunctor -> DefinedFunctor
$cgmapT :: (forall b. Data b => b -> b) -> DefinedFunctor -> DefinedFunctor
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefinedFunctor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DefinedFunctor)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DefinedFunctor)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DefinedFunctor)
dataTypeOf :: DefinedFunctor -> DataType
$cdataTypeOf :: DefinedFunctor -> DataType
toConstr :: DefinedFunctor -> Constr
$ctoConstr :: DefinedFunctor -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedFunctor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DefinedFunctor
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedFunctor -> c DefinedFunctor
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefinedFunctor -> c DefinedFunctor
$cp1Data :: Typeable DefinedFunctor
Data)

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

type Arguments = [Term]

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

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

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

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

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

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

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

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

type OptionalInfo = (Maybe UsefulInfo)

type UsefulInfo = [InfoItem]

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

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

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

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

data StatusValue =
    Suc | Unp | Sap | Esa | Sat | Fsa | Thm | Eqv | Tac
  | Wec | Eth | Tau | Wtc | Wth | Cax | Sca | Tca | Wca
  | Cup | Csp | Ecs | Csa | Cth | Ceq | Unc | Wcc | Ect
  | Fun | Uns | Wuc | Wct | Scc | Uca | Noc
  deriving (Int -> StatusValue -> ShowS
[StatusValue] -> ShowS
StatusValue -> String
(Int -> StatusValue -> ShowS)
-> (StatusValue -> String)
-> ([StatusValue] -> ShowS)
-> Show StatusValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StatusValue] -> ShowS
$cshowList :: [StatusValue] -> ShowS
show :: StatusValue -> String
$cshow :: StatusValue -> String
showsPrec :: Int -> StatusValue -> ShowS
$cshowsPrec :: Int -> StatusValue -> ShowS
Show, StatusValue -> StatusValue -> Bool
(StatusValue -> StatusValue -> Bool)
-> (StatusValue -> StatusValue -> Bool) -> Eq StatusValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StatusValue -> StatusValue -> Bool
$c/= :: StatusValue -> StatusValue -> Bool
== :: StatusValue -> StatusValue -> Bool
$c== :: StatusValue -> StatusValue -> Bool
Eq, Eq StatusValue
Eq StatusValue =>
(StatusValue -> StatusValue -> Ordering)
-> (StatusValue -> StatusValue -> Bool)
-> (StatusValue -> StatusValue -> Bool)
-> (StatusValue -> StatusValue -> Bool)
-> (StatusValue -> StatusValue -> Bool)
-> (StatusValue -> StatusValue -> StatusValue)
-> (StatusValue -> StatusValue -> StatusValue)
-> Ord StatusValue
StatusValue -> StatusValue -> Bool
StatusValue -> StatusValue -> Ordering
StatusValue -> StatusValue -> StatusValue
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 :: StatusValue -> StatusValue -> StatusValue
$cmin :: StatusValue -> StatusValue -> StatusValue
max :: StatusValue -> StatusValue -> StatusValue
$cmax :: StatusValue -> StatusValue -> StatusValue
>= :: StatusValue -> StatusValue -> Bool
$c>= :: StatusValue -> StatusValue -> Bool
> :: StatusValue -> StatusValue -> Bool
$c> :: StatusValue -> StatusValue -> Bool
<= :: StatusValue -> StatusValue -> Bool
$c<= :: StatusValue -> StatusValue -> Bool
< :: StatusValue -> StatusValue -> Bool
$c< :: StatusValue -> StatusValue -> Bool
compare :: StatusValue -> StatusValue -> Ordering
$ccompare :: StatusValue -> StatusValue -> Ordering
$cp1Ord :: Eq StatusValue
Ord, Typeable, Typeable StatusValue
Constr
DataType
Typeable StatusValue =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> StatusValue -> c StatusValue)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StatusValue)
-> (StatusValue -> Constr)
-> (StatusValue -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StatusValue))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StatusValue))
-> ((forall b. Data b => b -> b) -> StatusValue -> StatusValue)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StatusValue -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StatusValue -> r)
-> (forall u. (forall d. Data d => d -> u) -> StatusValue -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StatusValue -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> StatusValue -> m StatusValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StatusValue -> m StatusValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StatusValue -> m StatusValue)
-> Data StatusValue
StatusValue -> Constr
StatusValue -> DataType
(forall b. Data b => b -> b) -> StatusValue -> StatusValue
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StatusValue -> c StatusValue
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StatusValue
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) -> StatusValue -> u
forall u. (forall d. Data d => d -> u) -> StatusValue -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StatusValue -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StatusValue -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StatusValue
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StatusValue -> c StatusValue
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StatusValue)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StatusValue)
$cNoc :: Constr
$cUca :: Constr
$cScc :: Constr
$cWct :: Constr
$cWuc :: Constr
$cUns :: Constr
$cFun :: Constr
$cEct :: Constr
$cWcc :: Constr
$cUnc :: Constr
$cCeq :: Constr
$cCth :: Constr
$cCsa :: Constr
$cEcs :: Constr
$cCsp :: Constr
$cCup :: Constr
$cWca :: Constr
$cTca :: Constr
$cSca :: Constr
$cCax :: Constr
$cWth :: Constr
$cWtc :: Constr
$cTau :: Constr
$cEth :: Constr
$cWec :: Constr
$cTac :: Constr
$cEqv :: Constr
$cThm :: Constr
$cFsa :: Constr
$cSat :: Constr
$cEsa :: Constr
$cSap :: Constr
$cUnp :: Constr
$cSuc :: Constr
$tStatusValue :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
gmapMp :: (forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
gmapM :: (forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StatusValue -> m StatusValue
gmapQi :: Int -> (forall d. Data d => d -> u) -> StatusValue -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StatusValue -> u
gmapQ :: (forall d. Data d => d -> u) -> StatusValue -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StatusValue -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StatusValue -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StatusValue -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StatusValue -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StatusValue -> r
gmapT :: (forall b. Data b => b -> b) -> StatusValue -> StatusValue
$cgmapT :: (forall b. Data b => b -> b) -> StatusValue -> StatusValue
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StatusValue)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StatusValue)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c StatusValue)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StatusValue)
dataTypeOf :: StatusValue -> DataType
$cdataTypeOf :: StatusValue -> DataType
toConstr :: StatusValue -> Constr
$ctoConstr :: StatusValue -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StatusValue
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StatusValue
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StatusValue -> c StatusValue
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StatusValue -> c StatusValue
$cp1Data :: Typeable StatusValue
Data)

type NameList = [Name]

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

data GeneralData =
    GD_Atomic_Word AtomicWord
  | GD_Variable Token
  | GD_Number Number
  | GD_Distinct_Object Token
  | GD_Formula_Data FormulaData
  | GD_Bind Token FormulaData
  | GD_General_Function GeneralFunction
    deriving (Int -> GeneralData -> ShowS
[GeneralData] -> ShowS
GeneralData -> String
(Int -> GeneralData -> ShowS)
-> (GeneralData -> String)
-> ([GeneralData] -> ShowS)
-> Show GeneralData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GeneralData] -> ShowS
$cshowList :: [GeneralData] -> ShowS
show :: GeneralData -> String
$cshow :: GeneralData -> String
showsPrec :: Int -> GeneralData -> ShowS
$cshowsPrec :: Int -> GeneralData -> ShowS
Show, GeneralData -> GeneralData -> Bool
(GeneralData -> GeneralData -> Bool)
-> (GeneralData -> GeneralData -> Bool) -> Eq GeneralData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GeneralData -> GeneralData -> Bool
$c/= :: GeneralData -> GeneralData -> Bool
== :: GeneralData -> GeneralData -> Bool
$c== :: GeneralData -> GeneralData -> Bool
Eq, Eq GeneralData
Eq GeneralData =>
(GeneralData -> GeneralData -> Ordering)
-> (GeneralData -> GeneralData -> Bool)
-> (GeneralData -> GeneralData -> Bool)
-> (GeneralData -> GeneralData -> Bool)
-> (GeneralData -> GeneralData -> Bool)
-> (GeneralData -> GeneralData -> GeneralData)
-> (GeneralData -> GeneralData -> GeneralData)
-> Ord GeneralData
GeneralData -> GeneralData -> Bool
GeneralData -> GeneralData -> Ordering
GeneralData -> GeneralData -> GeneralData
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 :: GeneralData -> GeneralData -> GeneralData
$cmin :: GeneralData -> GeneralData -> GeneralData
max :: GeneralData -> GeneralData -> GeneralData
$cmax :: GeneralData -> GeneralData -> GeneralData
>= :: GeneralData -> GeneralData -> Bool
$c>= :: GeneralData -> GeneralData -> Bool
> :: GeneralData -> GeneralData -> Bool
$c> :: GeneralData -> GeneralData -> Bool
<= :: GeneralData -> GeneralData -> Bool
$c<= :: GeneralData -> GeneralData -> Bool
< :: GeneralData -> GeneralData -> Bool
$c< :: GeneralData -> GeneralData -> Bool
compare :: GeneralData -> GeneralData -> Ordering
$ccompare :: GeneralData -> GeneralData -> Ordering
$cp1Ord :: Eq GeneralData
Ord, Typeable, Typeable GeneralData
Constr
DataType
Typeable GeneralData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GeneralData -> c GeneralData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GeneralData)
-> (GeneralData -> Constr)
-> (GeneralData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GeneralData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GeneralData))
-> ((forall b. Data b => b -> b) -> GeneralData -> GeneralData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GeneralData -> r)
-> (forall u. (forall d. Data d => d -> u) -> GeneralData -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GeneralData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GeneralData -> m GeneralData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GeneralData -> m GeneralData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GeneralData -> m GeneralData)
-> Data GeneralData
GeneralData -> Constr
GeneralData -> DataType
(forall b. Data b => b -> b) -> GeneralData -> GeneralData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GeneralData -> c GeneralData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GeneralData
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) -> GeneralData -> u
forall u. (forall d. Data d => d -> u) -> GeneralData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GeneralData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GeneralData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GeneralData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GeneralData -> c GeneralData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GeneralData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GeneralData)
$cGD_General_Function :: Constr
$cGD_Bind :: Constr
$cGD_Formula_Data :: Constr
$cGD_Distinct_Object :: Constr
$cGD_Number :: Constr
$cGD_Variable :: Constr
$cGD_Atomic_Word :: Constr
$tGeneralData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
gmapMp :: (forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
gmapM :: (forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GeneralData -> m GeneralData
gmapQi :: Int -> (forall d. Data d => d -> u) -> GeneralData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GeneralData -> u
gmapQ :: (forall d. Data d => d -> u) -> GeneralData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GeneralData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GeneralData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GeneralData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GeneralData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GeneralData -> r
gmapT :: (forall b. Data b => b -> b) -> GeneralData -> GeneralData
$cgmapT :: (forall b. Data b => b -> b) -> GeneralData -> GeneralData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GeneralData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GeneralData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c GeneralData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GeneralData)
dataTypeOf :: GeneralData -> DataType
$cdataTypeOf :: GeneralData -> DataType
toConstr :: GeneralData -> Constr
$ctoConstr :: GeneralData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GeneralData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GeneralData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GeneralData -> c GeneralData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GeneralData -> c GeneralData
$cp1Data :: Typeable GeneralData
Data)

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

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

type GeneralList = GeneralTerms

type GeneralTerms = [GeneralTerm]

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

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

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

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

instance GetRange TPTP_THF where
  getRange :: TPTP_THF -> Range
getRange = Range -> TPTP_THF -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TPTP_THF -> [Pos]
rangeSpan x :: TPTP_THF
x = case TPTP_THF
x of
    TPTP_THF_Annotated_Formula a :: Name
a b :: FormulaRole
b c :: THFFormula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a,
                                                      FormulaRole -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FormulaRole
b, THFFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFFormula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]
    TPTP_Include a :: Include
a -> [[Pos]] -> [Pos]
joinRanges [Include -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Include
a]
    TPTP_Comment a :: Comment
a -> [[Pos]] -> [Pos]
joinRanges [Comment -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Comment
a]
    TPTP_Defined_Comment a :: DefinedComment
a -> [[Pos]] -> [Pos]
joinRanges [DefinedComment -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedComment
a]
    TPTP_System_Comment a :: SystemComment
a -> [[Pos]] -> [Pos]
joinRanges [SystemComment -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SystemComment
a]
    TPTP_Header a :: [Comment]
a -> [[Pos]] -> [Pos]
joinRanges [[Comment] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Comment]
a]

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_Line a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    Comment_Block a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange DefinedComment where
  getRange :: DefinedComment -> Range
getRange = Range -> DefinedComment -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedComment -> [Pos]
rangeSpan x :: DefinedComment
x = case DefinedComment
x of
    Defined_Comment_Line a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    Defined_Comment_Block a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange SystemComment where
  getRange :: SystemComment -> Range
getRange = Range -> SystemComment -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: SystemComment -> [Pos]
rangeSpan x :: SystemComment
x = case SystemComment
x of
    System_Comment_Line a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    System_Comment_Block a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange Include where
  getRange :: Include -> Range
getRange = Range -> Include -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Include -> [Pos]
rangeSpan x :: Include
x = case Include
x of
    I_Include a :: Token
a b :: Maybe [Name]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, Maybe [Name] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe [Name]
b]

instance GetRange Annotations where
  getRange :: Annotations -> Range
getRange = Range -> Annotations -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Annotations -> [Pos]
rangeSpan x :: Annotations
x = case Annotations
x of
    Annotations a :: Source
a b :: OptionalInfo
b -> [[Pos]] -> [Pos]
joinRanges [Source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Source
a, OptionalInfo -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OptionalInfo
b]
    Null -> []

instance GetRange FormulaRole where
  getRange :: FormulaRole -> Range
getRange = Range -> FormulaRole -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FormulaRole -> [Pos]
rangeSpan x :: FormulaRole
x = case FormulaRole
x of
    Axiom -> []
    Hypothesis -> []
    Definition -> []
    Assumption -> []
    Lemma -> []
    Theorem -> []
    Conjecture -> []
    Negated_Conjecture -> []
    Plain -> []
    Fi_Domain -> []
    Fi_Functors -> []
    Fi_Predicates -> []
    Type -> []
    Unknown -> []

instance GetRange THFFormula where
  getRange :: THFFormula -> Range
getRange = Range -> THFFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFFormula -> [Pos]
rangeSpan x :: THFFormula
x = case THFFormula
x of
    TF_THF_Logic_Formula a :: THFLogicFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
a]
    TF_THF_Sequent a :: THFSequent
a -> [[Pos]] -> [Pos]
joinRanges [THFSequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFSequent
a]
    T0F_THF_Typed_Const a :: THFTypedConst
a -> [[Pos]] -> [Pos]
joinRanges [THFTypedConst -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTypedConst
a]

instance GetRange THFLogicFormula where
  getRange :: THFLogicFormula -> Range
getRange = Range -> THFLogicFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFLogicFormula -> [Pos]
rangeSpan x :: THFLogicFormula
x = case THFLogicFormula
x of
    TLF_THF_Binary_Formula a :: THFBinaryFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFBinaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFBinaryFormula
a]
    TLF_THF_Unitary_Formula a :: THFUnitaryFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
a]
    TLF_THF_Type_Formula a :: THFTypeFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFTypeFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTypeFormula
a]
    TLF_THF_Sub_Type a :: THFSubType
a -> [[Pos]] -> [Pos]
joinRanges [THFSubType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFSubType
a]

instance GetRange THFBinaryFormula where
  getRange :: THFBinaryFormula -> Range
getRange = Range -> THFBinaryFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFBinaryFormula -> [Pos]
rangeSpan x :: THFBinaryFormula
x = case THFBinaryFormula
x of
    TBF_THF_Binary_Pair a :: THFUnitaryFormula
a b :: THFPairConnective
b c :: THFUnitaryFormula
c -> [[Pos]] -> [Pos]
joinRanges [THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
a, THFPairConnective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFPairConnective
b,
                                             THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
c]
    TBF_THF_Binary_Tuple a :: THFBinaryTuple
a -> [[Pos]] -> [Pos]
joinRanges [THFBinaryTuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFBinaryTuple
a]
    TBF_THF_Binary_Type a :: THFBinaryType
a -> [[Pos]] -> [Pos]
joinRanges [THFBinaryType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFBinaryType
a]

instance GetRange THFBinaryTuple where
  getRange :: THFBinaryTuple -> Range
getRange = Range -> THFBinaryTuple -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFBinaryTuple -> [Pos]
rangeSpan x :: THFBinaryTuple
x = case THFBinaryTuple
x of
    TBT_THF_Or_Formula a :: [THFUnitaryFormula]
a -> [[Pos]] -> [Pos]
joinRanges [[THFUnitaryFormula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFUnitaryFormula]
a]
    TBT_THF_And_Formula a :: [THFUnitaryFormula]
a -> [[Pos]] -> [Pos]
joinRanges [[THFUnitaryFormula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFUnitaryFormula]
a]
    TBT_THF_Apply_Formula a :: [THFUnitaryFormula]
a -> [[Pos]] -> [Pos]
joinRanges [[THFUnitaryFormula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFUnitaryFormula]
a]

instance GetRange THFUnitaryFormula where
  getRange :: THFUnitaryFormula -> Range
getRange = Range -> THFUnitaryFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFUnitaryFormula -> [Pos]
rangeSpan x :: THFUnitaryFormula
x = case THFUnitaryFormula
x of
    TUF_THF_Quantified_Formula a :: THFQuantifiedFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFQuantifiedFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFQuantifiedFormula
a]
    TUF_THF_Unary_Formula a :: THFUnaryConnective
a b :: THFLogicFormula
b -> [[Pos]] -> [Pos]
joinRanges [THFUnaryConnective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnaryConnective
a, THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
b]
    TUF_THF_Atom a :: THFAtom
a -> [[Pos]] -> [Pos]
joinRanges [THFAtom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFAtom
a]
    TUF_THF_Tuple a :: [THFLogicFormula]
a -> [[Pos]] -> [Pos]
joinRanges [[THFLogicFormula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFLogicFormula]
a]
    TUF_THF_Conditional a :: THFLogicFormula
a b :: THFLogicFormula
b c :: THFLogicFormula
c -> [[Pos]] -> [Pos]
joinRanges [THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
a, THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
b,
                                             THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
c]
    TUF_THF_Logic_Formula_Par a :: THFLogicFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
a]
    T0UF_THF_Abstraction a :: [THFVariable]
a b :: THFUnitaryFormula
b -> [[Pos]] -> [Pos]
joinRanges [[THFVariable] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFVariable]
a, THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
b]

instance GetRange THFQuantifiedFormula where
  getRange :: THFQuantifiedFormula -> Range
getRange = Range -> THFQuantifiedFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFQuantifiedFormula -> [Pos]
rangeSpan x :: THFQuantifiedFormula
x = case THFQuantifiedFormula
x of
    TQF_THF_Quantified_Formula a :: THFQuantifier
a b :: [THFVariable]
b c :: THFUnitaryFormula
c -> [[Pos]] -> [Pos]
joinRanges [THFQuantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFQuantifier
a,
                                                    [THFVariable] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFVariable]
b, THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
c]
    T0QF_THF_Quantified_Var a :: Quantifier
a b :: [THFVariable]
b c :: THFUnitaryFormula
c -> [[Pos]] -> [Pos]
joinRanges [Quantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Quantifier
a,
                                                 [THFVariable] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFVariable]
b, THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
c]
    T0QF_THF_Quantified_Novar a :: THFQuantifier
a b :: THFUnitaryFormula
b -> [[Pos]] -> [Pos]
joinRanges [THFQuantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFQuantifier
a,
                                                 THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
b]

instance GetRange THFVariable where
  getRange :: THFVariable -> Range
getRange = Range -> THFVariable -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFVariable -> [Pos]
rangeSpan x :: THFVariable
x = case THFVariable
x of
    TV_THF_Typed_Variable a :: Token
a b :: THFTopLevelType
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, THFTopLevelType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTopLevelType
b]
    TV_Variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange THFTypedConst where
  getRange :: THFTypedConst -> Range
getRange = Range -> THFTypedConst -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFTypedConst -> [Pos]
rangeSpan x :: THFTypedConst
x = case THFTypedConst
x of
    T0TC_Typed_Const a :: AtomicWord
a b :: THFTopLevelType
b -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, THFTopLevelType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTopLevelType
b]
    T0TC_THF_TypedConst_Par a :: THFTypedConst
a -> [[Pos]] -> [Pos]
joinRanges [THFTypedConst -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTypedConst
a]

instance GetRange THFTypeFormula where
  getRange :: THFTypeFormula -> Range
getRange = Range -> THFTypeFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFTypeFormula -> [Pos]
rangeSpan x :: THFTypeFormula
x = case THFTypeFormula
x of
    TTF_THF_Type_Formula a :: THFTypeableFormula
a b :: THFTopLevelType
b -> [[Pos]] -> [Pos]
joinRanges [THFTypeableFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTypeableFormula
a, THFTopLevelType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTopLevelType
b]
    TTF_THF_Typed_Const a :: AtomicWord
a b :: THFTopLevelType
b -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, THFTopLevelType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFTopLevelType
b]

instance GetRange THFTypeableFormula where
  getRange :: THFTypeableFormula -> Range
getRange = Range -> THFTypeableFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFTypeableFormula -> [Pos]
rangeSpan x :: THFTypeableFormula
x = case THFTypeableFormula
x of
    TTyF_THF_Atom a :: THFAtom
a -> [[Pos]] -> [Pos]
joinRanges [THFAtom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFAtom
a]
    TTyF_THF_Tuple a :: [THFLogicFormula]
a -> [[Pos]] -> [Pos]
joinRanges [[THFLogicFormula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFLogicFormula]
a]
    TTyF_THF_Logic_Formula a :: THFLogicFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
a]

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

instance GetRange THFTopLevelType where
  getRange :: THFTopLevelType -> Range
getRange = Range -> THFTopLevelType -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFTopLevelType -> [Pos]
rangeSpan x :: THFTopLevelType
x = case THFTopLevelType
x of
    TTLT_THF_Logic_Formula a :: THFLogicFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFLogicFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFLogicFormula
a]
    T0TLT_Constant a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]
    T0TLT_Variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    T0TLT_Defined_Type a :: DefinedType
a -> [[Pos]] -> [Pos]
joinRanges [DefinedType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedType
a]
    T0TLT_System_Type a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    T0TLT_THF_Binary_Type a :: THFBinaryType
a -> [[Pos]] -> [Pos]
joinRanges [THFBinaryType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFBinaryType
a]

instance GetRange THFUnitaryType where
  getRange :: THFUnitaryType -> Range
getRange = Range -> THFUnitaryType -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFUnitaryType -> [Pos]
rangeSpan x :: THFUnitaryType
x = case THFUnitaryType
x of
    TUT_THF_Unitary_Formula a :: THFUnitaryFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFUnitaryFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnitaryFormula
a]
    T0UT_Constant a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]
    T0UT_Variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    T0UT_Defined_Type a :: DefinedType
a -> [[Pos]] -> [Pos]
joinRanges [DefinedType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedType
a]
    T0UT_System_Type a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    T0UT_THF_Binary_Type_Par a :: THFBinaryType
a -> [[Pos]] -> [Pos]
joinRanges [THFBinaryType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFBinaryType
a]

instance GetRange THFBinaryType where
  getRange :: THFBinaryType -> Range
getRange = Range -> THFBinaryType -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFBinaryType -> [Pos]
rangeSpan x :: THFBinaryType
x = case THFBinaryType
x of
    TBT_THF_Mapping_Type a :: [THFUnitaryType]
a -> [[Pos]] -> [Pos]
joinRanges [[THFUnitaryType] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFUnitaryType]
a]
    TBT_THF_Xprod_Type a :: [THFUnitaryType]
a -> [[Pos]] -> [Pos]
joinRanges [[THFUnitaryType] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFUnitaryType]
a]
    TBT_THF_Union_Type a :: [THFUnitaryType]
a -> [[Pos]] -> [Pos]
joinRanges [[THFUnitaryType] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFUnitaryType]
a]
    T0BT_THF_Binary_Type_Par a :: THFBinaryType
a -> [[Pos]] -> [Pos]
joinRanges [THFBinaryType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFBinaryType
a]

instance GetRange THFAtom where
  getRange :: THFAtom -> Range
getRange = Range -> THFAtom -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFAtom -> [Pos]
rangeSpan x :: THFAtom
x = case THFAtom
x of
    TA_Term a :: Term
a -> [[Pos]] -> [Pos]
joinRanges [Term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Term
a]
    TA_THF_Conn_Term a :: THFConnTerm
a -> [[Pos]] -> [Pos]
joinRanges [THFConnTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFConnTerm
a]
    TA_Defined_Type a :: DefinedType
a -> [[Pos]] -> [Pos]
joinRanges [DefinedType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedType
a]
    TA_Defined_Plain_Formula a :: DefinedPlainFormula
a -> [[Pos]] -> [Pos]
joinRanges [DefinedPlainFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedPlainFormula
a]
    TA_System_Type a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    TA_System_Atomic_Formula a :: SystemTerm
a -> [[Pos]] -> [Pos]
joinRanges [SystemTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SystemTerm
a]
    T0A_Constant a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]
    T0A_Defined_Constant a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    T0A_System_Constant a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    T0A_Variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange THFSequent where
  getRange :: THFSequent -> Range
getRange = Range -> THFSequent -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFSequent -> [Pos]
rangeSpan x :: THFSequent
x = case THFSequent
x of
    TS_THF_Sequent a :: [THFLogicFormula]
a b :: [THFLogicFormula]
b -> [[Pos]] -> [Pos]
joinRanges [[THFLogicFormula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFLogicFormula]
a, [THFLogicFormula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THFLogicFormula]
b]
    TS_THF_Sequent_Par a :: THFSequent
a -> [[Pos]] -> [Pos]
joinRanges [THFSequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFSequent
a]

instance GetRange THFConnTerm where
  getRange :: THFConnTerm -> Range
getRange = Range -> THFConnTerm -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFConnTerm -> [Pos]
rangeSpan x :: THFConnTerm
x = case THFConnTerm
x of
    TCT_THF_Pair_Connective a :: THFPairConnective
a -> [[Pos]] -> [Pos]
joinRanges [THFPairConnective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFPairConnective
a]
    TCT_Assoc_Connective a :: AssocConnective
a -> [[Pos]] -> [Pos]
joinRanges [AssocConnective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AssocConnective
a]
    TCT_THF_Unary_Connective a :: THFUnaryConnective
a -> [[Pos]] -> [Pos]
joinRanges [THFUnaryConnective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFUnaryConnective
a]
    T0CT_THF_Quantifier a :: THFQuantifier
a -> [[Pos]] -> [Pos]
joinRanges [THFQuantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFQuantifier
a]

instance GetRange THFQuantifier where
  getRange :: THFQuantifier -> Range
getRange = Range -> THFQuantifier -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFQuantifier -> [Pos]
rangeSpan x :: THFQuantifier
x = case THFQuantifier
x of
    TQ_ForAll -> []
    TQ_Exists -> []
    TQ_Lambda_Binder -> []
    TQ_Dependent_Product -> []
    TQ_Dependent_Sum -> []
    TQ_Indefinite_Description -> []
    TQ_Definite_Description -> []
    T0Q_PiForAll -> []
    T0Q_SigmaExists -> []

instance GetRange Quantifier where
  getRange :: Quantifier -> Range
getRange = Range -> Quantifier -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Quantifier -> [Pos]
rangeSpan x :: Quantifier
x = case Quantifier
x of
    T0Q_ForAll -> []
    T0Q_Exists -> []

instance GetRange THFPairConnective where
  getRange :: THFPairConnective -> Range
getRange = Range -> THFPairConnective -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFPairConnective -> [Pos]
rangeSpan x :: THFPairConnective
x = case THFPairConnective
x of
    Infix_Equality -> []
    Infix_Inequality -> []
    Equivalent -> []
    Implication -> []
    IF -> []
    XOR -> []
    NOR -> []
    NAND -> []

instance GetRange THFUnaryConnective where
  getRange :: THFUnaryConnective -> Range
getRange = Range -> THFUnaryConnective -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THFUnaryConnective -> [Pos]
rangeSpan x :: THFUnaryConnective
x = case THFUnaryConnective
x of
    Negation -> []
    PiForAll -> []
    SigmaExists -> []

instance GetRange AssocConnective where
  getRange :: AssocConnective -> Range
getRange = Range -> AssocConnective -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: AssocConnective -> [Pos]
rangeSpan x :: AssocConnective
x = case AssocConnective
x of
    OR -> []
    AND -> []

instance GetRange DefinedType where
  getRange :: DefinedType -> Range
getRange = Range -> DefinedType -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedType -> [Pos]
rangeSpan x :: DefinedType
x = case DefinedType
x of
    DT_oType -> []
    DT_o -> []
    DT_iType -> []
    DT_i -> []
    DT_tType -> []
    DT_real -> []
    DT_rat -> []
    DT_int -> []

instance GetRange DefinedPlainFormula where
  getRange :: DefinedPlainFormula -> Range
getRange = Range -> DefinedPlainFormula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedPlainFormula -> [Pos]
rangeSpan x :: DefinedPlainFormula
x = case DefinedPlainFormula
x of
    DPF_Defined_Prop a :: DefinedProp
a -> [[Pos]] -> [Pos]
joinRanges [DefinedProp -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedProp
a]
    DPF_Defined_Formula a :: DefinedPred
a b :: [Term]
b -> [[Pos]] -> [Pos]
joinRanges [DefinedPred -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedPred
a, [Term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Term]
b]

instance GetRange DefinedProp where
  getRange :: DefinedProp -> Range
getRange = Range -> DefinedProp -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedProp -> [Pos]
rangeSpan x :: DefinedProp
x = case DefinedProp
x of
    DP_True -> []
    DP_False -> []

instance GetRange DefinedPred where
  getRange :: DefinedPred -> Range
getRange = Range -> DefinedPred -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedPred -> [Pos]
rangeSpan x :: DefinedPred
x = case DefinedPred
x of
    Disrinct -> []
    Less -> []
    Lesseq -> []
    Greater -> []
    Greatereq -> []
    Is_int -> []
    Is_rat -> []

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
    T_Function_Term a :: FunctionTerm
a -> [[Pos]] -> [Pos]
joinRanges [FunctionTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FunctionTerm
a]
    T_Variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange FunctionTerm where
  getRange :: FunctionTerm -> Range
getRange = Range -> FunctionTerm -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FunctionTerm -> [Pos]
rangeSpan x :: FunctionTerm
x = case FunctionTerm
x of
    FT_Plain_Term a :: PlainTerm
a -> [[Pos]] -> [Pos]
joinRanges [PlainTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PlainTerm
a]
    FT_Defined_Term a :: DefinedTerm
a -> [[Pos]] -> [Pos]
joinRanges [DefinedTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedTerm
a]
    FT_System_Term a :: SystemTerm
a -> [[Pos]] -> [Pos]
joinRanges [SystemTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SystemTerm
a]

instance GetRange PlainTerm where
  getRange :: PlainTerm -> Range
getRange = Range -> PlainTerm -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: PlainTerm -> [Pos]
rangeSpan x :: PlainTerm
x = case PlainTerm
x of
    PT_Plain_Term a :: AtomicWord
a b :: [Term]
b -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, [Term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Term]
b]
    PT_Constant a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]

instance GetRange DefinedTerm where
  getRange :: DefinedTerm -> Range
getRange = Range -> DefinedTerm -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedTerm -> [Pos]
rangeSpan x :: DefinedTerm
x = case DefinedTerm
x of
    DT_Defined_Atom a :: DefinedAtom
a -> [[Pos]] -> [Pos]
joinRanges [DefinedAtom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedAtom
a]
    DT_Defined_Atomic_Term a :: DefinedPlainTerm
a -> [[Pos]] -> [Pos]
joinRanges [DefinedPlainTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedPlainTerm
a]

instance GetRange DefinedAtom where
  getRange :: DefinedAtom -> Range
getRange = Range -> DefinedAtom -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedAtom -> [Pos]
rangeSpan x :: DefinedAtom
x = case DefinedAtom
x of
    DA_Number a :: Number
a -> [[Pos]] -> [Pos]
joinRanges [Number -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Number
a]
    DA_Distinct_Object a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange DefinedPlainTerm where
  getRange :: DefinedPlainTerm -> Range
getRange = Range -> DefinedPlainTerm -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedPlainTerm -> [Pos]
rangeSpan x :: DefinedPlainTerm
x = case DefinedPlainTerm
x of
    DPT_Defined_Function a :: DefinedFunctor
a b :: [Term]
b -> [[Pos]] -> [Pos]
joinRanges [DefinedFunctor -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedFunctor
a, [Term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Term]
b]
    DPT_Defined_Constant a :: DefinedFunctor
a -> [[Pos]] -> [Pos]
joinRanges [DefinedFunctor -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DefinedFunctor
a]

instance GetRange DefinedFunctor where
  getRange :: DefinedFunctor -> Range
getRange = Range -> DefinedFunctor -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DefinedFunctor -> [Pos]
rangeSpan x :: DefinedFunctor
x = case DefinedFunctor
x of
    UMinus -> []
    Sum -> []
    Difference -> []
    Product -> []
    Quotient -> []
    Quotient_e -> []
    Quotient_t -> []
    Quotient_f -> []
    Remainder_e -> []
    Remainder_t -> []
    Remainder_f -> []
    Floor -> []
    Ceiling -> []
    Truncate -> []
    Round -> []
    To_int -> []
    To_rat -> []
    To_real -> []

instance GetRange SystemTerm where
  getRange :: SystemTerm -> Range
getRange = Range -> SystemTerm -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: SystemTerm -> [Pos]
rangeSpan x :: SystemTerm
x = case SystemTerm
x of
    ST_System_Term a :: Token
a b :: [Term]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [Term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Term]
b]
    ST_System_Constant a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange PrincipalSymbol where
  getRange :: PrincipalSymbol -> Range
getRange = Range -> PrincipalSymbol -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: PrincipalSymbol -> [Pos]
rangeSpan x :: PrincipalSymbol
x = case PrincipalSymbol
x of
    PS_Functor a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]
    PS_Variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange Source where
  getRange :: Source -> Range
getRange = Range -> Source -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Source -> [Pos]
rangeSpan x :: Source
x = case Source
x of
    S_Dag_Source a :: DagSource
a -> [[Pos]] -> [Pos]
joinRanges [DagSource -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DagSource
a]
    S_Internal_Source a :: IntroType
a b :: OptionalInfo
b -> [[Pos]] -> [Pos]
joinRanges [IntroType -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan IntroType
a, OptionalInfo -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OptionalInfo
b]
    S_External_Source a :: ExternalSource
a -> [[Pos]] -> [Pos]
joinRanges [ExternalSource -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan ExternalSource
a]
    S_Sources a :: [Source]
a -> [[Pos]] -> [Pos]
joinRanges [[Source] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Source]
a]
    S_Unknown -> []

instance GetRange DagSource where
  getRange :: DagSource -> Range
getRange = Range -> DagSource -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DagSource -> [Pos]
rangeSpan x :: DagSource
x = case DagSource
x of
    DS_Name a :: Name
a -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a]
    DS_Inference_Record a :: AtomicWord
a b :: [InfoItem]
b c :: [ParentInfo]
c -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, [InfoItem] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [InfoItem]
b,
                                             [ParentInfo] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [ParentInfo]
c]

instance GetRange ParentInfo where
  getRange :: ParentInfo -> Range
getRange = Range -> ParentInfo -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: ParentInfo -> [Pos]
rangeSpan x :: ParentInfo
x = case ParentInfo
x of
    PI_Parent_Info a :: Source
a b :: Maybe [GeneralTerm]
b -> [[Pos]] -> [Pos]
joinRanges [Source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Source
a, Maybe [GeneralTerm] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe [GeneralTerm]
b]

instance GetRange IntroType where
  getRange :: IntroType -> Range
getRange = Range -> IntroType -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: IntroType -> [Pos]
rangeSpan x :: IntroType
x = case IntroType
x of
    IT_definition -> []
    IT_axiom_of_choice -> []
    IT_tautology -> []
    IT_assumption -> []

instance GetRange ExternalSource where
  getRange :: ExternalSource -> Range
getRange = Range -> ExternalSource -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: ExternalSource -> [Pos]
rangeSpan x :: ExternalSource
x = case ExternalSource
x of
    ES_File_Source a :: FileSource
a -> [[Pos]] -> [Pos]
joinRanges [FileSource -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FileSource
a]
    ES_Theory a :: TheoryName
a b :: OptionalInfo
b -> [[Pos]] -> [Pos]
joinRanges [TheoryName -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TheoryName
a, OptionalInfo -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OptionalInfo
b]
    ES_Creator_Source a :: AtomicWord
a b :: OptionalInfo
b -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, OptionalInfo -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OptionalInfo
b]

instance GetRange FileSource where
  getRange :: FileSource -> Range
getRange = Range -> FileSource -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FileSource -> [Pos]
rangeSpan x :: FileSource
x = case FileSource
x of
    FS_File a :: Token
a b :: Maybe Name
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, Maybe Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe Name
b]

instance GetRange TheoryName where
  getRange :: TheoryName -> Range
getRange = Range -> TheoryName -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TheoryName -> [Pos]
rangeSpan x :: TheoryName
x = case TheoryName
x of
    Equality -> []
    Ac -> []

instance GetRange InfoItem where
  getRange :: InfoItem -> Range
getRange = Range -> InfoItem -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: InfoItem -> [Pos]
rangeSpan x :: InfoItem
x = case InfoItem
x of
    II_Formula_Item a :: FormulaItem
a -> [[Pos]] -> [Pos]
joinRanges [FormulaItem -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FormulaItem
a]
    II_Inference_Item a :: InferenceItem
a -> [[Pos]] -> [Pos]
joinRanges [InferenceItem -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan InferenceItem
a]
    II_General_Function a :: GeneralFunction
a -> [[Pos]] -> [Pos]
joinRanges [GeneralFunction -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan GeneralFunction
a]

instance GetRange FormulaItem where
  getRange :: FormulaItem -> Range
getRange = Range -> FormulaItem -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FormulaItem -> [Pos]
rangeSpan x :: FormulaItem
x = case FormulaItem
x of
    FI_Description_Item a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]
    FI_Iquote_Item a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]

instance GetRange InferenceItem where
  getRange :: InferenceItem -> Range
getRange = Range -> InferenceItem -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: InferenceItem -> [Pos]
rangeSpan x :: InferenceItem
x = case InferenceItem
x of
    II_Inference_Status a :: InferenceStatus
a -> [[Pos]] -> [Pos]
joinRanges [InferenceStatus -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan InferenceStatus
a]
    II_Assumptions_Record a :: [Name]
a -> [[Pos]] -> [Pos]
joinRanges [[Name] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Name]
a]
    II_New_Symbol_Record a :: AtomicWord
a b :: [PrincipalSymbol]
b -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, [PrincipalSymbol] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [PrincipalSymbol]
b]
    II_Refutation a :: FileSource
a -> [[Pos]] -> [Pos]
joinRanges [FileSource -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FileSource
a]

instance GetRange InferenceStatus where
  getRange :: InferenceStatus -> Range
getRange = Range -> InferenceStatus -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: InferenceStatus -> [Pos]
rangeSpan x :: InferenceStatus
x = case InferenceStatus
x of
    IS_Status a :: StatusValue
a -> [[Pos]] -> [Pos]
joinRanges [StatusValue -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan StatusValue
a]
    IS_Inference_Info a :: AtomicWord
a b :: AtomicWord
b c :: [GeneralTerm]
c -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
b,
                                           [GeneralTerm] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [GeneralTerm]
c]

instance GetRange StatusValue where
  getRange :: StatusValue -> Range
getRange = Range -> StatusValue -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: StatusValue -> [Pos]
rangeSpan x :: StatusValue
x = case StatusValue
x of
    Suc -> []
    Unp -> []
    Sap -> []
    Esa -> []
    Sat -> []
    Fsa -> []
    Thm -> []
    Eqv -> []
    Tac -> []
    Wec -> []
    Eth -> []
    Tau -> []
    Wtc -> []
    Wth -> []
    Cax -> []
    Sca -> []
    Tca -> []
    Wca -> []
    Cup -> []
    Csp -> []
    Ecs -> []
    Csa -> []
    Cth -> []
    Ceq -> []
    Unc -> []
    Wcc -> []
    Ect -> []
    Fun -> []
    Uns -> []
    Wuc -> []
    Wct -> []
    Scc -> []
    Uca -> []
    Noc -> []

instance GetRange GeneralTerm where
  getRange :: GeneralTerm -> Range
getRange = Range -> GeneralTerm -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: GeneralTerm -> [Pos]
rangeSpan x :: GeneralTerm
x = case GeneralTerm
x of
    GT_General_Data a :: GeneralData
a -> [[Pos]] -> [Pos]
joinRanges [GeneralData -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan GeneralData
a]
    GT_General_Data_Term a :: GeneralData
a b :: GeneralTerm
b -> [[Pos]] -> [Pos]
joinRanges [GeneralData -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan GeneralData
a, GeneralTerm -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan GeneralTerm
b]
    GT_General_List a :: [GeneralTerm]
a -> [[Pos]] -> [Pos]
joinRanges [[GeneralTerm] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [GeneralTerm]
a]

instance GetRange GeneralData where
  getRange :: GeneralData -> Range
getRange = Range -> GeneralData -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: GeneralData -> [Pos]
rangeSpan x :: GeneralData
x = case GeneralData
x of
    GD_Atomic_Word a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]
    GD_Variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    GD_Number a :: Number
a -> [[Pos]] -> [Pos]
joinRanges [Number -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Number
a]
    GD_Distinct_Object a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    GD_Formula_Data a :: FormulaData
a -> [[Pos]] -> [Pos]
joinRanges [FormulaData -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FormulaData
a]
    GD_Bind a :: Token
a b :: FormulaData
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, FormulaData -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FormulaData
b]
    GD_General_Function a :: GeneralFunction
a -> [[Pos]] -> [Pos]
joinRanges [GeneralFunction -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan GeneralFunction
a]

instance GetRange GeneralFunction where
  getRange :: GeneralFunction -> Range
getRange = Range -> GeneralFunction -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: GeneralFunction -> [Pos]
rangeSpan x :: GeneralFunction
x = case GeneralFunction
x of
    GF_General_Function a :: AtomicWord
a b :: [GeneralTerm]
b -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a, [GeneralTerm] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [GeneralTerm]
b]

instance GetRange FormulaData where
  getRange :: FormulaData -> Range
getRange = Range -> FormulaData -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FormulaData -> [Pos]
rangeSpan x :: FormulaData
x = case FormulaData
x of
    THF_Formula a :: THFFormula
a -> [[Pos]] -> [Pos]
joinRanges [THFFormula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THFFormula
a]

instance GetRange Name where
  getRange :: Name -> Range
getRange = Range -> Name -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Name -> [Pos]
rangeSpan x :: Name
x = case Name
x of
    N_Atomic_Word a :: AtomicWord
a -> [[Pos]] -> [Pos]
joinRanges [AtomicWord -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan AtomicWord
a]
    N_Integer a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    T0N_Unsigned_Integer a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange AtomicWord where
  getRange :: AtomicWord -> Range
getRange = Range -> AtomicWord -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: AtomicWord -> [Pos]
rangeSpan x :: AtomicWord
x = case AtomicWord
x of
    A_Lower_Word a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    A_Single_Quoted a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange Number where
  getRange :: Number -> Range
getRange = Range -> Number -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Number -> [Pos]
rangeSpan x :: Number
x = case Number
x of
    Num_Integer a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    Num_Rational a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    Num_Real a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]