{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./TPTP/AS.der.hs
Description :  Abstract syntax for TPTP v6.4.0.11
Copyright   :  (c) Eugen Kuksa University of Magdeburg 2017
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  Eugen Kuksa <kuksa@iks.cs.ovgu.de>
Stability   :  provisional
Portability :  portable

Definition of abstract syntax for TPTP taken from [1]

References

[1] G. Sutcliffe et al.: The TPTP language grammar in BNF.
    <http://www.cs.miami.edu/~tptp/TPTP/SyntaxBNF.html>

    Note: The implemented version is saved at TPTP/Documents/SyntaxBNF.html

    Note: The names of the data types are aligned with the names of the
    grammar rules at this reference page (modulo case).

[2] C. Kaliszyk, G. Sutcliffe and F. Rabe:
    TH1: The TPTP Typed Higher-Order Form with Rank-1 Polymorphism
    <https://kwarc.info/people/frabe/Research/KRS_thf1_16.pdf>
    Note: for further information on TF0, TF1, TH0 and TH1
-}

module TPTP.AS where

import Common.Id as Id
import Common.IRI
import Syntax.AS_Structured ()
import qualified Common.AS_Annotation as AS_Anno

import Data.Data

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

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

-- Files

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

-- <TPTP_input>           ::= <annotated_formula> | <include>
data TPTP_input = Annotated_formula Annotated_formula
                | TPTP_include Include
                | TPTP_comment Comment
                | TPTP_defined_comment DefinedComment
                | TPTP_system_comment SystemComment
                  deriving (Int -> TPTP_input -> ShowS
[TPTP_input] -> ShowS
TPTP_input -> String
(Int -> TPTP_input -> ShowS)
-> (TPTP_input -> String)
-> ([TPTP_input] -> ShowS)
-> Show TPTP_input
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TPTP_input] -> ShowS
$cshowList :: [TPTP_input] -> ShowS
show :: TPTP_input -> String
$cshow :: TPTP_input -> String
showsPrec :: Int -> TPTP_input -> ShowS
$cshowsPrec :: Int -> TPTP_input -> ShowS
Show, Eq TPTP_input
Eq TPTP_input =>
(TPTP_input -> TPTP_input -> Ordering)
-> (TPTP_input -> TPTP_input -> Bool)
-> (TPTP_input -> TPTP_input -> Bool)
-> (TPTP_input -> TPTP_input -> Bool)
-> (TPTP_input -> TPTP_input -> Bool)
-> (TPTP_input -> TPTP_input -> TPTP_input)
-> (TPTP_input -> TPTP_input -> TPTP_input)
-> Ord TPTP_input
TPTP_input -> TPTP_input -> Bool
TPTP_input -> TPTP_input -> Ordering
TPTP_input -> TPTP_input -> TPTP_input
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_input -> TPTP_input -> TPTP_input
$cmin :: TPTP_input -> TPTP_input -> TPTP_input
max :: TPTP_input -> TPTP_input -> TPTP_input
$cmax :: TPTP_input -> TPTP_input -> TPTP_input
>= :: TPTP_input -> TPTP_input -> Bool
$c>= :: TPTP_input -> TPTP_input -> Bool
> :: TPTP_input -> TPTP_input -> Bool
$c> :: TPTP_input -> TPTP_input -> Bool
<= :: TPTP_input -> TPTP_input -> Bool
$c<= :: TPTP_input -> TPTP_input -> Bool
< :: TPTP_input -> TPTP_input -> Bool
$c< :: TPTP_input -> TPTP_input -> Bool
compare :: TPTP_input -> TPTP_input -> Ordering
$ccompare :: TPTP_input -> TPTP_input -> Ordering
$cp1Ord :: Eq TPTP_input
Ord, TPTP_input -> TPTP_input -> Bool
(TPTP_input -> TPTP_input -> Bool)
-> (TPTP_input -> TPTP_input -> Bool) -> Eq TPTP_input
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TPTP_input -> TPTP_input -> Bool
$c/= :: TPTP_input -> TPTP_input -> Bool
== :: TPTP_input -> TPTP_input -> Bool
$c== :: TPTP_input -> TPTP_input -> Bool
Eq, Typeable TPTP_input
Constr
DataType
Typeable TPTP_input =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TPTP_input -> c TPTP_input)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TPTP_input)
-> (TPTP_input -> Constr)
-> (TPTP_input -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TPTP_input))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TPTP_input))
-> ((forall b. Data b => b -> b) -> TPTP_input -> TPTP_input)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TPTP_input -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TPTP_input -> r)
-> (forall u. (forall d. Data d => d -> u) -> TPTP_input -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TPTP_input -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input)
-> Data TPTP_input
TPTP_input -> Constr
TPTP_input -> DataType
(forall b. Data b => b -> b) -> TPTP_input -> TPTP_input
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_input -> c TPTP_input
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_input
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_input -> u
forall u. (forall d. Data d => d -> u) -> TPTP_input -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_input -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_input -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_input
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_input -> c TPTP_input
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TPTP_input)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TPTP_input)
$cTPTP_system_comment :: Constr
$cTPTP_defined_comment :: Constr
$cTPTP_comment :: Constr
$cTPTP_include :: Constr
$cAnnotated_formula :: Constr
$tTPTP_input :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
gmapMp :: (forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
gmapM :: (forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TPTP_input -> m TPTP_input
gmapQi :: Int -> (forall d. Data d => d -> u) -> TPTP_input -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TPTP_input -> u
gmapQ :: (forall d. Data d => d -> u) -> TPTP_input -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TPTP_input -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_input -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_input -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_input -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TPTP_input -> r
gmapT :: (forall b. Data b => b -> b) -> TPTP_input -> TPTP_input
$cgmapT :: (forall b. Data b => b -> b) -> TPTP_input -> TPTP_input
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TPTP_input)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TPTP_input)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TPTP_input)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TPTP_input)
dataTypeOf :: TPTP_input -> DataType
$cdataTypeOf :: TPTP_input -> DataType
toConstr :: TPTP_input -> Constr
$ctoConstr :: TPTP_input -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_input
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TPTP_input
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_input -> c TPTP_input
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TPTP_input -> c TPTP_input
$cp1Data :: Typeable TPTP_input
Data, Typeable)

-- Comments

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 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, Typeable)

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 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, Typeable)

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 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, Typeable)

-- %----Formula records
-- <annotated_formula>    ::= <thf_annotated> | <tfx_annotated> | <tff_annotated> |
--                            <tcf_annotated> | <fof_annotated> | <cnf_annotated> |
--                            <tpi_annotated>
data Annotated_formula = AF_THF_Annotated THF_annotated
                       | AF_TFX_Annotated TFX_annotated
                       | AF_TFF_Annotated TFF_annotated
                       | AF_TCF_Annotated TCF_annotated
                       | AF_FOF_Annotated FOF_annotated
                       | AF_CNF_Annotated CNF_annotated
                       | AF_TPI_Annotated TPI_annotated
                         deriving (Int -> Annotated_formula -> ShowS
[Annotated_formula] -> ShowS
Annotated_formula -> String
(Int -> Annotated_formula -> ShowS)
-> (Annotated_formula -> String)
-> ([Annotated_formula] -> ShowS)
-> Show Annotated_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Annotated_formula] -> ShowS
$cshowList :: [Annotated_formula] -> ShowS
show :: Annotated_formula -> String
$cshow :: Annotated_formula -> String
showsPrec :: Int -> Annotated_formula -> ShowS
$cshowsPrec :: Int -> Annotated_formula -> ShowS
Show, Eq Annotated_formula
Eq Annotated_formula =>
(Annotated_formula -> Annotated_formula -> Ordering)
-> (Annotated_formula -> Annotated_formula -> Bool)
-> (Annotated_formula -> Annotated_formula -> Bool)
-> (Annotated_formula -> Annotated_formula -> Bool)
-> (Annotated_formula -> Annotated_formula -> Bool)
-> (Annotated_formula -> Annotated_formula -> Annotated_formula)
-> (Annotated_formula -> Annotated_formula -> Annotated_formula)
-> Ord Annotated_formula
Annotated_formula -> Annotated_formula -> Bool
Annotated_formula -> Annotated_formula -> Ordering
Annotated_formula -> Annotated_formula -> Annotated_formula
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 :: Annotated_formula -> Annotated_formula -> Annotated_formula
$cmin :: Annotated_formula -> Annotated_formula -> Annotated_formula
max :: Annotated_formula -> Annotated_formula -> Annotated_formula
$cmax :: Annotated_formula -> Annotated_formula -> Annotated_formula
>= :: Annotated_formula -> Annotated_formula -> Bool
$c>= :: Annotated_formula -> Annotated_formula -> Bool
> :: Annotated_formula -> Annotated_formula -> Bool
$c> :: Annotated_formula -> Annotated_formula -> Bool
<= :: Annotated_formula -> Annotated_formula -> Bool
$c<= :: Annotated_formula -> Annotated_formula -> Bool
< :: Annotated_formula -> Annotated_formula -> Bool
$c< :: Annotated_formula -> Annotated_formula -> Bool
compare :: Annotated_formula -> Annotated_formula -> Ordering
$ccompare :: Annotated_formula -> Annotated_formula -> Ordering
$cp1Ord :: Eq Annotated_formula
Ord, Annotated_formula -> Annotated_formula -> Bool
(Annotated_formula -> Annotated_formula -> Bool)
-> (Annotated_formula -> Annotated_formula -> Bool)
-> Eq Annotated_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Annotated_formula -> Annotated_formula -> Bool
$c/= :: Annotated_formula -> Annotated_formula -> Bool
== :: Annotated_formula -> Annotated_formula -> Bool
$c== :: Annotated_formula -> Annotated_formula -> Bool
Eq, Typeable Annotated_formula
Constr
DataType
Typeable Annotated_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> Annotated_formula
 -> c Annotated_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Annotated_formula)
-> (Annotated_formula -> Constr)
-> (Annotated_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Annotated_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Annotated_formula))
-> ((forall b. Data b => b -> b)
    -> Annotated_formula -> Annotated_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Annotated_formula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Annotated_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Annotated_formula -> m Annotated_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Annotated_formula -> m Annotated_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Annotated_formula -> m Annotated_formula)
-> Data Annotated_formula
Annotated_formula -> Constr
Annotated_formula -> DataType
(forall b. Data b => b -> b)
-> Annotated_formula -> Annotated_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotated_formula -> c Annotated_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Annotated_formula
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) -> Annotated_formula -> u
forall u. (forall d. Data d => d -> u) -> Annotated_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Annotated_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotated_formula -> c Annotated_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Annotated_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Annotated_formula)
$cAF_TPI_Annotated :: Constr
$cAF_CNF_Annotated :: Constr
$cAF_FOF_Annotated :: Constr
$cAF_TCF_Annotated :: Constr
$cAF_TFF_Annotated :: Constr
$cAF_TFX_Annotated :: Constr
$cAF_THF_Annotated :: Constr
$tAnnotated_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
gmapMp :: (forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
gmapM :: (forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Annotated_formula -> m Annotated_formula
gmapQi :: Int -> (forall d. Data d => d -> u) -> Annotated_formula -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Annotated_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> Annotated_formula -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Annotated_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotated_formula -> r
gmapT :: (forall b. Data b => b -> b)
-> Annotated_formula -> Annotated_formula
$cgmapT :: (forall b. Data b => b -> b)
-> Annotated_formula -> Annotated_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Annotated_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Annotated_formula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Annotated_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Annotated_formula)
dataTypeOf :: Annotated_formula -> DataType
$cdataTypeOf :: Annotated_formula -> DataType
toConstr :: Annotated_formula -> Constr
$ctoConstr :: Annotated_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Annotated_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Annotated_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotated_formula -> c Annotated_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotated_formula -> c Annotated_formula
$cp1Data :: Typeable Annotated_formula
Data, Typeable)

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

-- <tpi_formula>          ::= <fof_formula>
type TPI_formula = FOF_formula

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

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

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

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

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

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

name :: Annotated_formula -> Name
name :: Annotated_formula -> Name
name f :: Annotated_formula
f = case Annotated_formula
f of
  AF_THF_Annotated (THF_annotated n :: Name
n _ _ _) -> Name
n
  AF_TFX_Annotated (TFX_annotated n :: Name
n _ _ _) -> Name
n
  AF_TFF_Annotated (TFF_annotated n :: Name
n _ _ _) -> Name
n
  AF_TCF_Annotated (TCF_annotated n :: Name
n _ _ _) -> Name
n
  AF_FOF_Annotated (FOF_annotated n :: Name
n _ _ _) -> Name
n
  AF_CNF_Annotated (CNF_annotated n :: Name
n _ _ _) -> Name
n
  AF_TPI_Annotated (TPI_annotated n :: Name
n _ _ _) -> Name
n

formulaRole :: Annotated_formula -> Formula_role
formulaRole :: Annotated_formula -> Formula_role
formulaRole f :: Annotated_formula
f = case Annotated_formula
f of
  AF_THF_Annotated (THF_annotated _ r :: Formula_role
r _ _) -> Formula_role
r
  AF_TFX_Annotated (TFX_annotated _ r :: Formula_role
r _ _) -> Formula_role
r
  AF_TFF_Annotated (TFF_annotated _ r :: Formula_role
r _ _) -> Formula_role
r
  AF_TCF_Annotated (TCF_annotated _ r :: Formula_role
r _ _) -> Formula_role
r
  AF_FOF_Annotated (FOF_annotated _ r :: Formula_role
r _ _) -> Formula_role
r
  AF_CNF_Annotated (CNF_annotated _ r :: Formula_role
r _ _) -> Formula_role
r
  AF_TPI_Annotated (TPI_annotated _ r :: Formula_role
r _ _) -> Formula_role
r

annotations :: Annotated_formula -> Annotations
annotations :: Annotated_formula -> Annotations
annotations f :: Annotated_formula
f = case Annotated_formula
f of
  AF_THF_Annotated (THF_annotated _ _ _ a :: Annotations
a) -> Annotations
a
  AF_TFX_Annotated (TFX_annotated _ _ _ a :: Annotations
a) -> Annotations
a
  AF_TFF_Annotated (TFF_annotated _ _ _ a :: Annotations
a) -> Annotations
a
  AF_TCF_Annotated (TCF_annotated _ _ _ a :: Annotations
a) -> Annotations
a
  AF_FOF_Annotated (FOF_annotated _ _ _ a :: Annotations
a) -> Annotations
a
  AF_CNF_Annotated (CNF_annotated _ _ _ a :: Annotations
a) -> Annotations
a
  AF_TPI_Annotated (TPI_annotated _ _ _ a :: Annotations
a) -> Annotations
a

-- <annotations>          ::= ,<source><optional_info> | <null>
newtype Annotations = Annotations (Maybe (Source, Optional_info))
                      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, 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, 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, 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)
$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, Typeable)

-- Types for problems

-- %----Types for problems.
-- <formula_role>         ::= <lower_word>
-- <formula_role>         :== axiom | hypothesis | definition | assumption |
--                            lemma | theorem | corollary | conjecture |
--                            negated_conjecture | plain | type |
--                            fi_domain | fi_functors | fi_predicates | unknown
data Formula_role = Axiom
                  | Hypothesis
                  | Definition
                  | Assumption
                  | Lemma
                  | Theorem
                  | Corollary
                  | Conjecture
                  | Negated_conjecture
                  | Plain
                  | Type
                  | Fi_domain
                  | Fi_functors
                  | Fi_predicates
                  | Unknown
                  | Other_formula_role Token
                    -- ^ For future updates. Should not be used.
                    deriving (Int -> Formula_role -> ShowS
[Formula_role] -> ShowS
Formula_role -> String
(Int -> Formula_role -> ShowS)
-> (Formula_role -> String)
-> ([Formula_role] -> ShowS)
-> Show Formula_role
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Formula_role] -> ShowS
$cshowList :: [Formula_role] -> ShowS
show :: Formula_role -> String
$cshow :: Formula_role -> String
showsPrec :: Int -> Formula_role -> ShowS
$cshowsPrec :: Int -> Formula_role -> ShowS
Show, Eq Formula_role
Eq Formula_role =>
(Formula_role -> Formula_role -> Ordering)
-> (Formula_role -> Formula_role -> Bool)
-> (Formula_role -> Formula_role -> Bool)
-> (Formula_role -> Formula_role -> Bool)
-> (Formula_role -> Formula_role -> Bool)
-> (Formula_role -> Formula_role -> Formula_role)
-> (Formula_role -> Formula_role -> Formula_role)
-> Ord Formula_role
Formula_role -> Formula_role -> Bool
Formula_role -> Formula_role -> Ordering
Formula_role -> Formula_role -> Formula_role
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 :: Formula_role -> Formula_role -> Formula_role
$cmin :: Formula_role -> Formula_role -> Formula_role
max :: Formula_role -> Formula_role -> Formula_role
$cmax :: Formula_role -> Formula_role -> Formula_role
>= :: Formula_role -> Formula_role -> Bool
$c>= :: Formula_role -> Formula_role -> Bool
> :: Formula_role -> Formula_role -> Bool
$c> :: Formula_role -> Formula_role -> Bool
<= :: Formula_role -> Formula_role -> Bool
$c<= :: Formula_role -> Formula_role -> Bool
< :: Formula_role -> Formula_role -> Bool
$c< :: Formula_role -> Formula_role -> Bool
compare :: Formula_role -> Formula_role -> Ordering
$ccompare :: Formula_role -> Formula_role -> Ordering
$cp1Ord :: Eq Formula_role
Ord, Formula_role -> Formula_role -> Bool
(Formula_role -> Formula_role -> Bool)
-> (Formula_role -> Formula_role -> Bool) -> Eq Formula_role
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Formula_role -> Formula_role -> Bool
$c/= :: Formula_role -> Formula_role -> Bool
== :: Formula_role -> Formula_role -> Bool
$c== :: Formula_role -> Formula_role -> Bool
Eq, Typeable Formula_role
Constr
DataType
Typeable Formula_role =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Formula_role -> c Formula_role)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Formula_role)
-> (Formula_role -> Constr)
-> (Formula_role -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Formula_role))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Formula_role))
-> ((forall b. Data b => b -> b) -> Formula_role -> Formula_role)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Formula_role -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Formula_role -> r)
-> (forall u. (forall d. Data d => d -> u) -> Formula_role -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Formula_role -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Formula_role -> m Formula_role)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formula_role -> m Formula_role)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formula_role -> m Formula_role)
-> Data Formula_role
Formula_role -> Constr
Formula_role -> DataType
(forall b. Data b => b -> b) -> Formula_role -> Formula_role
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_role -> c Formula_role
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_role
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) -> Formula_role -> u
forall u. (forall d. Data d => d -> u) -> Formula_role -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_role -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_role -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_role
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_role -> c Formula_role
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formula_role)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Formula_role)
$cOther_formula_role :: Constr
$cUnknown :: Constr
$cFi_predicates :: Constr
$cFi_functors :: Constr
$cFi_domain :: Constr
$cType :: Constr
$cPlain :: Constr
$cNegated_conjecture :: Constr
$cConjecture :: Constr
$cCorollary :: Constr
$cTheorem :: Constr
$cLemma :: Constr
$cAssumption :: Constr
$cDefinition :: Constr
$cHypothesis :: Constr
$cAxiom :: Constr
$tFormula_role :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
gmapMp :: (forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
gmapM :: (forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formula_role -> m Formula_role
gmapQi :: Int -> (forall d. Data d => d -> u) -> Formula_role -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Formula_role -> u
gmapQ :: (forall d. Data d => d -> u) -> Formula_role -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Formula_role -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_role -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_role -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_role -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_role -> r
gmapT :: (forall b. Data b => b -> b) -> Formula_role -> Formula_role
$cgmapT :: (forall b. Data b => b -> b) -> Formula_role -> Formula_role
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Formula_role)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Formula_role)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Formula_role)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formula_role)
dataTypeOf :: Formula_role -> DataType
$cdataTypeOf :: Formula_role -> DataType
toConstr :: Formula_role -> Constr
$ctoConstr :: Formula_role -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_role
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_role
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_role -> c Formula_role
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_role -> c Formula_role
$cp1Data :: Typeable Formula_role
Data, Typeable)

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

-- <thf_logic_formula>    ::= <thf_binary_formula> | <thf_unitary_formula> |
--                            <thf_type_formula> | <thf_subtype>
data THF_logic_formula = THFLF_binary THF_binary_formula
                       | THFLF_unitary THF_unitary_formula
                       | THFLF_type THF_type_formula
                       | THFLF_subtype THF_subtype
                         deriving (Int -> THF_logic_formula -> ShowS
[THF_logic_formula] -> ShowS
THF_logic_formula -> String
(Int -> THF_logic_formula -> ShowS)
-> (THF_logic_formula -> String)
-> ([THF_logic_formula] -> ShowS)
-> Show THF_logic_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_logic_formula] -> ShowS
$cshowList :: [THF_logic_formula] -> ShowS
show :: THF_logic_formula -> String
$cshow :: THF_logic_formula -> String
showsPrec :: Int -> THF_logic_formula -> ShowS
$cshowsPrec :: Int -> THF_logic_formula -> ShowS
Show, Eq THF_logic_formula
Eq THF_logic_formula =>
(THF_logic_formula -> THF_logic_formula -> Ordering)
-> (THF_logic_formula -> THF_logic_formula -> Bool)
-> (THF_logic_formula -> THF_logic_formula -> Bool)
-> (THF_logic_formula -> THF_logic_formula -> Bool)
-> (THF_logic_formula -> THF_logic_formula -> Bool)
-> (THF_logic_formula -> THF_logic_formula -> THF_logic_formula)
-> (THF_logic_formula -> THF_logic_formula -> THF_logic_formula)
-> Ord THF_logic_formula
THF_logic_formula -> THF_logic_formula -> Bool
THF_logic_formula -> THF_logic_formula -> Ordering
THF_logic_formula -> THF_logic_formula -> THF_logic_formula
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 :: THF_logic_formula -> THF_logic_formula -> THF_logic_formula
$cmin :: THF_logic_formula -> THF_logic_formula -> THF_logic_formula
max :: THF_logic_formula -> THF_logic_formula -> THF_logic_formula
$cmax :: THF_logic_formula -> THF_logic_formula -> THF_logic_formula
>= :: THF_logic_formula -> THF_logic_formula -> Bool
$c>= :: THF_logic_formula -> THF_logic_formula -> Bool
> :: THF_logic_formula -> THF_logic_formula -> Bool
$c> :: THF_logic_formula -> THF_logic_formula -> Bool
<= :: THF_logic_formula -> THF_logic_formula -> Bool
$c<= :: THF_logic_formula -> THF_logic_formula -> Bool
< :: THF_logic_formula -> THF_logic_formula -> Bool
$c< :: THF_logic_formula -> THF_logic_formula -> Bool
compare :: THF_logic_formula -> THF_logic_formula -> Ordering
$ccompare :: THF_logic_formula -> THF_logic_formula -> Ordering
$cp1Ord :: Eq THF_logic_formula
Ord, THF_logic_formula -> THF_logic_formula -> Bool
(THF_logic_formula -> THF_logic_formula -> Bool)
-> (THF_logic_formula -> THF_logic_formula -> Bool)
-> Eq THF_logic_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_logic_formula -> THF_logic_formula -> Bool
$c/= :: THF_logic_formula -> THF_logic_formula -> Bool
== :: THF_logic_formula -> THF_logic_formula -> Bool
$c== :: THF_logic_formula -> THF_logic_formula -> Bool
Eq, Typeable THF_logic_formula
Constr
DataType
Typeable THF_logic_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> THF_logic_formula
 -> c THF_logic_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_logic_formula)
-> (THF_logic_formula -> Constr)
-> (THF_logic_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_logic_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_logic_formula))
-> ((forall b. Data b => b -> b)
    -> THF_logic_formula -> THF_logic_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THF_logic_formula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_logic_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THF_logic_formula -> m THF_logic_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_logic_formula -> m THF_logic_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_logic_formula -> m THF_logic_formula)
-> Data THF_logic_formula
THF_logic_formula -> Constr
THF_logic_formula -> DataType
(forall b. Data b => b -> b)
-> THF_logic_formula -> THF_logic_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_logic_formula -> c THF_logic_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_logic_formula
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) -> THF_logic_formula -> u
forall u. (forall d. Data d => d -> u) -> THF_logic_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_logic_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_logic_formula -> c THF_logic_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_logic_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_logic_formula)
$cTHFLF_subtype :: Constr
$cTHFLF_type :: Constr
$cTHFLF_unitary :: Constr
$cTHFLF_binary :: Constr
$tTHF_logic_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
gmapMp :: (forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
gmapM :: (forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_logic_formula -> m THF_logic_formula
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_logic_formula -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THF_logic_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_logic_formula -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_logic_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_logic_formula -> r
gmapT :: (forall b. Data b => b -> b)
-> THF_logic_formula -> THF_logic_formula
$cgmapT :: (forall b. Data b => b -> b)
-> THF_logic_formula -> THF_logic_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_logic_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_logic_formula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_logic_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_logic_formula)
dataTypeOf :: THF_logic_formula -> DataType
$cdataTypeOf :: THF_logic_formula -> DataType
toConstr :: THF_logic_formula -> Constr
$ctoConstr :: THF_logic_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_logic_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_logic_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_logic_formula -> c THF_logic_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_logic_formula -> c THF_logic_formula
$cp1Data :: Typeable THF_logic_formula
Data, Typeable)

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

-- %----Only some binary connectives can be written without ()s.
-- %----There's no precedence among binary connectives
-- <thf_binary_pair>      ::= <thf_unitary_formula> <thf_pair_connective>
--                            <thf_unitary_formula>
data THF_binary_pair = THF_binary_pair THF_pair_connective THF_unitary_formula THF_unitary_formula
                       deriving (Int -> THF_binary_pair -> ShowS
[THF_binary_pair] -> ShowS
THF_binary_pair -> String
(Int -> THF_binary_pair -> ShowS)
-> (THF_binary_pair -> String)
-> ([THF_binary_pair] -> ShowS)
-> Show THF_binary_pair
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_binary_pair] -> ShowS
$cshowList :: [THF_binary_pair] -> ShowS
show :: THF_binary_pair -> String
$cshow :: THF_binary_pair -> String
showsPrec :: Int -> THF_binary_pair -> ShowS
$cshowsPrec :: Int -> THF_binary_pair -> ShowS
Show, Eq THF_binary_pair
Eq THF_binary_pair =>
(THF_binary_pair -> THF_binary_pair -> Ordering)
-> (THF_binary_pair -> THF_binary_pair -> Bool)
-> (THF_binary_pair -> THF_binary_pair -> Bool)
-> (THF_binary_pair -> THF_binary_pair -> Bool)
-> (THF_binary_pair -> THF_binary_pair -> Bool)
-> (THF_binary_pair -> THF_binary_pair -> THF_binary_pair)
-> (THF_binary_pair -> THF_binary_pair -> THF_binary_pair)
-> Ord THF_binary_pair
THF_binary_pair -> THF_binary_pair -> Bool
THF_binary_pair -> THF_binary_pair -> Ordering
THF_binary_pair -> THF_binary_pair -> THF_binary_pair
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 :: THF_binary_pair -> THF_binary_pair -> THF_binary_pair
$cmin :: THF_binary_pair -> THF_binary_pair -> THF_binary_pair
max :: THF_binary_pair -> THF_binary_pair -> THF_binary_pair
$cmax :: THF_binary_pair -> THF_binary_pair -> THF_binary_pair
>= :: THF_binary_pair -> THF_binary_pair -> Bool
$c>= :: THF_binary_pair -> THF_binary_pair -> Bool
> :: THF_binary_pair -> THF_binary_pair -> Bool
$c> :: THF_binary_pair -> THF_binary_pair -> Bool
<= :: THF_binary_pair -> THF_binary_pair -> Bool
$c<= :: THF_binary_pair -> THF_binary_pair -> Bool
< :: THF_binary_pair -> THF_binary_pair -> Bool
$c< :: THF_binary_pair -> THF_binary_pair -> Bool
compare :: THF_binary_pair -> THF_binary_pair -> Ordering
$ccompare :: THF_binary_pair -> THF_binary_pair -> Ordering
$cp1Ord :: Eq THF_binary_pair
Ord, THF_binary_pair -> THF_binary_pair -> Bool
(THF_binary_pair -> THF_binary_pair -> Bool)
-> (THF_binary_pair -> THF_binary_pair -> Bool)
-> Eq THF_binary_pair
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_binary_pair -> THF_binary_pair -> Bool
$c/= :: THF_binary_pair -> THF_binary_pair -> Bool
== :: THF_binary_pair -> THF_binary_pair -> Bool
$c== :: THF_binary_pair -> THF_binary_pair -> Bool
Eq, Typeable THF_binary_pair
Constr
DataType
Typeable THF_binary_pair =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THF_binary_pair -> c THF_binary_pair)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_binary_pair)
-> (THF_binary_pair -> Constr)
-> (THF_binary_pair -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_binary_pair))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_binary_pair))
-> ((forall b. Data b => b -> b)
    -> THF_binary_pair -> THF_binary_pair)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THF_binary_pair -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_binary_pair -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THF_binary_pair -> m THF_binary_pair)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_binary_pair -> m THF_binary_pair)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_binary_pair -> m THF_binary_pair)
-> Data THF_binary_pair
THF_binary_pair -> Constr
THF_binary_pair -> DataType
(forall b. Data b => b -> b) -> THF_binary_pair -> THF_binary_pair
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_pair -> c THF_binary_pair
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_pair
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) -> THF_binary_pair -> u
forall u. (forall d. Data d => d -> u) -> THF_binary_pair -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_pair
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_pair -> c THF_binary_pair
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_binary_pair)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_binary_pair)
$cTHF_binary_pair :: Constr
$tTHF_binary_pair :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
gmapMp :: (forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
gmapM :: (forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_binary_pair -> m THF_binary_pair
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_binary_pair -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THF_binary_pair -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_binary_pair -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_binary_pair -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_pair -> r
gmapT :: (forall b. Data b => b -> b) -> THF_binary_pair -> THF_binary_pair
$cgmapT :: (forall b. Data b => b -> b) -> THF_binary_pair -> THF_binary_pair
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_binary_pair)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_binary_pair)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_binary_pair)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_binary_pair)
dataTypeOf :: THF_binary_pair -> DataType
$cdataTypeOf :: THF_binary_pair -> DataType
toConstr :: THF_binary_pair -> Constr
$ctoConstr :: THF_binary_pair -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_pair
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_pair
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_pair -> c THF_binary_pair
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_pair -> c THF_binary_pair
$cp1Data :: Typeable THF_binary_pair
Data, Typeable)

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

-- <thf_or_formula>       ::= <thf_unitary_formula> <vline> <thf_unitary_formula> |
--                            <thf_or_formula> <vline> <thf_unitary_formula>

type THF_or_formula = [THF_unitary_formula]

-- <thf_and_formula>      ::= <thf_unitary_formula> & <thf_unitary_formula> |
--                            <thf_and_formula> & <thf_unitary_formula>
type THF_and_formula = [THF_unitary_formula]

-- <thf_apply_formula>    ::= <thf_unitary_formula> @ <thf_unitary_formula> |
--                            <thf_apply_formula> @ <thf_unitary_formula>
type THF_apply_formula = [THF_unitary_formula]

-- <thf_unitary_formula>  ::= <thf_quantified_formula> | <thf_unary_formula> |
--                            <thf_atom> | <thf_conditional> | <thf_let> |
--                            <thf_tuple> | (<thf_logic_formula>)
data THF_unitary_formula = THFUF_quantified THF_quantified_formula
                         | THFUF_unary THF_unary_formula
                         | THFUF_atom THF_atom
                         | THFUF_conditional THF_conditional
                         | THFUF_let THF_let
                         | THFUF_tuple THF_tuple
                         | THFUF_logic THF_logic_formula
                           deriving (Int -> THF_unitary_formula -> ShowS
[THF_unitary_formula] -> ShowS
THF_unitary_formula -> String
(Int -> THF_unitary_formula -> ShowS)
-> (THF_unitary_formula -> String)
-> ([THF_unitary_formula] -> ShowS)
-> Show THF_unitary_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_unitary_formula] -> ShowS
$cshowList :: [THF_unitary_formula] -> ShowS
show :: THF_unitary_formula -> String
$cshow :: THF_unitary_formula -> String
showsPrec :: Int -> THF_unitary_formula -> ShowS
$cshowsPrec :: Int -> THF_unitary_formula -> ShowS
Show, Eq THF_unitary_formula
Eq THF_unitary_formula =>
(THF_unitary_formula -> THF_unitary_formula -> Ordering)
-> (THF_unitary_formula -> THF_unitary_formula -> Bool)
-> (THF_unitary_formula -> THF_unitary_formula -> Bool)
-> (THF_unitary_formula -> THF_unitary_formula -> Bool)
-> (THF_unitary_formula -> THF_unitary_formula -> Bool)
-> (THF_unitary_formula
    -> THF_unitary_formula -> THF_unitary_formula)
-> (THF_unitary_formula
    -> THF_unitary_formula -> THF_unitary_formula)
-> Ord THF_unitary_formula
THF_unitary_formula -> THF_unitary_formula -> Bool
THF_unitary_formula -> THF_unitary_formula -> Ordering
THF_unitary_formula -> THF_unitary_formula -> THF_unitary_formula
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 :: THF_unitary_formula -> THF_unitary_formula -> THF_unitary_formula
$cmin :: THF_unitary_formula -> THF_unitary_formula -> THF_unitary_formula
max :: THF_unitary_formula -> THF_unitary_formula -> THF_unitary_formula
$cmax :: THF_unitary_formula -> THF_unitary_formula -> THF_unitary_formula
>= :: THF_unitary_formula -> THF_unitary_formula -> Bool
$c>= :: THF_unitary_formula -> THF_unitary_formula -> Bool
> :: THF_unitary_formula -> THF_unitary_formula -> Bool
$c> :: THF_unitary_formula -> THF_unitary_formula -> Bool
<= :: THF_unitary_formula -> THF_unitary_formula -> Bool
$c<= :: THF_unitary_formula -> THF_unitary_formula -> Bool
< :: THF_unitary_formula -> THF_unitary_formula -> Bool
$c< :: THF_unitary_formula -> THF_unitary_formula -> Bool
compare :: THF_unitary_formula -> THF_unitary_formula -> Ordering
$ccompare :: THF_unitary_formula -> THF_unitary_formula -> Ordering
$cp1Ord :: Eq THF_unitary_formula
Ord, THF_unitary_formula -> THF_unitary_formula -> Bool
(THF_unitary_formula -> THF_unitary_formula -> Bool)
-> (THF_unitary_formula -> THF_unitary_formula -> Bool)
-> Eq THF_unitary_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_unitary_formula -> THF_unitary_formula -> Bool
$c/= :: THF_unitary_formula -> THF_unitary_formula -> Bool
== :: THF_unitary_formula -> THF_unitary_formula -> Bool
$c== :: THF_unitary_formula -> THF_unitary_formula -> Bool
Eq, Typeable THF_unitary_formula
Constr
DataType
Typeable THF_unitary_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> THF_unitary_formula
 -> c THF_unitary_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_unitary_formula)
-> (THF_unitary_formula -> Constr)
-> (THF_unitary_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_unitary_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_unitary_formula))
-> ((forall b. Data b => b -> b)
    -> THF_unitary_formula -> THF_unitary_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THF_unitary_formula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_unitary_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THF_unitary_formula -> m THF_unitary_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_unitary_formula -> m THF_unitary_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_unitary_formula -> m THF_unitary_formula)
-> Data THF_unitary_formula
THF_unitary_formula -> Constr
THF_unitary_formula -> DataType
(forall b. Data b => b -> b)
-> THF_unitary_formula -> THF_unitary_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_unitary_formula
-> c THF_unitary_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_unitary_formula
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) -> THF_unitary_formula -> u
forall u.
(forall d. Data d => d -> u) -> THF_unitary_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_unitary_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_unitary_formula
-> c THF_unitary_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_unitary_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_unitary_formula)
$cTHFUF_logic :: Constr
$cTHFUF_tuple :: Constr
$cTHFUF_let :: Constr
$cTHFUF_conditional :: Constr
$cTHFUF_atom :: Constr
$cTHFUF_unary :: Constr
$cTHFUF_quantified :: Constr
$tTHF_unitary_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
gmapMp :: (forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
gmapM :: (forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_unitary_formula -> m THF_unitary_formula
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_unitary_formula -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THF_unitary_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_unitary_formula -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> THF_unitary_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_unitary_formula -> r
gmapT :: (forall b. Data b => b -> b)
-> THF_unitary_formula -> THF_unitary_formula
$cgmapT :: (forall b. Data b => b -> b)
-> THF_unitary_formula -> THF_unitary_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_unitary_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_unitary_formula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_unitary_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_unitary_formula)
dataTypeOf :: THF_unitary_formula -> DataType
$cdataTypeOf :: THF_unitary_formula -> DataType
toConstr :: THF_unitary_formula -> Constr
$ctoConstr :: THF_unitary_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_unitary_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_unitary_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_unitary_formula
-> c THF_unitary_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_unitary_formula
-> c THF_unitary_formula
$cp1Data :: Typeable THF_unitary_formula
Data, Typeable)

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

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

-- <thf_variable_list>    ::= <thf_variable> | <thf_variable>,<thf_variable_list>
type THF_variable_list = [THF_variable]

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

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

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

-- <thf_atom>             ::= <thf_function> | <variable> | <defined_term> |
--                            <thf_conn_term>
data THF_atom = THF_atom_function THF_function
              | THF_atom_variable Variable
              | THF_atom_defined Defined_term
              | THF_atom_conn THF_conn_term
                deriving (Int -> THF_atom -> ShowS
[THF_atom] -> ShowS
THF_atom -> String
(Int -> THF_atom -> ShowS)
-> (THF_atom -> String) -> ([THF_atom] -> ShowS) -> Show THF_atom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_atom] -> ShowS
$cshowList :: [THF_atom] -> ShowS
show :: THF_atom -> String
$cshow :: THF_atom -> String
showsPrec :: Int -> THF_atom -> ShowS
$cshowsPrec :: Int -> THF_atom -> ShowS
Show, Eq THF_atom
Eq THF_atom =>
(THF_atom -> THF_atom -> Ordering)
-> (THF_atom -> THF_atom -> Bool)
-> (THF_atom -> THF_atom -> Bool)
-> (THF_atom -> THF_atom -> Bool)
-> (THF_atom -> THF_atom -> Bool)
-> (THF_atom -> THF_atom -> THF_atom)
-> (THF_atom -> THF_atom -> THF_atom)
-> Ord THF_atom
THF_atom -> THF_atom -> Bool
THF_atom -> THF_atom -> Ordering
THF_atom -> THF_atom -> THF_atom
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: THF_atom -> THF_atom -> THF_atom
$cmin :: THF_atom -> THF_atom -> THF_atom
max :: THF_atom -> THF_atom -> THF_atom
$cmax :: THF_atom -> THF_atom -> THF_atom
>= :: THF_atom -> THF_atom -> Bool
$c>= :: THF_atom -> THF_atom -> Bool
> :: THF_atom -> THF_atom -> Bool
$c> :: THF_atom -> THF_atom -> Bool
<= :: THF_atom -> THF_atom -> Bool
$c<= :: THF_atom -> THF_atom -> Bool
< :: THF_atom -> THF_atom -> Bool
$c< :: THF_atom -> THF_atom -> Bool
compare :: THF_atom -> THF_atom -> Ordering
$ccompare :: THF_atom -> THF_atom -> Ordering
$cp1Ord :: Eq THF_atom
Ord, THF_atom -> THF_atom -> Bool
(THF_atom -> THF_atom -> Bool)
-> (THF_atom -> THF_atom -> Bool) -> Eq THF_atom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_atom -> THF_atom -> Bool
$c/= :: THF_atom -> THF_atom -> Bool
== :: THF_atom -> THF_atom -> Bool
$c== :: THF_atom -> THF_atom -> Bool
Eq, Typeable THF_atom
Constr
DataType
Typeable THF_atom =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THF_atom -> c THF_atom)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_atom)
-> (THF_atom -> Constr)
-> (THF_atom -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_atom))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_atom))
-> ((forall b. Data b => b -> b) -> THF_atom -> THF_atom)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_atom -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_atom -> r)
-> (forall u. (forall d. Data d => d -> u) -> THF_atom -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> THF_atom -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> THF_atom -> m THF_atom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THF_atom -> m THF_atom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THF_atom -> m THF_atom)
-> Data THF_atom
THF_atom -> Constr
THF_atom -> DataType
(forall b. Data b => b -> b) -> THF_atom -> THF_atom
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_atom -> c THF_atom
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_atom
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> THF_atom -> u
forall u. (forall d. Data d => d -> u) -> THF_atom -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_atom -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_atom -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_atom
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_atom -> c THF_atom
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_atom)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_atom)
$cTHF_atom_conn :: Constr
$cTHF_atom_defined :: Constr
$cTHF_atom_variable :: Constr
$cTHF_atom_function :: Constr
$tTHF_atom :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
gmapMp :: (forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
gmapM :: (forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THF_atom -> m THF_atom
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_atom -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> THF_atom -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_atom -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_atom -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_atom -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_atom -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_atom -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_atom -> r
gmapT :: (forall b. Data b => b -> b) -> THF_atom -> THF_atom
$cgmapT :: (forall b. Data b => b -> b) -> THF_atom -> THF_atom
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_atom)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_atom)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_atom)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_atom)
dataTypeOf :: THF_atom -> DataType
$cdataTypeOf :: THF_atom -> DataType
toConstr :: THF_atom -> Constr
$ctoConstr :: THF_atom -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_atom
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_atom
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_atom -> c THF_atom
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_atom -> c THF_atom
$cp1Data :: Typeable THF_atom
Data, Typeable)

-- <thf_function>         ::= <atom> | <functor>(<thf_arguments>) |
--                            <defined_functor>(<thf_arguments>) |
--                            <system_functor>(<thf_arguments>)
data THF_function = THFF_atom Atom
                  | THFF_functor TPTP_functor THF_arguments
                  | THFF_defined Defined_functor THF_arguments
                  | THFF_system System_functor THF_arguments
                    deriving (Int -> THF_function -> ShowS
[THF_function] -> ShowS
THF_function -> String
(Int -> THF_function -> ShowS)
-> (THF_function -> String)
-> ([THF_function] -> ShowS)
-> Show THF_function
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_function] -> ShowS
$cshowList :: [THF_function] -> ShowS
show :: THF_function -> String
$cshow :: THF_function -> String
showsPrec :: Int -> THF_function -> ShowS
$cshowsPrec :: Int -> THF_function -> ShowS
Show, Eq THF_function
Eq THF_function =>
(THF_function -> THF_function -> Ordering)
-> (THF_function -> THF_function -> Bool)
-> (THF_function -> THF_function -> Bool)
-> (THF_function -> THF_function -> Bool)
-> (THF_function -> THF_function -> Bool)
-> (THF_function -> THF_function -> THF_function)
-> (THF_function -> THF_function -> THF_function)
-> Ord THF_function
THF_function -> THF_function -> Bool
THF_function -> THF_function -> Ordering
THF_function -> THF_function -> THF_function
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 :: THF_function -> THF_function -> THF_function
$cmin :: THF_function -> THF_function -> THF_function
max :: THF_function -> THF_function -> THF_function
$cmax :: THF_function -> THF_function -> THF_function
>= :: THF_function -> THF_function -> Bool
$c>= :: THF_function -> THF_function -> Bool
> :: THF_function -> THF_function -> Bool
$c> :: THF_function -> THF_function -> Bool
<= :: THF_function -> THF_function -> Bool
$c<= :: THF_function -> THF_function -> Bool
< :: THF_function -> THF_function -> Bool
$c< :: THF_function -> THF_function -> Bool
compare :: THF_function -> THF_function -> Ordering
$ccompare :: THF_function -> THF_function -> Ordering
$cp1Ord :: Eq THF_function
Ord, THF_function -> THF_function -> Bool
(THF_function -> THF_function -> Bool)
-> (THF_function -> THF_function -> Bool) -> Eq THF_function
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_function -> THF_function -> Bool
$c/= :: THF_function -> THF_function -> Bool
== :: THF_function -> THF_function -> Bool
$c== :: THF_function -> THF_function -> Bool
Eq, Typeable THF_function
Constr
DataType
Typeable THF_function =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THF_function -> c THF_function)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_function)
-> (THF_function -> Constr)
-> (THF_function -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_function))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_function))
-> ((forall b. Data b => b -> b) -> THF_function -> THF_function)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_function -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_function -> r)
-> (forall u. (forall d. Data d => d -> u) -> THF_function -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_function -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> THF_function -> m THF_function)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THF_function -> m THF_function)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THF_function -> m THF_function)
-> Data THF_function
THF_function -> Constr
THF_function -> DataType
(forall b. Data b => b -> b) -> THF_function -> THF_function
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_function -> c THF_function
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_function
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) -> THF_function -> u
forall u. (forall d. Data d => d -> u) -> THF_function -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_function -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_function -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THF_function -> m THF_function
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_function -> m THF_function
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_function
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_function -> c THF_function
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_function)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_function)
$cTHFF_system :: Constr
$cTHFF_defined :: Constr
$cTHFF_functor :: Constr
$cTHFF_atom :: Constr
$tTHF_function :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> THF_function -> m THF_function
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_function -> m THF_function
gmapMp :: (forall d. Data d => d -> m d) -> THF_function -> m THF_function
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_function -> m THF_function
gmapM :: (forall d. Data d => d -> m d) -> THF_function -> m THF_function
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THF_function -> m THF_function
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_function -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> THF_function -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_function -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_function -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_function -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_function -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_function -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_function -> r
gmapT :: (forall b. Data b => b -> b) -> THF_function -> THF_function
$cgmapT :: (forall b. Data b => b -> b) -> THF_function -> THF_function
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_function)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_function)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_function)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_function)
dataTypeOf :: THF_function -> DataType
$cdataTypeOf :: THF_function -> DataType
toConstr :: THF_function -> Constr
$ctoConstr :: THF_function -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_function
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_function
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_function -> c THF_function
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_function -> c THF_function
$cp1Data :: Typeable THF_function
Data, Typeable)

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

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

-- %----The LHS of a term or formula binding must be a non-variable term that
-- %----is flat with pairwise distinct variable arguments, and the variables in
-- %----the LHS must be exactly those bound in the universally quantified variable
-- %----list, in the same order. Let definitions are not recursive: a non-variable
-- %----symbol introduced in the LHS of a let definition cannot occur in the RHS.
-- %----If a symbol with the same signature as the one in the LHS of the binding
-- %----is declared above the let expression (at the top level or in an
-- %----encompassing let) then it can be used in the RHS of the binding, but it is
-- %----not accessible in the term or formula of the let expression. Let
-- %----expressions can be eliminated by a simple definition expansion.
-- <thf_let>              ::= $let(<thf_unitary_formula>,<thf_formula>)
-- <thf_let>              :== $let(<thf_let_defns>,<thf_formula>)
data THF_let = THF_let THF_let_defns THF_formula
               deriving (Int -> THF_let -> ShowS
[THF_let] -> ShowS
THF_let -> String
(Int -> THF_let -> ShowS)
-> (THF_let -> String) -> ([THF_let] -> ShowS) -> Show THF_let
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_let] -> ShowS
$cshowList :: [THF_let] -> ShowS
show :: THF_let -> String
$cshow :: THF_let -> String
showsPrec :: Int -> THF_let -> ShowS
$cshowsPrec :: Int -> THF_let -> ShowS
Show, Eq THF_let
Eq THF_let =>
(THF_let -> THF_let -> Ordering)
-> (THF_let -> THF_let -> Bool)
-> (THF_let -> THF_let -> Bool)
-> (THF_let -> THF_let -> Bool)
-> (THF_let -> THF_let -> Bool)
-> (THF_let -> THF_let -> THF_let)
-> (THF_let -> THF_let -> THF_let)
-> Ord THF_let
THF_let -> THF_let -> Bool
THF_let -> THF_let -> Ordering
THF_let -> THF_let -> THF_let
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 :: THF_let -> THF_let -> THF_let
$cmin :: THF_let -> THF_let -> THF_let
max :: THF_let -> THF_let -> THF_let
$cmax :: THF_let -> THF_let -> THF_let
>= :: THF_let -> THF_let -> Bool
$c>= :: THF_let -> THF_let -> Bool
> :: THF_let -> THF_let -> Bool
$c> :: THF_let -> THF_let -> Bool
<= :: THF_let -> THF_let -> Bool
$c<= :: THF_let -> THF_let -> Bool
< :: THF_let -> THF_let -> Bool
$c< :: THF_let -> THF_let -> Bool
compare :: THF_let -> THF_let -> Ordering
$ccompare :: THF_let -> THF_let -> Ordering
$cp1Ord :: Eq THF_let
Ord, THF_let -> THF_let -> Bool
(THF_let -> THF_let -> Bool)
-> (THF_let -> THF_let -> Bool) -> Eq THF_let
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_let -> THF_let -> Bool
$c/= :: THF_let -> THF_let -> Bool
== :: THF_let -> THF_let -> Bool
$c== :: THF_let -> THF_let -> Bool
Eq, Typeable THF_let
Constr
DataType
Typeable THF_let =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THF_let -> c THF_let)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_let)
-> (THF_let -> Constr)
-> (THF_let -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_let))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_let))
-> ((forall b. Data b => b -> b) -> THF_let -> THF_let)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_let -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_let -> r)
-> (forall u. (forall d. Data d => d -> u) -> THF_let -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> THF_let -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> THF_let -> m THF_let)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THF_let -> m THF_let)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> THF_let -> m THF_let)
-> Data THF_let
THF_let -> Constr
THF_let -> DataType
(forall b. Data b => b -> b) -> THF_let -> THF_let
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let -> c THF_let
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let
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) -> THF_let -> u
forall u. (forall d. Data d => d -> u) -> THF_let -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THF_let -> m THF_let
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_let -> m THF_let
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let -> c THF_let
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_let)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_let)
$cTHF_let :: Constr
$tTHF_let :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> THF_let -> m THF_let
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_let -> m THF_let
gmapMp :: (forall d. Data d => d -> m d) -> THF_let -> m THF_let
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> THF_let -> m THF_let
gmapM :: (forall d. Data d => d -> m d) -> THF_let -> m THF_let
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> THF_let -> m THF_let
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_let -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> THF_let -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_let -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_let -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let -> r
gmapT :: (forall b. Data b => b -> b) -> THF_let -> THF_let
$cgmapT :: (forall b. Data b => b -> b) -> THF_let -> THF_let
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_let)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c THF_let)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_let)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_let)
dataTypeOf :: THF_let -> DataType
$cdataTypeOf :: THF_let -> DataType
toConstr :: THF_let -> Constr
$ctoConstr :: THF_let -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let -> c THF_let
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let -> c THF_let
$cp1Data :: Typeable THF_let
Data, Typeable)

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

-- <thf_let_defn_list>    :== <thf_let_defn> | <thf_let_defn>,<thf_let_defn_list>
type THF_let_defn_list = [THF_let_defn]

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

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

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

-- <thf_let_defn_LHS>     :== <constant> | <functor>(<fof_arguments>) |
--                            <thf_tuple>
-- %----The <fof_arguments> must all be <variable>s, and the <thf_tuple> may
-- %----contain only <constant>s and <functor>(<fof_arguments>)s
data THF_let_defn_LHS = THFLDL_constant Constant
                      | THFLDL_functor TPTP_functor FOF_arguments
                      | THFLDL_tuple THF_tuple
                        deriving (Int -> THF_let_defn_LHS -> ShowS
[THF_let_defn_LHS] -> ShowS
THF_let_defn_LHS -> String
(Int -> THF_let_defn_LHS -> ShowS)
-> (THF_let_defn_LHS -> String)
-> ([THF_let_defn_LHS] -> ShowS)
-> Show THF_let_defn_LHS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_let_defn_LHS] -> ShowS
$cshowList :: [THF_let_defn_LHS] -> ShowS
show :: THF_let_defn_LHS -> String
$cshow :: THF_let_defn_LHS -> String
showsPrec :: Int -> THF_let_defn_LHS -> ShowS
$cshowsPrec :: Int -> THF_let_defn_LHS -> ShowS
Show, Eq THF_let_defn_LHS
Eq THF_let_defn_LHS =>
(THF_let_defn_LHS -> THF_let_defn_LHS -> Ordering)
-> (THF_let_defn_LHS -> THF_let_defn_LHS -> Bool)
-> (THF_let_defn_LHS -> THF_let_defn_LHS -> Bool)
-> (THF_let_defn_LHS -> THF_let_defn_LHS -> Bool)
-> (THF_let_defn_LHS -> THF_let_defn_LHS -> Bool)
-> (THF_let_defn_LHS -> THF_let_defn_LHS -> THF_let_defn_LHS)
-> (THF_let_defn_LHS -> THF_let_defn_LHS -> THF_let_defn_LHS)
-> Ord THF_let_defn_LHS
THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
THF_let_defn_LHS -> THF_let_defn_LHS -> Ordering
THF_let_defn_LHS -> THF_let_defn_LHS -> THF_let_defn_LHS
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 :: THF_let_defn_LHS -> THF_let_defn_LHS -> THF_let_defn_LHS
$cmin :: THF_let_defn_LHS -> THF_let_defn_LHS -> THF_let_defn_LHS
max :: THF_let_defn_LHS -> THF_let_defn_LHS -> THF_let_defn_LHS
$cmax :: THF_let_defn_LHS -> THF_let_defn_LHS -> THF_let_defn_LHS
>= :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
$c>= :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
> :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
$c> :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
<= :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
$c<= :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
< :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
$c< :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
compare :: THF_let_defn_LHS -> THF_let_defn_LHS -> Ordering
$ccompare :: THF_let_defn_LHS -> THF_let_defn_LHS -> Ordering
$cp1Ord :: Eq THF_let_defn_LHS
Ord, THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
(THF_let_defn_LHS -> THF_let_defn_LHS -> Bool)
-> (THF_let_defn_LHS -> THF_let_defn_LHS -> Bool)
-> Eq THF_let_defn_LHS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
$c/= :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
== :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
$c== :: THF_let_defn_LHS -> THF_let_defn_LHS -> Bool
Eq, Typeable THF_let_defn_LHS
Constr
DataType
Typeable THF_let_defn_LHS =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THF_let_defn_LHS -> c THF_let_defn_LHS)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_let_defn_LHS)
-> (THF_let_defn_LHS -> Constr)
-> (THF_let_defn_LHS -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_let_defn_LHS))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_let_defn_LHS))
-> ((forall b. Data b => b -> b)
    -> THF_let_defn_LHS -> THF_let_defn_LHS)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THF_let_defn_LHS -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_let_defn_LHS -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THF_let_defn_LHS -> m THF_let_defn_LHS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_let_defn_LHS -> m THF_let_defn_LHS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_let_defn_LHS -> m THF_let_defn_LHS)
-> Data THF_let_defn_LHS
THF_let_defn_LHS -> Constr
THF_let_defn_LHS -> DataType
(forall b. Data b => b -> b)
-> THF_let_defn_LHS -> THF_let_defn_LHS
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let_defn_LHS -> c THF_let_defn_LHS
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let_defn_LHS
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) -> THF_let_defn_LHS -> u
forall u. (forall d. Data d => d -> u) -> THF_let_defn_LHS -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let_defn_LHS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let_defn_LHS -> c THF_let_defn_LHS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_let_defn_LHS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_let_defn_LHS)
$cTHFLDL_tuple :: Constr
$cTHFLDL_functor :: Constr
$cTHFLDL_constant :: Constr
$tTHF_let_defn_LHS :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
gmapMp :: (forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
gmapM :: (forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_let_defn_LHS -> m THF_let_defn_LHS
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_let_defn_LHS -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THF_let_defn_LHS -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_let_defn_LHS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_let_defn_LHS -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_let_defn_LHS -> r
gmapT :: (forall b. Data b => b -> b)
-> THF_let_defn_LHS -> THF_let_defn_LHS
$cgmapT :: (forall b. Data b => b -> b)
-> THF_let_defn_LHS -> THF_let_defn_LHS
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_let_defn_LHS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_let_defn_LHS)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_let_defn_LHS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_let_defn_LHS)
dataTypeOf :: THF_let_defn_LHS -> DataType
$cdataTypeOf :: THF_let_defn_LHS -> DataType
toConstr :: THF_let_defn_LHS -> Constr
$ctoConstr :: THF_let_defn_LHS -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let_defn_LHS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_let_defn_LHS
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let_defn_LHS -> c THF_let_defn_LHS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_let_defn_LHS -> c THF_let_defn_LHS
$cp1Data :: Typeable THF_let_defn_LHS
Data, Typeable)

-- <thf_arguments>        ::= <thf_formula_list>
type THF_arguments = THF_formula_list

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

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

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


-- %----<thf_top_level_type> appears after ":", where a type is being specified
-- %----for a term or variable. <thf_unitary_type> includes <thf_unitary_formula>,
-- %----so the syntax allows just about any lambda expression with "enough"
-- %----parentheses to serve as a type. The expected use of this flexibility is
-- %----parametric polymorphism in types, expressed with lambda abstraction.
-- %----Mapping is right-associative: o > o > o means o > (o > o).
-- %----Xproduct is left-associative: o * o * o means (o * o) * o.
-- %----Union is left-associative: o + o + o means (o + o) + o.
-- <thf_top_level_type>   ::= <thf_unitary_type> | <thf_mapping_type>
data THF_top_level_type = THFTLT_unitary THF_unitary_type
                        | THFTLT_mapping THF_mapping_type
                          deriving (Int -> THF_top_level_type -> ShowS
[THF_top_level_type] -> ShowS
THF_top_level_type -> String
(Int -> THF_top_level_type -> ShowS)
-> (THF_top_level_type -> String)
-> ([THF_top_level_type] -> ShowS)
-> Show THF_top_level_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_top_level_type] -> ShowS
$cshowList :: [THF_top_level_type] -> ShowS
show :: THF_top_level_type -> String
$cshow :: THF_top_level_type -> String
showsPrec :: Int -> THF_top_level_type -> ShowS
$cshowsPrec :: Int -> THF_top_level_type -> ShowS
Show, Eq THF_top_level_type
Eq THF_top_level_type =>
(THF_top_level_type -> THF_top_level_type -> Ordering)
-> (THF_top_level_type -> THF_top_level_type -> Bool)
-> (THF_top_level_type -> THF_top_level_type -> Bool)
-> (THF_top_level_type -> THF_top_level_type -> Bool)
-> (THF_top_level_type -> THF_top_level_type -> Bool)
-> (THF_top_level_type -> THF_top_level_type -> THF_top_level_type)
-> (THF_top_level_type -> THF_top_level_type -> THF_top_level_type)
-> Ord THF_top_level_type
THF_top_level_type -> THF_top_level_type -> Bool
THF_top_level_type -> THF_top_level_type -> Ordering
THF_top_level_type -> THF_top_level_type -> THF_top_level_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: THF_top_level_type -> THF_top_level_type -> THF_top_level_type
$cmin :: THF_top_level_type -> THF_top_level_type -> THF_top_level_type
max :: THF_top_level_type -> THF_top_level_type -> THF_top_level_type
$cmax :: THF_top_level_type -> THF_top_level_type -> THF_top_level_type
>= :: THF_top_level_type -> THF_top_level_type -> Bool
$c>= :: THF_top_level_type -> THF_top_level_type -> Bool
> :: THF_top_level_type -> THF_top_level_type -> Bool
$c> :: THF_top_level_type -> THF_top_level_type -> Bool
<= :: THF_top_level_type -> THF_top_level_type -> Bool
$c<= :: THF_top_level_type -> THF_top_level_type -> Bool
< :: THF_top_level_type -> THF_top_level_type -> Bool
$c< :: THF_top_level_type -> THF_top_level_type -> Bool
compare :: THF_top_level_type -> THF_top_level_type -> Ordering
$ccompare :: THF_top_level_type -> THF_top_level_type -> Ordering
$cp1Ord :: Eq THF_top_level_type
Ord, THF_top_level_type -> THF_top_level_type -> Bool
(THF_top_level_type -> THF_top_level_type -> Bool)
-> (THF_top_level_type -> THF_top_level_type -> Bool)
-> Eq THF_top_level_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_top_level_type -> THF_top_level_type -> Bool
$c/= :: THF_top_level_type -> THF_top_level_type -> Bool
== :: THF_top_level_type -> THF_top_level_type -> Bool
$c== :: THF_top_level_type -> THF_top_level_type -> Bool
Eq, Typeable THF_top_level_type
Constr
DataType
Typeable THF_top_level_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> THF_top_level_type
 -> c THF_top_level_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_top_level_type)
-> (THF_top_level_type -> Constr)
-> (THF_top_level_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_top_level_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_top_level_type))
-> ((forall b. Data b => b -> b)
    -> THF_top_level_type -> THF_top_level_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THF_top_level_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_top_level_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THF_top_level_type -> m THF_top_level_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_top_level_type -> m THF_top_level_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_top_level_type -> m THF_top_level_type)
-> Data THF_top_level_type
THF_top_level_type -> Constr
THF_top_level_type -> DataType
(forall b. Data b => b -> b)
-> THF_top_level_type -> THF_top_level_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_top_level_type
-> c THF_top_level_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_top_level_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> THF_top_level_type -> u
forall u. (forall d. Data d => d -> u) -> THF_top_level_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_top_level_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_top_level_type
-> c THF_top_level_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_top_level_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_top_level_type)
$cTHFTLT_mapping :: Constr
$cTHFTLT_unitary :: Constr
$tTHF_top_level_type :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
gmapMp :: (forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
gmapM :: (forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_top_level_type -> m THF_top_level_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_top_level_type -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THF_top_level_type -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_top_level_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_top_level_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_top_level_type -> r
gmapT :: (forall b. Data b => b -> b)
-> THF_top_level_type -> THF_top_level_type
$cgmapT :: (forall b. Data b => b -> b)
-> THF_top_level_type -> THF_top_level_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_top_level_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_top_level_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_top_level_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_top_level_type)
dataTypeOf :: THF_top_level_type -> DataType
$cdataTypeOf :: THF_top_level_type -> DataType
toConstr :: THF_top_level_type -> Constr
$ctoConstr :: THF_top_level_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_top_level_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_top_level_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_top_level_type
-> c THF_top_level_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> THF_top_level_type
-> c THF_top_level_type
$cp1Data :: Typeable THF_top_level_type
Data, Typeable)

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

-- Each of these binary types has at least two (!) list entries.
-- <thf_binary_type>      ::= <thf_mapping_type> | <thf_xprod_type> |
--                            <thf_union_type>
data THF_binary_type = THFBT_mapping THF_mapping_type
                     | THFBT_xprod THF_xprod_type
                     | THFBT_union THF_union_type
                       deriving (Int -> THF_binary_type -> ShowS
[THF_binary_type] -> ShowS
THF_binary_type -> String
(Int -> THF_binary_type -> ShowS)
-> (THF_binary_type -> String)
-> ([THF_binary_type] -> ShowS)
-> Show THF_binary_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_binary_type] -> ShowS
$cshowList :: [THF_binary_type] -> ShowS
show :: THF_binary_type -> String
$cshow :: THF_binary_type -> String
showsPrec :: Int -> THF_binary_type -> ShowS
$cshowsPrec :: Int -> THF_binary_type -> ShowS
Show, Eq THF_binary_type
Eq THF_binary_type =>
(THF_binary_type -> THF_binary_type -> Ordering)
-> (THF_binary_type -> THF_binary_type -> Bool)
-> (THF_binary_type -> THF_binary_type -> Bool)
-> (THF_binary_type -> THF_binary_type -> Bool)
-> (THF_binary_type -> THF_binary_type -> Bool)
-> (THF_binary_type -> THF_binary_type -> THF_binary_type)
-> (THF_binary_type -> THF_binary_type -> THF_binary_type)
-> Ord THF_binary_type
THF_binary_type -> THF_binary_type -> Bool
THF_binary_type -> THF_binary_type -> Ordering
THF_binary_type -> THF_binary_type -> THF_binary_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: THF_binary_type -> THF_binary_type -> THF_binary_type
$cmin :: THF_binary_type -> THF_binary_type -> THF_binary_type
max :: THF_binary_type -> THF_binary_type -> THF_binary_type
$cmax :: THF_binary_type -> THF_binary_type -> THF_binary_type
>= :: THF_binary_type -> THF_binary_type -> Bool
$c>= :: THF_binary_type -> THF_binary_type -> Bool
> :: THF_binary_type -> THF_binary_type -> Bool
$c> :: THF_binary_type -> THF_binary_type -> Bool
<= :: THF_binary_type -> THF_binary_type -> Bool
$c<= :: THF_binary_type -> THF_binary_type -> Bool
< :: THF_binary_type -> THF_binary_type -> Bool
$c< :: THF_binary_type -> THF_binary_type -> Bool
compare :: THF_binary_type -> THF_binary_type -> Ordering
$ccompare :: THF_binary_type -> THF_binary_type -> Ordering
$cp1Ord :: Eq THF_binary_type
Ord, THF_binary_type -> THF_binary_type -> Bool
(THF_binary_type -> THF_binary_type -> Bool)
-> (THF_binary_type -> THF_binary_type -> Bool)
-> Eq THF_binary_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_binary_type -> THF_binary_type -> Bool
$c/= :: THF_binary_type -> THF_binary_type -> Bool
== :: THF_binary_type -> THF_binary_type -> Bool
$c== :: THF_binary_type -> THF_binary_type -> Bool
Eq, Typeable THF_binary_type
Constr
DataType
Typeable THF_binary_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THF_binary_type -> c THF_binary_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_binary_type)
-> (THF_binary_type -> Constr)
-> (THF_binary_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_binary_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_binary_type))
-> ((forall b. Data b => b -> b)
    -> THF_binary_type -> THF_binary_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THF_binary_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_binary_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THF_binary_type -> m THF_binary_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_binary_type -> m THF_binary_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_binary_type -> m THF_binary_type)
-> Data THF_binary_type
THF_binary_type -> Constr
THF_binary_type -> DataType
(forall b. Data b => b -> b) -> THF_binary_type -> THF_binary_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_type -> c THF_binary_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> THF_binary_type -> u
forall u. (forall d. Data d => d -> u) -> THF_binary_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_type -> c THF_binary_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_binary_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_binary_type)
$cTHFBT_union :: Constr
$cTHFBT_xprod :: Constr
$cTHFBT_mapping :: Constr
$tTHF_binary_type :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
gmapMp :: (forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
gmapM :: (forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_binary_type -> m THF_binary_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_binary_type -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THF_binary_type -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_binary_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_binary_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_binary_type -> r
gmapT :: (forall b. Data b => b -> b) -> THF_binary_type -> THF_binary_type
$cgmapT :: (forall b. Data b => b -> b) -> THF_binary_type -> THF_binary_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_binary_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_binary_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_binary_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_binary_type)
dataTypeOf :: THF_binary_type -> DataType
$cdataTypeOf :: THF_binary_type -> DataType
toConstr :: THF_binary_type -> Constr
$ctoConstr :: THF_binary_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_binary_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_type -> c THF_binary_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_binary_type -> c THF_binary_type
$cp1Data :: Typeable THF_binary_type
Data, Typeable)

-- <thf_mapping_type>     ::= <thf_unitary_type> <arrow> <thf_unitary_type> |
--                            <thf_unitary_type> <arrow> <thf_mapping_type>
type THF_mapping_type = [THF_unitary_type] -- right associative

-- <thf_xprod_type>       ::= <thf_unitary_type> <star> <thf_unitary_type> |
--                            <thf_xprod_type> <star> <thf_unitary_type>
type THF_xprod_type = [THF_unitary_type] -- left associative

-- <thf_union_type>       ::= <thf_unitary_type> <plus> <thf_unitary_type> |
--                            <thf_union_type> <plus> <thf_unitary_type>
type THF_union_type = [THF_unitary_type] -- right associative

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

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

-- <thf_formula_list>     ::= <thf_logic_formula> |
--                            <thf_logic_formula>,<thf_formula_list>
type THF_formula_list = [THF_logic_formula]

-- NOTE: not used by parser
-- %----New material for modal logic semantics, not integrated yet
-- <logic_defn_rule>      :== <logic_defn_LHS> <assignment> <logic_defn_RHS>-
-- data Logic_defn_rule = Logic_defn_rule Logic_defn_LHS Logic_defn_RHS
--                        deriving (Show, Ord, Eq, Data, Typeable)

-- NOTE: not used by parser
-- <logic_defn_LHS>       :== <logic_defn_value> | <thf_top_level_type>  | <name>
-- <logic_defn_LHS>       :== $constants | $quantification | $consequence |
--                            $modalities
--                            %----The $constants, $quantification, and $consequence apply to all of the
--                            %----$modalities. Each of these may be specified only once, but not necessarily
--                            %----all in a single annotated formula.-
-- data Logic_defn_LHS = Logic_defn_LHS_value Logic_defn_value
--                     | Logic_defn_LHS_THF_Top_level_type THF_top_level_type
--                     | Logic_defn_LHS_name Name
--                     | LDLC_constants
--                     | LDLC_quantification
--                     | LDLC_consequence
--                     | LDLC_modalities
--                       deriving (Show, Ord, Eq, Data, Typeable)

-- NOTE: not used by parser
-- <logic_defn_RHS>       :== <logic_defn_value> | <thf_unitary_formula>-
-- data Logic_defn_RHS = Logic_defn_RHS_value Logic_defn_value
--                     | Logic_defn_RNG_THF_Unitary_forumla THF_unitary_formula
--                       deriving (Show, Ord, Eq, Data, Typeable)

-- NOTE: not used by parser
-- <logic_defn_value>     :== <defined_constant>
-- <logic_defn_value>     :== $rigid | $flexible |
--                            $constant | $varying | $cumulative | $decreasing |
--                            $local | $global |
--                            $modal_system_K | $modal_system_T | $modal_system_D |
--                            $modal_system_S4 | $modal_system_S5 |
--                            $modal_axiom_K | $modal_axiom_T | $modal_axiom_B |
--                            $modal_axiom_D | $modal_axiom_4 | $modal_axiom_5-
-- data Logic_defn_value = Rigid
--                       | Flexible
--                       | Constant
--                       | Varying
--                       | Cumulative
--                       | Decreasing
--                       | Local
--                       | Global
--                       | Modal_system_K
--                       | Modal_system_T
--                       | Modal_system_D
--                       | Modal_system_S4
--                       | Modal_system_S5
--                       | Modal_axiom_K
--                       | Modal_axiom_T
--                       | Modal_axiom_B
--                       | Modal_axiom_D
--                       | Modal_axiom_4
--                       | Modal_axiom_5
--                       deriving (Show, Ord, Eq, Data, Typeable)

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

-- <tfx_logic_formula>    ::= <thf_logic_formula>
-- % <tfx_logic_formula>    ::= <thf_binary_formula> | <thf_unitary_formula> |
-- %                            <tff_typed_atom> | <tff_subtype>
data TFX_logic_formula = TFXLF_binary THF_binary_formula
                       | TFXLF_unitary THF_unitary_formula
                       | TFXLF_typed TFF_typed_atom
                       | TFXLF_subtype TFF_subtype
                         deriving (Int -> TFX_logic_formula -> ShowS
[TFX_logic_formula] -> ShowS
TFX_logic_formula -> String
(Int -> TFX_logic_formula -> ShowS)
-> (TFX_logic_formula -> String)
-> ([TFX_logic_formula] -> ShowS)
-> Show TFX_logic_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFX_logic_formula] -> ShowS
$cshowList :: [TFX_logic_formula] -> ShowS
show :: TFX_logic_formula -> String
$cshow :: TFX_logic_formula -> String
showsPrec :: Int -> TFX_logic_formula -> ShowS
$cshowsPrec :: Int -> TFX_logic_formula -> ShowS
Show, Eq TFX_logic_formula
Eq TFX_logic_formula =>
(TFX_logic_formula -> TFX_logic_formula -> Ordering)
-> (TFX_logic_formula -> TFX_logic_formula -> Bool)
-> (TFX_logic_formula -> TFX_logic_formula -> Bool)
-> (TFX_logic_formula -> TFX_logic_formula -> Bool)
-> (TFX_logic_formula -> TFX_logic_formula -> Bool)
-> (TFX_logic_formula -> TFX_logic_formula -> TFX_logic_formula)
-> (TFX_logic_formula -> TFX_logic_formula -> TFX_logic_formula)
-> Ord TFX_logic_formula
TFX_logic_formula -> TFX_logic_formula -> Bool
TFX_logic_formula -> TFX_logic_formula -> Ordering
TFX_logic_formula -> TFX_logic_formula -> TFX_logic_formula
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 :: TFX_logic_formula -> TFX_logic_formula -> TFX_logic_formula
$cmin :: TFX_logic_formula -> TFX_logic_formula -> TFX_logic_formula
max :: TFX_logic_formula -> TFX_logic_formula -> TFX_logic_formula
$cmax :: TFX_logic_formula -> TFX_logic_formula -> TFX_logic_formula
>= :: TFX_logic_formula -> TFX_logic_formula -> Bool
$c>= :: TFX_logic_formula -> TFX_logic_formula -> Bool
> :: TFX_logic_formula -> TFX_logic_formula -> Bool
$c> :: TFX_logic_formula -> TFX_logic_formula -> Bool
<= :: TFX_logic_formula -> TFX_logic_formula -> Bool
$c<= :: TFX_logic_formula -> TFX_logic_formula -> Bool
< :: TFX_logic_formula -> TFX_logic_formula -> Bool
$c< :: TFX_logic_formula -> TFX_logic_formula -> Bool
compare :: TFX_logic_formula -> TFX_logic_formula -> Ordering
$ccompare :: TFX_logic_formula -> TFX_logic_formula -> Ordering
$cp1Ord :: Eq TFX_logic_formula
Ord, TFX_logic_formula -> TFX_logic_formula -> Bool
(TFX_logic_formula -> TFX_logic_formula -> Bool)
-> (TFX_logic_formula -> TFX_logic_formula -> Bool)
-> Eq TFX_logic_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFX_logic_formula -> TFX_logic_formula -> Bool
$c/= :: TFX_logic_formula -> TFX_logic_formula -> Bool
== :: TFX_logic_formula -> TFX_logic_formula -> Bool
$c== :: TFX_logic_formula -> TFX_logic_formula -> Bool
Eq, Typeable TFX_logic_formula
Constr
DataType
Typeable TFX_logic_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> TFX_logic_formula
 -> c TFX_logic_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFX_logic_formula)
-> (TFX_logic_formula -> Constr)
-> (TFX_logic_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFX_logic_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFX_logic_formula))
-> ((forall b. Data b => b -> b)
    -> TFX_logic_formula -> TFX_logic_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFX_logic_formula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFX_logic_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFX_logic_formula -> m TFX_logic_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFX_logic_formula -> m TFX_logic_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFX_logic_formula -> m TFX_logic_formula)
-> Data TFX_logic_formula
TFX_logic_formula -> Constr
TFX_logic_formula -> DataType
(forall b. Data b => b -> b)
-> TFX_logic_formula -> TFX_logic_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFX_logic_formula -> c TFX_logic_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFX_logic_formula
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) -> TFX_logic_formula -> u
forall u. (forall d. Data d => d -> u) -> TFX_logic_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFX_logic_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFX_logic_formula -> c TFX_logic_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFX_logic_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFX_logic_formula)
$cTFXLF_subtype :: Constr
$cTFXLF_typed :: Constr
$cTFXLF_unitary :: Constr
$cTFXLF_binary :: Constr
$tTFX_logic_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
gmapMp :: (forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
gmapM :: (forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFX_logic_formula -> m TFX_logic_formula
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFX_logic_formula -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFX_logic_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> TFX_logic_formula -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFX_logic_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFX_logic_formula -> r
gmapT :: (forall b. Data b => b -> b)
-> TFX_logic_formula -> TFX_logic_formula
$cgmapT :: (forall b. Data b => b -> b)
-> TFX_logic_formula -> TFX_logic_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFX_logic_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFX_logic_formula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFX_logic_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFX_logic_formula)
dataTypeOf :: TFX_logic_formula -> DataType
$cdataTypeOf :: TFX_logic_formula -> DataType
toConstr :: TFX_logic_formula -> Constr
$ctoConstr :: TFX_logic_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFX_logic_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFX_logic_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFX_logic_formula -> c TFX_logic_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFX_logic_formula -> c TFX_logic_formula
$cp1Data :: Typeable TFX_logic_formula
Data, Typeable)

-- %----TFF formulae.
-- <tff_formula>          ::= <tff_logic_formula> | <tff_typed_atom> |
--                            <tff_sequent>
data TFF_formula = TFFF_logic TFF_logic_formula
                 | TFFF_atom TFF_typed_atom
                 | TFFF_sequent TFF_sequent
                   deriving (Int -> TFF_formula -> ShowS
[TFF_formula] -> ShowS
TFF_formula -> String
(Int -> TFF_formula -> ShowS)
-> (TFF_formula -> String)
-> ([TFF_formula] -> ShowS)
-> Show TFF_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_formula] -> ShowS
$cshowList :: [TFF_formula] -> ShowS
show :: TFF_formula -> String
$cshow :: TFF_formula -> String
showsPrec :: Int -> TFF_formula -> ShowS
$cshowsPrec :: Int -> TFF_formula -> ShowS
Show, Eq TFF_formula
Eq TFF_formula =>
(TFF_formula -> TFF_formula -> Ordering)
-> (TFF_formula -> TFF_formula -> Bool)
-> (TFF_formula -> TFF_formula -> Bool)
-> (TFF_formula -> TFF_formula -> Bool)
-> (TFF_formula -> TFF_formula -> Bool)
-> (TFF_formula -> TFF_formula -> TFF_formula)
-> (TFF_formula -> TFF_formula -> TFF_formula)
-> Ord TFF_formula
TFF_formula -> TFF_formula -> Bool
TFF_formula -> TFF_formula -> Ordering
TFF_formula -> TFF_formula -> TFF_formula
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 :: TFF_formula -> TFF_formula -> TFF_formula
$cmin :: TFF_formula -> TFF_formula -> TFF_formula
max :: TFF_formula -> TFF_formula -> TFF_formula
$cmax :: TFF_formula -> TFF_formula -> TFF_formula
>= :: TFF_formula -> TFF_formula -> Bool
$c>= :: TFF_formula -> TFF_formula -> Bool
> :: TFF_formula -> TFF_formula -> Bool
$c> :: TFF_formula -> TFF_formula -> Bool
<= :: TFF_formula -> TFF_formula -> Bool
$c<= :: TFF_formula -> TFF_formula -> Bool
< :: TFF_formula -> TFF_formula -> Bool
$c< :: TFF_formula -> TFF_formula -> Bool
compare :: TFF_formula -> TFF_formula -> Ordering
$ccompare :: TFF_formula -> TFF_formula -> Ordering
$cp1Ord :: Eq TFF_formula
Ord, TFF_formula -> TFF_formula -> Bool
(TFF_formula -> TFF_formula -> Bool)
-> (TFF_formula -> TFF_formula -> Bool) -> Eq TFF_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_formula -> TFF_formula -> Bool
$c/= :: TFF_formula -> TFF_formula -> Bool
== :: TFF_formula -> TFF_formula -> Bool
$c== :: TFF_formula -> TFF_formula -> Bool
Eq, Typeable TFF_formula
Constr
DataType
Typeable TFF_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TFF_formula -> c TFF_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_formula)
-> (TFF_formula -> Constr)
-> (TFF_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_formula))
-> ((forall b. Data b => b -> b) -> TFF_formula -> TFF_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_formula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_formula -> r)
-> (forall u. (forall d. Data d => d -> u) -> TFF_formula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula)
-> Data TFF_formula
TFF_formula -> Constr
TFF_formula -> DataType
(forall b. Data b => b -> b) -> TFF_formula -> TFF_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_formula -> c TFF_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_formula
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) -> TFF_formula -> u
forall u. (forall d. Data d => d -> u) -> TFF_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_formula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_formula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_formula -> c TFF_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_formula)
$cTFFF_sequent :: Constr
$cTFFF_atom :: Constr
$cTFFF_logic :: Constr
$tTFF_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
gmapMp :: (forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
gmapM :: (forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TFF_formula -> m TFF_formula
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_formula -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TFF_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_formula -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFF_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_formula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_formula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_formula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_formula -> r
gmapT :: (forall b. Data b => b -> b) -> TFF_formula -> TFF_formula
$cgmapT :: (forall b. Data b => b -> b) -> TFF_formula -> TFF_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_formula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_formula)
dataTypeOf :: TFF_formula -> DataType
$cdataTypeOf :: TFF_formula -> DataType
toConstr :: TFF_formula -> Constr
$ctoConstr :: TFF_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_formula -> c TFF_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_formula -> c TFF_formula
$cp1Data :: Typeable TFF_formula
Data, Typeable)

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

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

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

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

-- <tff_or_formula>       ::= <tff_unitary_formula> <vline> <tff_unitary_formula> |
--                            <tff_or_formula> <vline> <tff_unitary_formula>
type TFF_or_formula = [TFF_unitary_formula]

-- <tff_and_formula>      ::= <tff_unitary_formula> & <tff_unitary_formula> |
--                            <tff_and_formula> & <tff_unitary_formula>
type TFF_and_formula = [TFF_unitary_formula]

-- <tff_unitary_formula>  ::= <tff_quantified_formula> | <tff_unary_formula> |
--                            <tff_atomic_formula> | <tff_conditional> |
--                            <tff_let> | (<tff_logic_formula>)
data TFF_unitary_formula = TFFUF_quantified TFF_quantified_formula
                         | TFFUF_unary TFF_unary_formula
                         | TFFUF_atomic TFF_atomic_formula
                         | TFFUF_conditional TFF_conditional
                         | TFFUF_let TFF_let
                         | TFFUF_logic TFF_logic_formula
                           deriving (Int -> TFF_unitary_formula -> ShowS
[TFF_unitary_formula] -> ShowS
TFF_unitary_formula -> String
(Int -> TFF_unitary_formula -> ShowS)
-> (TFF_unitary_formula -> String)
-> ([TFF_unitary_formula] -> ShowS)
-> Show TFF_unitary_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_unitary_formula] -> ShowS
$cshowList :: [TFF_unitary_formula] -> ShowS
show :: TFF_unitary_formula -> String
$cshow :: TFF_unitary_formula -> String
showsPrec :: Int -> TFF_unitary_formula -> ShowS
$cshowsPrec :: Int -> TFF_unitary_formula -> ShowS
Show, Eq TFF_unitary_formula
Eq TFF_unitary_formula =>
(TFF_unitary_formula -> TFF_unitary_formula -> Ordering)
-> (TFF_unitary_formula -> TFF_unitary_formula -> Bool)
-> (TFF_unitary_formula -> TFF_unitary_formula -> Bool)
-> (TFF_unitary_formula -> TFF_unitary_formula -> Bool)
-> (TFF_unitary_formula -> TFF_unitary_formula -> Bool)
-> (TFF_unitary_formula
    -> TFF_unitary_formula -> TFF_unitary_formula)
-> (TFF_unitary_formula
    -> TFF_unitary_formula -> TFF_unitary_formula)
-> Ord TFF_unitary_formula
TFF_unitary_formula -> TFF_unitary_formula -> Bool
TFF_unitary_formula -> TFF_unitary_formula -> Ordering
TFF_unitary_formula -> TFF_unitary_formula -> TFF_unitary_formula
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 :: TFF_unitary_formula -> TFF_unitary_formula -> TFF_unitary_formula
$cmin :: TFF_unitary_formula -> TFF_unitary_formula -> TFF_unitary_formula
max :: TFF_unitary_formula -> TFF_unitary_formula -> TFF_unitary_formula
$cmax :: TFF_unitary_formula -> TFF_unitary_formula -> TFF_unitary_formula
>= :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
$c>= :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
> :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
$c> :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
<= :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
$c<= :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
< :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
$c< :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
compare :: TFF_unitary_formula -> TFF_unitary_formula -> Ordering
$ccompare :: TFF_unitary_formula -> TFF_unitary_formula -> Ordering
$cp1Ord :: Eq TFF_unitary_formula
Ord, TFF_unitary_formula -> TFF_unitary_formula -> Bool
(TFF_unitary_formula -> TFF_unitary_formula -> Bool)
-> (TFF_unitary_formula -> TFF_unitary_formula -> Bool)
-> Eq TFF_unitary_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
$c/= :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
== :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
$c== :: TFF_unitary_formula -> TFF_unitary_formula -> Bool
Eq, Typeable TFF_unitary_formula
Constr
DataType
Typeable TFF_unitary_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> TFF_unitary_formula
 -> c TFF_unitary_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_unitary_formula)
-> (TFF_unitary_formula -> Constr)
-> (TFF_unitary_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_unitary_formula))
-> ((forall b. Data b => b -> b)
    -> TFF_unitary_formula -> TFF_unitary_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFF_unitary_formula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_unitary_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFF_unitary_formula -> m TFF_unitary_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_unitary_formula -> m TFF_unitary_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_unitary_formula -> m TFF_unitary_formula)
-> Data TFF_unitary_formula
TFF_unitary_formula -> Constr
TFF_unitary_formula -> DataType
(forall b. Data b => b -> b)
-> TFF_unitary_formula -> TFF_unitary_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_unitary_formula
-> c TFF_unitary_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_formula
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) -> TFF_unitary_formula -> u
forall u.
(forall d. Data d => d -> u) -> TFF_unitary_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_unitary_formula
-> c TFF_unitary_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_unitary_formula)
$cTFFUF_logic :: Constr
$cTFFUF_let :: Constr
$cTFFUF_conditional :: Constr
$cTFFUF_atomic :: Constr
$cTFFUF_unary :: Constr
$cTFFUF_quantified :: Constr
$tTFF_unitary_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
gmapMp :: (forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
gmapM :: (forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_formula -> m TFF_unitary_formula
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_unitary_formula -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFF_unitary_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_unitary_formula -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> TFF_unitary_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_formula -> r
gmapT :: (forall b. Data b => b -> b)
-> TFF_unitary_formula -> TFF_unitary_formula
$cgmapT :: (forall b. Data b => b -> b)
-> TFF_unitary_formula -> TFF_unitary_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_unitary_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_unitary_formula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_formula)
dataTypeOf :: TFF_unitary_formula -> DataType
$cdataTypeOf :: TFF_unitary_formula -> DataType
toConstr :: TFF_unitary_formula -> Constr
$ctoConstr :: TFF_unitary_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_unitary_formula
-> c TFF_unitary_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_unitary_formula
-> c TFF_unitary_formula
$cp1Data :: Typeable TFF_unitary_formula
Data, Typeable)

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

-- <tff_variable_list>    ::= <tff_variable> | <tff_variable>,<tff_variable_list>
type TFF_variable_list = [TFF_variable]

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

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

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

-- <tff_atomic_formula>   ::= <fof_atomic_formula>
type TFF_atomic_formula = FOF_atomic_formula

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

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

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

-- <tff_let_term_list>    ::= <tff_let_term_defn> |
--                            <tff_let_term_defn>,<tff_let_term_list>
type TFF_let_term_list = [TFF_let_term_defn]

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

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

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

-- <tff_let_formula_list> ::= <tff_let_formula_defn> |
--                            <tff_let_formula_defn>,<tff_let_formula_list>
type TFF_let_formula_list = [TFF_let_formula_defn]

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

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

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

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

-- <tff_formula_tuple_list> ::= <tff_logic_formula> |
--                            <tff_logic_formula>,<tff_formula_tuple_list>
type TFF_formula_tuple_list = [TFF_logic_formula]

-- %----<tff_typed_atom> can appear only at top level
-- <tff_typed_atom>       ::= <untyped_atom> : <tff_top_level_type> |
--                            (<tff_typed_atom>)
data TFF_typed_atom = TFFTA_plain Untyped_atom TFF_top_level_type
                    | TFFTA_parens TFF_typed_atom
                      deriving (Int -> TFF_typed_atom -> ShowS
[TFF_typed_atom] -> ShowS
TFF_typed_atom -> String
(Int -> TFF_typed_atom -> ShowS)
-> (TFF_typed_atom -> String)
-> ([TFF_typed_atom] -> ShowS)
-> Show TFF_typed_atom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_typed_atom] -> ShowS
$cshowList :: [TFF_typed_atom] -> ShowS
show :: TFF_typed_atom -> String
$cshow :: TFF_typed_atom -> String
showsPrec :: Int -> TFF_typed_atom -> ShowS
$cshowsPrec :: Int -> TFF_typed_atom -> ShowS
Show, Eq TFF_typed_atom
Eq TFF_typed_atom =>
(TFF_typed_atom -> TFF_typed_atom -> Ordering)
-> (TFF_typed_atom -> TFF_typed_atom -> Bool)
-> (TFF_typed_atom -> TFF_typed_atom -> Bool)
-> (TFF_typed_atom -> TFF_typed_atom -> Bool)
-> (TFF_typed_atom -> TFF_typed_atom -> Bool)
-> (TFF_typed_atom -> TFF_typed_atom -> TFF_typed_atom)
-> (TFF_typed_atom -> TFF_typed_atom -> TFF_typed_atom)
-> Ord TFF_typed_atom
TFF_typed_atom -> TFF_typed_atom -> Bool
TFF_typed_atom -> TFF_typed_atom -> Ordering
TFF_typed_atom -> TFF_typed_atom -> TFF_typed_atom
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TFF_typed_atom -> TFF_typed_atom -> TFF_typed_atom
$cmin :: TFF_typed_atom -> TFF_typed_atom -> TFF_typed_atom
max :: TFF_typed_atom -> TFF_typed_atom -> TFF_typed_atom
$cmax :: TFF_typed_atom -> TFF_typed_atom -> TFF_typed_atom
>= :: TFF_typed_atom -> TFF_typed_atom -> Bool
$c>= :: TFF_typed_atom -> TFF_typed_atom -> Bool
> :: TFF_typed_atom -> TFF_typed_atom -> Bool
$c> :: TFF_typed_atom -> TFF_typed_atom -> Bool
<= :: TFF_typed_atom -> TFF_typed_atom -> Bool
$c<= :: TFF_typed_atom -> TFF_typed_atom -> Bool
< :: TFF_typed_atom -> TFF_typed_atom -> Bool
$c< :: TFF_typed_atom -> TFF_typed_atom -> Bool
compare :: TFF_typed_atom -> TFF_typed_atom -> Ordering
$ccompare :: TFF_typed_atom -> TFF_typed_atom -> Ordering
$cp1Ord :: Eq TFF_typed_atom
Ord, TFF_typed_atom -> TFF_typed_atom -> Bool
(TFF_typed_atom -> TFF_typed_atom -> Bool)
-> (TFF_typed_atom -> TFF_typed_atom -> Bool) -> Eq TFF_typed_atom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_typed_atom -> TFF_typed_atom -> Bool
$c/= :: TFF_typed_atom -> TFF_typed_atom -> Bool
== :: TFF_typed_atom -> TFF_typed_atom -> Bool
$c== :: TFF_typed_atom -> TFF_typed_atom -> Bool
Eq, Typeable TFF_typed_atom
Constr
DataType
Typeable TFF_typed_atom =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TFF_typed_atom -> c TFF_typed_atom)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_typed_atom)
-> (TFF_typed_atom -> Constr)
-> (TFF_typed_atom -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_typed_atom))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_typed_atom))
-> ((forall b. Data b => b -> b)
    -> TFF_typed_atom -> TFF_typed_atom)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFF_typed_atom -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_typed_atom -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFF_typed_atom -> m TFF_typed_atom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_typed_atom -> m TFF_typed_atom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_typed_atom -> m TFF_typed_atom)
-> Data TFF_typed_atom
TFF_typed_atom -> Constr
TFF_typed_atom -> DataType
(forall b. Data b => b -> b) -> TFF_typed_atom -> TFF_typed_atom
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_typed_atom -> c TFF_typed_atom
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_typed_atom
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TFF_typed_atom -> u
forall u. (forall d. Data d => d -> u) -> TFF_typed_atom -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_typed_atom
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_typed_atom -> c TFF_typed_atom
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_typed_atom)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_typed_atom)
$cTFFTA_parens :: Constr
$cTFFTA_plain :: Constr
$tTFF_typed_atom :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
gmapMp :: (forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
gmapM :: (forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_typed_atom -> m TFF_typed_atom
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_typed_atom -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFF_typed_atom -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_typed_atom -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFF_typed_atom -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_typed_atom -> r
gmapT :: (forall b. Data b => b -> b) -> TFF_typed_atom -> TFF_typed_atom
$cgmapT :: (forall b. Data b => b -> b) -> TFF_typed_atom -> TFF_typed_atom
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_typed_atom)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_typed_atom)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_typed_atom)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_typed_atom)
dataTypeOf :: TFF_typed_atom -> DataType
$cdataTypeOf :: TFF_typed_atom -> DataType
toConstr :: TFF_typed_atom -> Constr
$ctoConstr :: TFF_typed_atom -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_typed_atom
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_typed_atom
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_typed_atom -> c TFF_typed_atom
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_typed_atom -> c TFF_typed_atom
$cp1Data :: Typeable TFF_typed_atom
Data, Typeable)

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

-- %----See <thf_top_level_type> for commentary.
-- <tff_top_level_type>   ::= <tff_atomic_type> | <tff_mapping_type> |
--                            <tf1_quantified_type> | (<tff_top_level_type>)
data TFF_top_level_type = TFFTLT_atomic TFF_atomic_type
                        | TFFTLT_mapping TFF_mapping_type
                        | TFFTLT_quantified TF1_quantified_type
                        | TFFTLT_parens TFF_top_level_type
                          deriving (Int -> TFF_top_level_type -> ShowS
[TFF_top_level_type] -> ShowS
TFF_top_level_type -> String
(Int -> TFF_top_level_type -> ShowS)
-> (TFF_top_level_type -> String)
-> ([TFF_top_level_type] -> ShowS)
-> Show TFF_top_level_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_top_level_type] -> ShowS
$cshowList :: [TFF_top_level_type] -> ShowS
show :: TFF_top_level_type -> String
$cshow :: TFF_top_level_type -> String
showsPrec :: Int -> TFF_top_level_type -> ShowS
$cshowsPrec :: Int -> TFF_top_level_type -> ShowS
Show, Eq TFF_top_level_type
Eq TFF_top_level_type =>
(TFF_top_level_type -> TFF_top_level_type -> Ordering)
-> (TFF_top_level_type -> TFF_top_level_type -> Bool)
-> (TFF_top_level_type -> TFF_top_level_type -> Bool)
-> (TFF_top_level_type -> TFF_top_level_type -> Bool)
-> (TFF_top_level_type -> TFF_top_level_type -> Bool)
-> (TFF_top_level_type -> TFF_top_level_type -> TFF_top_level_type)
-> (TFF_top_level_type -> TFF_top_level_type -> TFF_top_level_type)
-> Ord TFF_top_level_type
TFF_top_level_type -> TFF_top_level_type -> Bool
TFF_top_level_type -> TFF_top_level_type -> Ordering
TFF_top_level_type -> TFF_top_level_type -> TFF_top_level_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TFF_top_level_type -> TFF_top_level_type -> TFF_top_level_type
$cmin :: TFF_top_level_type -> TFF_top_level_type -> TFF_top_level_type
max :: TFF_top_level_type -> TFF_top_level_type -> TFF_top_level_type
$cmax :: TFF_top_level_type -> TFF_top_level_type -> TFF_top_level_type
>= :: TFF_top_level_type -> TFF_top_level_type -> Bool
$c>= :: TFF_top_level_type -> TFF_top_level_type -> Bool
> :: TFF_top_level_type -> TFF_top_level_type -> Bool
$c> :: TFF_top_level_type -> TFF_top_level_type -> Bool
<= :: TFF_top_level_type -> TFF_top_level_type -> Bool
$c<= :: TFF_top_level_type -> TFF_top_level_type -> Bool
< :: TFF_top_level_type -> TFF_top_level_type -> Bool
$c< :: TFF_top_level_type -> TFF_top_level_type -> Bool
compare :: TFF_top_level_type -> TFF_top_level_type -> Ordering
$ccompare :: TFF_top_level_type -> TFF_top_level_type -> Ordering
$cp1Ord :: Eq TFF_top_level_type
Ord, TFF_top_level_type -> TFF_top_level_type -> Bool
(TFF_top_level_type -> TFF_top_level_type -> Bool)
-> (TFF_top_level_type -> TFF_top_level_type -> Bool)
-> Eq TFF_top_level_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_top_level_type -> TFF_top_level_type -> Bool
$c/= :: TFF_top_level_type -> TFF_top_level_type -> Bool
== :: TFF_top_level_type -> TFF_top_level_type -> Bool
$c== :: TFF_top_level_type -> TFF_top_level_type -> Bool
Eq, Typeable TFF_top_level_type
Constr
DataType
Typeable TFF_top_level_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> TFF_top_level_type
 -> c TFF_top_level_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_top_level_type)
-> (TFF_top_level_type -> Constr)
-> (TFF_top_level_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_top_level_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_top_level_type))
-> ((forall b. Data b => b -> b)
    -> TFF_top_level_type -> TFF_top_level_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFF_top_level_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_top_level_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFF_top_level_type -> m TFF_top_level_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_top_level_type -> m TFF_top_level_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_top_level_type -> m TFF_top_level_type)
-> Data TFF_top_level_type
TFF_top_level_type -> Constr
TFF_top_level_type -> DataType
(forall b. Data b => b -> b)
-> TFF_top_level_type -> TFF_top_level_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_top_level_type
-> c TFF_top_level_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_top_level_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TFF_top_level_type -> u
forall u. (forall d. Data d => d -> u) -> TFF_top_level_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_top_level_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_top_level_type
-> c TFF_top_level_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_top_level_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_top_level_type)
$cTFFTLT_parens :: Constr
$cTFFTLT_quantified :: Constr
$cTFFTLT_mapping :: Constr
$cTFFTLT_atomic :: Constr
$tTFF_top_level_type :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
gmapMp :: (forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
gmapM :: (forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_top_level_type -> m TFF_top_level_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_top_level_type -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFF_top_level_type -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_top_level_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFF_top_level_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_top_level_type -> r
gmapT :: (forall b. Data b => b -> b)
-> TFF_top_level_type -> TFF_top_level_type
$cgmapT :: (forall b. Data b => b -> b)
-> TFF_top_level_type -> TFF_top_level_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_top_level_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_top_level_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_top_level_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_top_level_type)
dataTypeOf :: TFF_top_level_type -> DataType
$cdataTypeOf :: TFF_top_level_type -> DataType
toConstr :: TFF_top_level_type -> Constr
$ctoConstr :: TFF_top_level_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_top_level_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_top_level_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_top_level_type
-> c TFF_top_level_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_top_level_type
-> c TFF_top_level_type
$cp1Data :: Typeable TFF_top_level_type
Data, Typeable)

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

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

-- <tff_unitary_type>     ::= <tff_atomic_type> | (<tff_xprod_type>)
data TFF_unitary_type = TFFUT_atomic TFF_atomic_type
                      | TFFUT_xprod TFF_xprod_type
                        deriving (Int -> TFF_unitary_type -> ShowS
[TFF_unitary_type] -> ShowS
TFF_unitary_type -> String
(Int -> TFF_unitary_type -> ShowS)
-> (TFF_unitary_type -> String)
-> ([TFF_unitary_type] -> ShowS)
-> Show TFF_unitary_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_unitary_type] -> ShowS
$cshowList :: [TFF_unitary_type] -> ShowS
show :: TFF_unitary_type -> String
$cshow :: TFF_unitary_type -> String
showsPrec :: Int -> TFF_unitary_type -> ShowS
$cshowsPrec :: Int -> TFF_unitary_type -> ShowS
Show, Eq TFF_unitary_type
Eq TFF_unitary_type =>
(TFF_unitary_type -> TFF_unitary_type -> Ordering)
-> (TFF_unitary_type -> TFF_unitary_type -> Bool)
-> (TFF_unitary_type -> TFF_unitary_type -> Bool)
-> (TFF_unitary_type -> TFF_unitary_type -> Bool)
-> (TFF_unitary_type -> TFF_unitary_type -> Bool)
-> (TFF_unitary_type -> TFF_unitary_type -> TFF_unitary_type)
-> (TFF_unitary_type -> TFF_unitary_type -> TFF_unitary_type)
-> Ord TFF_unitary_type
TFF_unitary_type -> TFF_unitary_type -> Bool
TFF_unitary_type -> TFF_unitary_type -> Ordering
TFF_unitary_type -> TFF_unitary_type -> TFF_unitary_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TFF_unitary_type -> TFF_unitary_type -> TFF_unitary_type
$cmin :: TFF_unitary_type -> TFF_unitary_type -> TFF_unitary_type
max :: TFF_unitary_type -> TFF_unitary_type -> TFF_unitary_type
$cmax :: TFF_unitary_type -> TFF_unitary_type -> TFF_unitary_type
>= :: TFF_unitary_type -> TFF_unitary_type -> Bool
$c>= :: TFF_unitary_type -> TFF_unitary_type -> Bool
> :: TFF_unitary_type -> TFF_unitary_type -> Bool
$c> :: TFF_unitary_type -> TFF_unitary_type -> Bool
<= :: TFF_unitary_type -> TFF_unitary_type -> Bool
$c<= :: TFF_unitary_type -> TFF_unitary_type -> Bool
< :: TFF_unitary_type -> TFF_unitary_type -> Bool
$c< :: TFF_unitary_type -> TFF_unitary_type -> Bool
compare :: TFF_unitary_type -> TFF_unitary_type -> Ordering
$ccompare :: TFF_unitary_type -> TFF_unitary_type -> Ordering
$cp1Ord :: Eq TFF_unitary_type
Ord, TFF_unitary_type -> TFF_unitary_type -> Bool
(TFF_unitary_type -> TFF_unitary_type -> Bool)
-> (TFF_unitary_type -> TFF_unitary_type -> Bool)
-> Eq TFF_unitary_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_unitary_type -> TFF_unitary_type -> Bool
$c/= :: TFF_unitary_type -> TFF_unitary_type -> Bool
== :: TFF_unitary_type -> TFF_unitary_type -> Bool
$c== :: TFF_unitary_type -> TFF_unitary_type -> Bool
Eq, Typeable TFF_unitary_type
Constr
DataType
Typeable TFF_unitary_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TFF_unitary_type -> c TFF_unitary_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_unitary_type)
-> (TFF_unitary_type -> Constr)
-> (TFF_unitary_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_unitary_type))
-> ((forall b. Data b => b -> b)
    -> TFF_unitary_type -> TFF_unitary_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFF_unitary_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_unitary_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFF_unitary_type -> m TFF_unitary_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_unitary_type -> m TFF_unitary_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_unitary_type -> m TFF_unitary_type)
-> Data TFF_unitary_type
TFF_unitary_type -> Constr
TFF_unitary_type -> DataType
(forall b. Data b => b -> b)
-> TFF_unitary_type -> TFF_unitary_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_unitary_type -> c TFF_unitary_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TFF_unitary_type -> u
forall u. (forall d. Data d => d -> u) -> TFF_unitary_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_unitary_type -> c TFF_unitary_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_unitary_type)
$cTFFUT_xprod :: Constr
$cTFFUT_atomic :: Constr
$tTFF_unitary_type :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
gmapMp :: (forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
gmapM :: (forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_unitary_type -> m TFF_unitary_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_unitary_type -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFF_unitary_type -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_unitary_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFF_unitary_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_unitary_type -> r
gmapT :: (forall b. Data b => b -> b)
-> TFF_unitary_type -> TFF_unitary_type
$cgmapT :: (forall b. Data b => b -> b)
-> TFF_unitary_type -> TFF_unitary_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_unitary_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_unitary_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_unitary_type)
dataTypeOf :: TFF_unitary_type -> DataType
$cdataTypeOf :: TFF_unitary_type -> DataType
toConstr :: TFF_unitary_type -> Constr
$ctoConstr :: TFF_unitary_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_unitary_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_unitary_type -> c TFF_unitary_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_unitary_type -> c TFF_unitary_type
$cp1Data :: Typeable TFF_unitary_type
Data, Typeable)
-- <tff_atomic_type>      ::= <type_constant> | <defined_type> |
--                            <type_functor>(<tff_type_arguments>) | <variable>
data TFF_atomic_type = TFFAT_constant Type_constant
                     | TFFAT_defined Defined_type
                     | TFFAT_functor Type_functor TFF_type_arguments
                     | TFFAT_variable Variable
                       deriving (Int -> TFF_atomic_type -> ShowS
[TFF_atomic_type] -> ShowS
TFF_atomic_type -> String
(Int -> TFF_atomic_type -> ShowS)
-> (TFF_atomic_type -> String)
-> ([TFF_atomic_type] -> ShowS)
-> Show TFF_atomic_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_atomic_type] -> ShowS
$cshowList :: [TFF_atomic_type] -> ShowS
show :: TFF_atomic_type -> String
$cshow :: TFF_atomic_type -> String
showsPrec :: Int -> TFF_atomic_type -> ShowS
$cshowsPrec :: Int -> TFF_atomic_type -> ShowS
Show, Eq TFF_atomic_type
Eq TFF_atomic_type =>
(TFF_atomic_type -> TFF_atomic_type -> Ordering)
-> (TFF_atomic_type -> TFF_atomic_type -> Bool)
-> (TFF_atomic_type -> TFF_atomic_type -> Bool)
-> (TFF_atomic_type -> TFF_atomic_type -> Bool)
-> (TFF_atomic_type -> TFF_atomic_type -> Bool)
-> (TFF_atomic_type -> TFF_atomic_type -> TFF_atomic_type)
-> (TFF_atomic_type -> TFF_atomic_type -> TFF_atomic_type)
-> Ord TFF_atomic_type
TFF_atomic_type -> TFF_atomic_type -> Bool
TFF_atomic_type -> TFF_atomic_type -> Ordering
TFF_atomic_type -> TFF_atomic_type -> TFF_atomic_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TFF_atomic_type -> TFF_atomic_type -> TFF_atomic_type
$cmin :: TFF_atomic_type -> TFF_atomic_type -> TFF_atomic_type
max :: TFF_atomic_type -> TFF_atomic_type -> TFF_atomic_type
$cmax :: TFF_atomic_type -> TFF_atomic_type -> TFF_atomic_type
>= :: TFF_atomic_type -> TFF_atomic_type -> Bool
$c>= :: TFF_atomic_type -> TFF_atomic_type -> Bool
> :: TFF_atomic_type -> TFF_atomic_type -> Bool
$c> :: TFF_atomic_type -> TFF_atomic_type -> Bool
<= :: TFF_atomic_type -> TFF_atomic_type -> Bool
$c<= :: TFF_atomic_type -> TFF_atomic_type -> Bool
< :: TFF_atomic_type -> TFF_atomic_type -> Bool
$c< :: TFF_atomic_type -> TFF_atomic_type -> Bool
compare :: TFF_atomic_type -> TFF_atomic_type -> Ordering
$ccompare :: TFF_atomic_type -> TFF_atomic_type -> Ordering
$cp1Ord :: Eq TFF_atomic_type
Ord, TFF_atomic_type -> TFF_atomic_type -> Bool
(TFF_atomic_type -> TFF_atomic_type -> Bool)
-> (TFF_atomic_type -> TFF_atomic_type -> Bool)
-> Eq TFF_atomic_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_atomic_type -> TFF_atomic_type -> Bool
$c/= :: TFF_atomic_type -> TFF_atomic_type -> Bool
== :: TFF_atomic_type -> TFF_atomic_type -> Bool
$c== :: TFF_atomic_type -> TFF_atomic_type -> Bool
Eq, Typeable TFF_atomic_type
Constr
DataType
Typeable TFF_atomic_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TFF_atomic_type -> c TFF_atomic_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_atomic_type)
-> (TFF_atomic_type -> Constr)
-> (TFF_atomic_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_atomic_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_atomic_type))
-> ((forall b. Data b => b -> b)
    -> TFF_atomic_type -> TFF_atomic_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFF_atomic_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_atomic_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFF_atomic_type -> m TFF_atomic_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_atomic_type -> m TFF_atomic_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_atomic_type -> m TFF_atomic_type)
-> Data TFF_atomic_type
TFF_atomic_type -> Constr
TFF_atomic_type -> DataType
(forall b. Data b => b -> b) -> TFF_atomic_type -> TFF_atomic_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_atomic_type -> c TFF_atomic_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_atomic_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TFF_atomic_type -> u
forall u. (forall d. Data d => d -> u) -> TFF_atomic_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_atomic_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_atomic_type -> c TFF_atomic_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_atomic_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_atomic_type)
$cTFFAT_variable :: Constr
$cTFFAT_functor :: Constr
$cTFFAT_defined :: Constr
$cTFFAT_constant :: Constr
$tTFF_atomic_type :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
gmapMp :: (forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
gmapM :: (forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_atomic_type -> m TFF_atomic_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_atomic_type -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFF_atomic_type -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_atomic_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFF_atomic_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_atomic_type -> r
gmapT :: (forall b. Data b => b -> b) -> TFF_atomic_type -> TFF_atomic_type
$cgmapT :: (forall b. Data b => b -> b) -> TFF_atomic_type -> TFF_atomic_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_atomic_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_atomic_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_atomic_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_atomic_type)
dataTypeOf :: TFF_atomic_type -> DataType
$cdataTypeOf :: TFF_atomic_type -> DataType
toConstr :: TFF_atomic_type -> Constr
$ctoConstr :: TFF_atomic_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_atomic_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_atomic_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_atomic_type -> c TFF_atomic_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_atomic_type -> c TFF_atomic_type
$cp1Data :: Typeable TFF_atomic_type
Data, Typeable)

-- <tff_type_arguments>   ::= <tff_atomic_type> |
--                            <tff_atomic_type>,<tff_type_arguments>
type TFF_type_arguments = [TFF_atomic_type]

-- %----For consistency with <thf_unitary_type> (the analogue in thf),
-- %----<tff_atomic_type> should also allow (<tff_atomic_type>), but that causes
-- %----ambiguity.
-- <tff_mapping_type>     ::= <tff_unitary_type> <arrow> <tff_atomic_type>
data TFF_mapping_type = TFF_mapping_type TFF_unitary_type TFF_atomic_type
                        deriving (Int -> TFF_mapping_type -> ShowS
[TFF_mapping_type] -> ShowS
TFF_mapping_type -> String
(Int -> TFF_mapping_type -> ShowS)
-> (TFF_mapping_type -> String)
-> ([TFF_mapping_type] -> ShowS)
-> Show TFF_mapping_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_mapping_type] -> ShowS
$cshowList :: [TFF_mapping_type] -> ShowS
show :: TFF_mapping_type -> String
$cshow :: TFF_mapping_type -> String
showsPrec :: Int -> TFF_mapping_type -> ShowS
$cshowsPrec :: Int -> TFF_mapping_type -> ShowS
Show, Eq TFF_mapping_type
Eq TFF_mapping_type =>
(TFF_mapping_type -> TFF_mapping_type -> Ordering)
-> (TFF_mapping_type -> TFF_mapping_type -> Bool)
-> (TFF_mapping_type -> TFF_mapping_type -> Bool)
-> (TFF_mapping_type -> TFF_mapping_type -> Bool)
-> (TFF_mapping_type -> TFF_mapping_type -> Bool)
-> (TFF_mapping_type -> TFF_mapping_type -> TFF_mapping_type)
-> (TFF_mapping_type -> TFF_mapping_type -> TFF_mapping_type)
-> Ord TFF_mapping_type
TFF_mapping_type -> TFF_mapping_type -> Bool
TFF_mapping_type -> TFF_mapping_type -> Ordering
TFF_mapping_type -> TFF_mapping_type -> TFF_mapping_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TFF_mapping_type -> TFF_mapping_type -> TFF_mapping_type
$cmin :: TFF_mapping_type -> TFF_mapping_type -> TFF_mapping_type
max :: TFF_mapping_type -> TFF_mapping_type -> TFF_mapping_type
$cmax :: TFF_mapping_type -> TFF_mapping_type -> TFF_mapping_type
>= :: TFF_mapping_type -> TFF_mapping_type -> Bool
$c>= :: TFF_mapping_type -> TFF_mapping_type -> Bool
> :: TFF_mapping_type -> TFF_mapping_type -> Bool
$c> :: TFF_mapping_type -> TFF_mapping_type -> Bool
<= :: TFF_mapping_type -> TFF_mapping_type -> Bool
$c<= :: TFF_mapping_type -> TFF_mapping_type -> Bool
< :: TFF_mapping_type -> TFF_mapping_type -> Bool
$c< :: TFF_mapping_type -> TFF_mapping_type -> Bool
compare :: TFF_mapping_type -> TFF_mapping_type -> Ordering
$ccompare :: TFF_mapping_type -> TFF_mapping_type -> Ordering
$cp1Ord :: Eq TFF_mapping_type
Ord, TFF_mapping_type -> TFF_mapping_type -> Bool
(TFF_mapping_type -> TFF_mapping_type -> Bool)
-> (TFF_mapping_type -> TFF_mapping_type -> Bool)
-> Eq TFF_mapping_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_mapping_type -> TFF_mapping_type -> Bool
$c/= :: TFF_mapping_type -> TFF_mapping_type -> Bool
== :: TFF_mapping_type -> TFF_mapping_type -> Bool
$c== :: TFF_mapping_type -> TFF_mapping_type -> Bool
Eq, Typeable TFF_mapping_type
Constr
DataType
Typeable TFF_mapping_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TFF_mapping_type -> c TFF_mapping_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_mapping_type)
-> (TFF_mapping_type -> Constr)
-> (TFF_mapping_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_mapping_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_mapping_type))
-> ((forall b. Data b => b -> b)
    -> TFF_mapping_type -> TFF_mapping_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFF_mapping_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_mapping_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFF_mapping_type -> m TFF_mapping_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_mapping_type -> m TFF_mapping_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_mapping_type -> m TFF_mapping_type)
-> Data TFF_mapping_type
TFF_mapping_type -> Constr
TFF_mapping_type -> DataType
(forall b. Data b => b -> b)
-> TFF_mapping_type -> TFF_mapping_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_mapping_type -> c TFF_mapping_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_mapping_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TFF_mapping_type -> u
forall u. (forall d. Data d => d -> u) -> TFF_mapping_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_mapping_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_mapping_type -> c TFF_mapping_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_mapping_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_mapping_type)
$cTFF_mapping_type :: Constr
$tTFF_mapping_type :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
gmapMp :: (forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
gmapM :: (forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_mapping_type -> m TFF_mapping_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_mapping_type -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFF_mapping_type -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_mapping_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFF_mapping_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_mapping_type -> r
gmapT :: (forall b. Data b => b -> b)
-> TFF_mapping_type -> TFF_mapping_type
$cgmapT :: (forall b. Data b => b -> b)
-> TFF_mapping_type -> TFF_mapping_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_mapping_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_mapping_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_mapping_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_mapping_type)
dataTypeOf :: TFF_mapping_type -> DataType
$cdataTypeOf :: TFF_mapping_type -> DataType
toConstr :: TFF_mapping_type -> Constr
$ctoConstr :: TFF_mapping_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_mapping_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_mapping_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_mapping_type -> c TFF_mapping_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_mapping_type -> c TFF_mapping_type
$cp1Data :: Typeable TFF_mapping_type
Data, Typeable)

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


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

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

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


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

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

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

-- %----Only some binary connectives are associative
-- %----There's no precedence among binary connectives
-- <fof_binary_nonassoc>  ::= <fof_unitary_formula> <binary_connective>
--                            <fof_unitary_formula>
data FOF_binary_nonassoc = FOF_binary_nonassoc Binary_connective FOF_unitary_formula FOF_unitary_formula
                           deriving (Int -> FOF_binary_nonassoc -> ShowS
[FOF_binary_nonassoc] -> ShowS
FOF_binary_nonassoc -> String
(Int -> FOF_binary_nonassoc -> ShowS)
-> (FOF_binary_nonassoc -> String)
-> ([FOF_binary_nonassoc] -> ShowS)
-> Show FOF_binary_nonassoc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_binary_nonassoc] -> ShowS
$cshowList :: [FOF_binary_nonassoc] -> ShowS
show :: FOF_binary_nonassoc -> String
$cshow :: FOF_binary_nonassoc -> String
showsPrec :: Int -> FOF_binary_nonassoc -> ShowS
$cshowsPrec :: Int -> FOF_binary_nonassoc -> ShowS
Show, Eq FOF_binary_nonassoc
Eq FOF_binary_nonassoc =>
(FOF_binary_nonassoc -> FOF_binary_nonassoc -> Ordering)
-> (FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool)
-> (FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool)
-> (FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool)
-> (FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool)
-> (FOF_binary_nonassoc
    -> FOF_binary_nonassoc -> FOF_binary_nonassoc)
-> (FOF_binary_nonassoc
    -> FOF_binary_nonassoc -> FOF_binary_nonassoc)
-> Ord FOF_binary_nonassoc
FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
FOF_binary_nonassoc -> FOF_binary_nonassoc -> Ordering
FOF_binary_nonassoc -> FOF_binary_nonassoc -> FOF_binary_nonassoc
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 :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> FOF_binary_nonassoc
$cmin :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> FOF_binary_nonassoc
max :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> FOF_binary_nonassoc
$cmax :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> FOF_binary_nonassoc
>= :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
$c>= :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
> :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
$c> :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
<= :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
$c<= :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
< :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
$c< :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
compare :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Ordering
$ccompare :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Ordering
$cp1Ord :: Eq FOF_binary_nonassoc
Ord, FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
(FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool)
-> (FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool)
-> Eq FOF_binary_nonassoc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
$c/= :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
== :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
$c== :: FOF_binary_nonassoc -> FOF_binary_nonassoc -> Bool
Eq, Typeable FOF_binary_nonassoc
Constr
DataType
Typeable FOF_binary_nonassoc =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> FOF_binary_nonassoc
 -> c FOF_binary_nonassoc)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_binary_nonassoc)
-> (FOF_binary_nonassoc -> Constr)
-> (FOF_binary_nonassoc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_binary_nonassoc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_binary_nonassoc))
-> ((forall b. Data b => b -> b)
    -> FOF_binary_nonassoc -> FOF_binary_nonassoc)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_binary_nonassoc -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FOF_binary_nonassoc -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_binary_nonassoc -> m FOF_binary_nonassoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_binary_nonassoc -> m FOF_binary_nonassoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_binary_nonassoc -> m FOF_binary_nonassoc)
-> Data FOF_binary_nonassoc
FOF_binary_nonassoc -> Constr
FOF_binary_nonassoc -> DataType
(forall b. Data b => b -> b)
-> FOF_binary_nonassoc -> FOF_binary_nonassoc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_binary_nonassoc
-> c FOF_binary_nonassoc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_nonassoc
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) -> FOF_binary_nonassoc -> u
forall u.
(forall d. Data d => d -> u) -> FOF_binary_nonassoc -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_nonassoc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_binary_nonassoc
-> c FOF_binary_nonassoc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_binary_nonassoc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_binary_nonassoc)
$cFOF_binary_nonassoc :: Constr
$tFOF_binary_nonassoc :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
gmapM :: (forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_binary_nonassoc -> m FOF_binary_nonassoc
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_binary_nonassoc -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FOF_binary_nonassoc -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_binary_nonassoc -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> FOF_binary_nonassoc -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_nonassoc -> r
gmapT :: (forall b. Data b => b -> b)
-> FOF_binary_nonassoc -> FOF_binary_nonassoc
$cgmapT :: (forall b. Data b => b -> b)
-> FOF_binary_nonassoc -> FOF_binary_nonassoc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_binary_nonassoc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_binary_nonassoc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_binary_nonassoc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_binary_nonassoc)
dataTypeOf :: FOF_binary_nonassoc -> DataType
$cdataTypeOf :: FOF_binary_nonassoc -> DataType
toConstr :: FOF_binary_nonassoc -> Constr
$ctoConstr :: FOF_binary_nonassoc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_nonassoc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_nonassoc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_binary_nonassoc
-> c FOF_binary_nonassoc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_binary_nonassoc
-> c FOF_binary_nonassoc
$cp1Data :: Typeable FOF_binary_nonassoc
Data, Typeable)

-- %----Associative connectives & and | are in <binary_assoc>
-- <fof_binary_assoc>     ::= <fof_or_formula> | <fof_and_formula>
data FOF_binary_assoc = FOFBA_or FOF_or_formula
                      | FOFBA_and FOF_and_formula
                        deriving (Int -> FOF_binary_assoc -> ShowS
[FOF_binary_assoc] -> ShowS
FOF_binary_assoc -> String
(Int -> FOF_binary_assoc -> ShowS)
-> (FOF_binary_assoc -> String)
-> ([FOF_binary_assoc] -> ShowS)
-> Show FOF_binary_assoc
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_binary_assoc] -> ShowS
$cshowList :: [FOF_binary_assoc] -> ShowS
show :: FOF_binary_assoc -> String
$cshow :: FOF_binary_assoc -> String
showsPrec :: Int -> FOF_binary_assoc -> ShowS
$cshowsPrec :: Int -> FOF_binary_assoc -> ShowS
Show, Eq FOF_binary_assoc
Eq FOF_binary_assoc =>
(FOF_binary_assoc -> FOF_binary_assoc -> Ordering)
-> (FOF_binary_assoc -> FOF_binary_assoc -> Bool)
-> (FOF_binary_assoc -> FOF_binary_assoc -> Bool)
-> (FOF_binary_assoc -> FOF_binary_assoc -> Bool)
-> (FOF_binary_assoc -> FOF_binary_assoc -> Bool)
-> (FOF_binary_assoc -> FOF_binary_assoc -> FOF_binary_assoc)
-> (FOF_binary_assoc -> FOF_binary_assoc -> FOF_binary_assoc)
-> Ord FOF_binary_assoc
FOF_binary_assoc -> FOF_binary_assoc -> Bool
FOF_binary_assoc -> FOF_binary_assoc -> Ordering
FOF_binary_assoc -> FOF_binary_assoc -> FOF_binary_assoc
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 :: FOF_binary_assoc -> FOF_binary_assoc -> FOF_binary_assoc
$cmin :: FOF_binary_assoc -> FOF_binary_assoc -> FOF_binary_assoc
max :: FOF_binary_assoc -> FOF_binary_assoc -> FOF_binary_assoc
$cmax :: FOF_binary_assoc -> FOF_binary_assoc -> FOF_binary_assoc
>= :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
$c>= :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
> :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
$c> :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
<= :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
$c<= :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
< :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
$c< :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
compare :: FOF_binary_assoc -> FOF_binary_assoc -> Ordering
$ccompare :: FOF_binary_assoc -> FOF_binary_assoc -> Ordering
$cp1Ord :: Eq FOF_binary_assoc
Ord, FOF_binary_assoc -> FOF_binary_assoc -> Bool
(FOF_binary_assoc -> FOF_binary_assoc -> Bool)
-> (FOF_binary_assoc -> FOF_binary_assoc -> Bool)
-> Eq FOF_binary_assoc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
$c/= :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
== :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
$c== :: FOF_binary_assoc -> FOF_binary_assoc -> Bool
Eq, Typeable FOF_binary_assoc
Constr
DataType
Typeable FOF_binary_assoc =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FOF_binary_assoc -> c FOF_binary_assoc)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_binary_assoc)
-> (FOF_binary_assoc -> Constr)
-> (FOF_binary_assoc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_binary_assoc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_binary_assoc))
-> ((forall b. Data b => b -> b)
    -> FOF_binary_assoc -> FOF_binary_assoc)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_binary_assoc -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FOF_binary_assoc -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_binary_assoc -> m FOF_binary_assoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_binary_assoc -> m FOF_binary_assoc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_binary_assoc -> m FOF_binary_assoc)
-> Data FOF_binary_assoc
FOF_binary_assoc -> Constr
FOF_binary_assoc -> DataType
(forall b. Data b => b -> b)
-> FOF_binary_assoc -> FOF_binary_assoc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_binary_assoc -> c FOF_binary_assoc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_assoc
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) -> FOF_binary_assoc -> u
forall u. (forall d. Data d => d -> u) -> FOF_binary_assoc -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_assoc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_binary_assoc -> c FOF_binary_assoc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_binary_assoc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_binary_assoc)
$cFOFBA_and :: Constr
$cFOFBA_or :: Constr
$tFOF_binary_assoc :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
gmapM :: (forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_binary_assoc -> m FOF_binary_assoc
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_binary_assoc -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FOF_binary_assoc -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_binary_assoc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FOF_binary_assoc -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_binary_assoc -> r
gmapT :: (forall b. Data b => b -> b)
-> FOF_binary_assoc -> FOF_binary_assoc
$cgmapT :: (forall b. Data b => b -> b)
-> FOF_binary_assoc -> FOF_binary_assoc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_binary_assoc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_binary_assoc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_binary_assoc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_binary_assoc)
dataTypeOf :: FOF_binary_assoc -> DataType
$cdataTypeOf :: FOF_binary_assoc -> DataType
toConstr :: FOF_binary_assoc -> Constr
$ctoConstr :: FOF_binary_assoc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_assoc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_binary_assoc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_binary_assoc -> c FOF_binary_assoc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_binary_assoc -> c FOF_binary_assoc
$cp1Data :: Typeable FOF_binary_assoc
Data, Typeable)

-- <fof_or_formula>       ::= <fof_unitary_formula> <vline> <fof_unitary_formula> |
--                            <fof_or_formula> <vline> <fof_unitary_formula>
type FOF_or_formula = [FOF_unitary_formula]

-- <fof_and_formula>      ::= <fof_unitary_formula> & <fof_unitary_formula> |
--                            <fof_and_formula> & <fof_unitary_formula>
type FOF_and_formula = [FOF_unitary_formula]

-- %----<fof_unitary_formula> are in ()s or do not have a <binary_connective> at
-- %----the top level.
-- <fof_unitary_formula>  ::= <fof_quantified_formula> | <fof_unary_formula> |
--                            <fof_atomic_formula> | (<fof_logic_formula>)
data FOF_unitary_formula = FOFUF_quantified FOF_quantified_formula
                         | FOFUF_unary FOF_unary_formula
                         | FOFUF_atomic FOF_atomic_formula
                         | FOFUF_logic FOF_logic_formula
                           deriving (Int -> FOF_unitary_formula -> ShowS
[FOF_unitary_formula] -> ShowS
FOF_unitary_formula -> String
(Int -> FOF_unitary_formula -> ShowS)
-> (FOF_unitary_formula -> String)
-> ([FOF_unitary_formula] -> ShowS)
-> Show FOF_unitary_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_unitary_formula] -> ShowS
$cshowList :: [FOF_unitary_formula] -> ShowS
show :: FOF_unitary_formula -> String
$cshow :: FOF_unitary_formula -> String
showsPrec :: Int -> FOF_unitary_formula -> ShowS
$cshowsPrec :: Int -> FOF_unitary_formula -> ShowS
Show, Eq FOF_unitary_formula
Eq FOF_unitary_formula =>
(FOF_unitary_formula -> FOF_unitary_formula -> Ordering)
-> (FOF_unitary_formula -> FOF_unitary_formula -> Bool)
-> (FOF_unitary_formula -> FOF_unitary_formula -> Bool)
-> (FOF_unitary_formula -> FOF_unitary_formula -> Bool)
-> (FOF_unitary_formula -> FOF_unitary_formula -> Bool)
-> (FOF_unitary_formula
    -> FOF_unitary_formula -> FOF_unitary_formula)
-> (FOF_unitary_formula
    -> FOF_unitary_formula -> FOF_unitary_formula)
-> Ord FOF_unitary_formula
FOF_unitary_formula -> FOF_unitary_formula -> Bool
FOF_unitary_formula -> FOF_unitary_formula -> Ordering
FOF_unitary_formula -> FOF_unitary_formula -> FOF_unitary_formula
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 :: FOF_unitary_formula -> FOF_unitary_formula -> FOF_unitary_formula
$cmin :: FOF_unitary_formula -> FOF_unitary_formula -> FOF_unitary_formula
max :: FOF_unitary_formula -> FOF_unitary_formula -> FOF_unitary_formula
$cmax :: FOF_unitary_formula -> FOF_unitary_formula -> FOF_unitary_formula
>= :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
$c>= :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
> :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
$c> :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
<= :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
$c<= :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
< :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
$c< :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
compare :: FOF_unitary_formula -> FOF_unitary_formula -> Ordering
$ccompare :: FOF_unitary_formula -> FOF_unitary_formula -> Ordering
$cp1Ord :: Eq FOF_unitary_formula
Ord, FOF_unitary_formula -> FOF_unitary_formula -> Bool
(FOF_unitary_formula -> FOF_unitary_formula -> Bool)
-> (FOF_unitary_formula -> FOF_unitary_formula -> Bool)
-> Eq FOF_unitary_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
$c/= :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
== :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
$c== :: FOF_unitary_formula -> FOF_unitary_formula -> Bool
Eq, Typeable FOF_unitary_formula
Constr
DataType
Typeable FOF_unitary_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> FOF_unitary_formula
 -> c FOF_unitary_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_unitary_formula)
-> (FOF_unitary_formula -> Constr)
-> (FOF_unitary_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_unitary_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_unitary_formula))
-> ((forall b. Data b => b -> b)
    -> FOF_unitary_formula -> FOF_unitary_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_unitary_formula -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FOF_unitary_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_unitary_formula -> m FOF_unitary_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_unitary_formula -> m FOF_unitary_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_unitary_formula -> m FOF_unitary_formula)
-> Data FOF_unitary_formula
FOF_unitary_formula -> Constr
FOF_unitary_formula -> DataType
(forall b. Data b => b -> b)
-> FOF_unitary_formula -> FOF_unitary_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_unitary_formula
-> c FOF_unitary_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_unitary_formula
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) -> FOF_unitary_formula -> u
forall u.
(forall d. Data d => d -> u) -> FOF_unitary_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_unitary_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_unitary_formula
-> c FOF_unitary_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_unitary_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_unitary_formula)
$cFOFUF_logic :: Constr
$cFOFUF_atomic :: Constr
$cFOFUF_unary :: Constr
$cFOFUF_quantified :: Constr
$tFOF_unitary_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
gmapM :: (forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_unitary_formula -> m FOF_unitary_formula
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_unitary_formula -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FOF_unitary_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_unitary_formula -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> FOF_unitary_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_unitary_formula -> r
gmapT :: (forall b. Data b => b -> b)
-> FOF_unitary_formula -> FOF_unitary_formula
$cgmapT :: (forall b. Data b => b -> b)
-> FOF_unitary_formula -> FOF_unitary_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_unitary_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_unitary_formula)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_unitary_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_unitary_formula)
dataTypeOf :: FOF_unitary_formula -> DataType
$cdataTypeOf :: FOF_unitary_formula -> DataType
toConstr :: FOF_unitary_formula -> Constr
$ctoConstr :: FOF_unitary_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_unitary_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_unitary_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_unitary_formula
-> c FOF_unitary_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_unitary_formula
-> c FOF_unitary_formula
$cp1Data :: Typeable FOF_unitary_formula
Data, Typeable)

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

-- <fof_variable_list>    ::= <variable> | <variable>,<fof_variable_list>
type FOF_variable_list = [Variable]

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

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

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

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

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

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

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

-- %----System terms have system specific interpretations
-- <fof_system_atomic_formula> ::= <fof_system_term>
-- %----<fof_system_atomic_formula>s are used for evaluable predicates that are
-- %----available in particular tools. The predicate names are not controlled
-- %----by the TPTP syntax, so use with due care. The same is true for
-- %----<fof_system_term>s.
newtype FOF_system_atomic_formula = FOF_system_atomic_formula FOF_system_term
                                    deriving (Int -> FOF_system_atomic_formula -> ShowS
[FOF_system_atomic_formula] -> ShowS
FOF_system_atomic_formula -> String
(Int -> FOF_system_atomic_formula -> ShowS)
-> (FOF_system_atomic_formula -> String)
-> ([FOF_system_atomic_formula] -> ShowS)
-> Show FOF_system_atomic_formula
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_system_atomic_formula] -> ShowS
$cshowList :: [FOF_system_atomic_formula] -> ShowS
show :: FOF_system_atomic_formula -> String
$cshow :: FOF_system_atomic_formula -> String
showsPrec :: Int -> FOF_system_atomic_formula -> ShowS
$cshowsPrec :: Int -> FOF_system_atomic_formula -> ShowS
Show, Eq FOF_system_atomic_formula
Eq FOF_system_atomic_formula =>
(FOF_system_atomic_formula
 -> FOF_system_atomic_formula -> Ordering)
-> (FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool)
-> (FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool)
-> (FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool)
-> (FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool)
-> (FOF_system_atomic_formula
    -> FOF_system_atomic_formula -> FOF_system_atomic_formula)
-> (FOF_system_atomic_formula
    -> FOF_system_atomic_formula -> FOF_system_atomic_formula)
-> Ord FOF_system_atomic_formula
FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
FOF_system_atomic_formula -> FOF_system_atomic_formula -> Ordering
FOF_system_atomic_formula
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
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 :: FOF_system_atomic_formula
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
$cmin :: FOF_system_atomic_formula
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
max :: FOF_system_atomic_formula
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
$cmax :: FOF_system_atomic_formula
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
>= :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
$c>= :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
> :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
$c> :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
<= :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
$c<= :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
< :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
$c< :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
compare :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Ordering
$ccompare :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Ordering
$cp1Ord :: Eq FOF_system_atomic_formula
Ord, FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
(FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool)
-> (FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool)
-> Eq FOF_system_atomic_formula
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
$c/= :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
== :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
$c== :: FOF_system_atomic_formula -> FOF_system_atomic_formula -> Bool
Eq, Typeable FOF_system_atomic_formula
Constr
DataType
Typeable FOF_system_atomic_formula =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> FOF_system_atomic_formula
 -> c FOF_system_atomic_formula)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_system_atomic_formula)
-> (FOF_system_atomic_formula -> Constr)
-> (FOF_system_atomic_formula -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c FOF_system_atomic_formula))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_system_atomic_formula))
-> ((forall b. Data b => b -> b)
    -> FOF_system_atomic_formula -> FOF_system_atomic_formula)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> FOF_system_atomic_formula
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> FOF_system_atomic_formula
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_system_atomic_formula -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> FOF_system_atomic_formula -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_system_atomic_formula -> m FOF_system_atomic_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_system_atomic_formula -> m FOF_system_atomic_formula)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_system_atomic_formula -> m FOF_system_atomic_formula)
-> Data FOF_system_atomic_formula
FOF_system_atomic_formula -> Constr
FOF_system_atomic_formula -> DataType
(forall b. Data b => b -> b)
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_system_atomic_formula
-> c FOF_system_atomic_formula
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_atomic_formula
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) -> FOF_system_atomic_formula -> u
forall u.
(forall d. Data d => d -> u) -> FOF_system_atomic_formula -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_system_atomic_formula
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_system_atomic_formula
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_atomic_formula
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_system_atomic_formula
-> c FOF_system_atomic_formula
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c FOF_system_atomic_formula)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_system_atomic_formula)
$cFOF_system_atomic_formula :: Constr
$tFOF_system_atomic_formula :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
gmapM :: (forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_system_atomic_formula -> m FOF_system_atomic_formula
gmapQi :: Int
-> (forall d. Data d => d -> u) -> FOF_system_atomic_formula -> u
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> FOF_system_atomic_formula -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_system_atomic_formula -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> FOF_system_atomic_formula -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_system_atomic_formula
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_system_atomic_formula
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_system_atomic_formula
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_system_atomic_formula
-> r
gmapT :: (forall b. Data b => b -> b)
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
$cgmapT :: (forall b. Data b => b -> b)
-> FOF_system_atomic_formula -> FOF_system_atomic_formula
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_system_atomic_formula)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_system_atomic_formula)
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c FOF_system_atomic_formula)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c FOF_system_atomic_formula)
dataTypeOf :: FOF_system_atomic_formula -> DataType
$cdataTypeOf :: FOF_system_atomic_formula -> DataType
toConstr :: FOF_system_atomic_formula -> Constr
$ctoConstr :: FOF_system_atomic_formula -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_atomic_formula
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_atomic_formula
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_system_atomic_formula
-> c FOF_system_atomic_formula
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_system_atomic_formula
-> c FOF_system_atomic_formula
$cp1Data :: Typeable FOF_system_atomic_formula
Data, Typeable)

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

-- %----Defined terms have TPTP specific interpretations
-- <fof_defined_term>     ::= <defined_term> | <fof_defined_atomic_term>
data FOF_defined_term = FOFDT_term Defined_term
                      | FOFDT_atomic FOF_defined_atomic_term
                        deriving (Int -> FOF_defined_term -> ShowS
[FOF_defined_term] -> ShowS
FOF_defined_term -> String
(Int -> FOF_defined_term -> ShowS)
-> (FOF_defined_term -> String)
-> ([FOF_defined_term] -> ShowS)
-> Show FOF_defined_term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_defined_term] -> ShowS
$cshowList :: [FOF_defined_term] -> ShowS
show :: FOF_defined_term -> String
$cshow :: FOF_defined_term -> String
showsPrec :: Int -> FOF_defined_term -> ShowS
$cshowsPrec :: Int -> FOF_defined_term -> ShowS
Show, Eq FOF_defined_term
Eq FOF_defined_term =>
(FOF_defined_term -> FOF_defined_term -> Ordering)
-> (FOF_defined_term -> FOF_defined_term -> Bool)
-> (FOF_defined_term -> FOF_defined_term -> Bool)
-> (FOF_defined_term -> FOF_defined_term -> Bool)
-> (FOF_defined_term -> FOF_defined_term -> Bool)
-> (FOF_defined_term -> FOF_defined_term -> FOF_defined_term)
-> (FOF_defined_term -> FOF_defined_term -> FOF_defined_term)
-> Ord FOF_defined_term
FOF_defined_term -> FOF_defined_term -> Bool
FOF_defined_term -> FOF_defined_term -> Ordering
FOF_defined_term -> FOF_defined_term -> FOF_defined_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 :: FOF_defined_term -> FOF_defined_term -> FOF_defined_term
$cmin :: FOF_defined_term -> FOF_defined_term -> FOF_defined_term
max :: FOF_defined_term -> FOF_defined_term -> FOF_defined_term
$cmax :: FOF_defined_term -> FOF_defined_term -> FOF_defined_term
>= :: FOF_defined_term -> FOF_defined_term -> Bool
$c>= :: FOF_defined_term -> FOF_defined_term -> Bool
> :: FOF_defined_term -> FOF_defined_term -> Bool
$c> :: FOF_defined_term -> FOF_defined_term -> Bool
<= :: FOF_defined_term -> FOF_defined_term -> Bool
$c<= :: FOF_defined_term -> FOF_defined_term -> Bool
< :: FOF_defined_term -> FOF_defined_term -> Bool
$c< :: FOF_defined_term -> FOF_defined_term -> Bool
compare :: FOF_defined_term -> FOF_defined_term -> Ordering
$ccompare :: FOF_defined_term -> FOF_defined_term -> Ordering
$cp1Ord :: Eq FOF_defined_term
Ord, FOF_defined_term -> FOF_defined_term -> Bool
(FOF_defined_term -> FOF_defined_term -> Bool)
-> (FOF_defined_term -> FOF_defined_term -> Bool)
-> Eq FOF_defined_term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_defined_term -> FOF_defined_term -> Bool
$c/= :: FOF_defined_term -> FOF_defined_term -> Bool
== :: FOF_defined_term -> FOF_defined_term -> Bool
$c== :: FOF_defined_term -> FOF_defined_term -> Bool
Eq, Typeable FOF_defined_term
Constr
DataType
Typeable FOF_defined_term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FOF_defined_term -> c FOF_defined_term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_defined_term)
-> (FOF_defined_term -> Constr)
-> (FOF_defined_term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_defined_term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_defined_term))
-> ((forall b. Data b => b -> b)
    -> FOF_defined_term -> FOF_defined_term)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_defined_term -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FOF_defined_term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_defined_term -> m FOF_defined_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_defined_term -> m FOF_defined_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_defined_term -> m FOF_defined_term)
-> Data FOF_defined_term
FOF_defined_term -> Constr
FOF_defined_term -> DataType
(forall b. Data b => b -> b)
-> FOF_defined_term -> FOF_defined_term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_defined_term -> c FOF_defined_term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_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) -> FOF_defined_term -> u
forall u. (forall d. Data d => d -> u) -> FOF_defined_term -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_defined_term -> c FOF_defined_term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_defined_term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_defined_term)
$cFOFDT_atomic :: Constr
$cFOFDT_term :: Constr
$tFOF_defined_term :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
gmapM :: (forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_defined_term -> m FOF_defined_term
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_defined_term -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FOF_defined_term -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_defined_term -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FOF_defined_term -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_defined_term -> r
gmapT :: (forall b. Data b => b -> b)
-> FOF_defined_term -> FOF_defined_term
$cgmapT :: (forall b. Data b => b -> b)
-> FOF_defined_term -> FOF_defined_term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_defined_term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_defined_term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_defined_term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_defined_term)
dataTypeOf :: FOF_defined_term -> DataType
$cdataTypeOf :: FOF_defined_term -> DataType
toConstr :: FOF_defined_term -> Constr
$ctoConstr :: FOF_defined_term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_defined_term -> c FOF_defined_term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_defined_term -> c FOF_defined_term
$cp1Data :: Typeable FOF_defined_term
Data, Typeable)

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

-- %----None yet <defined_infix_term> ::= <fof_term> <defined_infix_func> <fof_term>
-- data Defined_infix_term = Defined_infix_term Defined_infix_func FOF_term FOF_term
--                           deriving (Show, Ord, Eq, Data, Typeable)

-- %----None yet <defined_infix_func> ::=
-- data Defined_infix_func =

-- <fof_defined_plain_term>   ::= <defined_constant> |
--                            <defined_functor>(<fof_arguments>)
-- %----Add $tuple for tuples, because [<fof_arguments>] doesn't work.
data FOF_defined_plain_term = FOFDPT_constant Defined_constant
                            | FOFDPT_functor Defined_functor FOF_arguments
                              deriving (Int -> FOF_defined_plain_term -> ShowS
[FOF_defined_plain_term] -> ShowS
FOF_defined_plain_term -> String
(Int -> FOF_defined_plain_term -> ShowS)
-> (FOF_defined_plain_term -> String)
-> ([FOF_defined_plain_term] -> ShowS)
-> Show FOF_defined_plain_term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_defined_plain_term] -> ShowS
$cshowList :: [FOF_defined_plain_term] -> ShowS
show :: FOF_defined_plain_term -> String
$cshow :: FOF_defined_plain_term -> String
showsPrec :: Int -> FOF_defined_plain_term -> ShowS
$cshowsPrec :: Int -> FOF_defined_plain_term -> ShowS
Show, Eq FOF_defined_plain_term
Eq FOF_defined_plain_term =>
(FOF_defined_plain_term -> FOF_defined_plain_term -> Ordering)
-> (FOF_defined_plain_term -> FOF_defined_plain_term -> Bool)
-> (FOF_defined_plain_term -> FOF_defined_plain_term -> Bool)
-> (FOF_defined_plain_term -> FOF_defined_plain_term -> Bool)
-> (FOF_defined_plain_term -> FOF_defined_plain_term -> Bool)
-> (FOF_defined_plain_term
    -> FOF_defined_plain_term -> FOF_defined_plain_term)
-> (FOF_defined_plain_term
    -> FOF_defined_plain_term -> FOF_defined_plain_term)
-> Ord FOF_defined_plain_term
FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
FOF_defined_plain_term -> FOF_defined_plain_term -> Ordering
FOF_defined_plain_term
-> FOF_defined_plain_term -> FOF_defined_plain_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 :: FOF_defined_plain_term
-> FOF_defined_plain_term -> FOF_defined_plain_term
$cmin :: FOF_defined_plain_term
-> FOF_defined_plain_term -> FOF_defined_plain_term
max :: FOF_defined_plain_term
-> FOF_defined_plain_term -> FOF_defined_plain_term
$cmax :: FOF_defined_plain_term
-> FOF_defined_plain_term -> FOF_defined_plain_term
>= :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
$c>= :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
> :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
$c> :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
<= :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
$c<= :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
< :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
$c< :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
compare :: FOF_defined_plain_term -> FOF_defined_plain_term -> Ordering
$ccompare :: FOF_defined_plain_term -> FOF_defined_plain_term -> Ordering
$cp1Ord :: Eq FOF_defined_plain_term
Ord, FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
(FOF_defined_plain_term -> FOF_defined_plain_term -> Bool)
-> (FOF_defined_plain_term -> FOF_defined_plain_term -> Bool)
-> Eq FOF_defined_plain_term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
$c/= :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
== :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
$c== :: FOF_defined_plain_term -> FOF_defined_plain_term -> Bool
Eq, Typeable FOF_defined_plain_term
Constr
DataType
Typeable FOF_defined_plain_term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> FOF_defined_plain_term
 -> c FOF_defined_plain_term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_defined_plain_term)
-> (FOF_defined_plain_term -> Constr)
-> (FOF_defined_plain_term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_defined_plain_term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_defined_plain_term))
-> ((forall b. Data b => b -> b)
    -> FOF_defined_plain_term -> FOF_defined_plain_term)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> FOF_defined_plain_term
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> FOF_defined_plain_term
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_defined_plain_term -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FOF_defined_plain_term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_defined_plain_term -> m FOF_defined_plain_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_defined_plain_term -> m FOF_defined_plain_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_defined_plain_term -> m FOF_defined_plain_term)
-> Data FOF_defined_plain_term
FOF_defined_plain_term -> Constr
FOF_defined_plain_term -> DataType
(forall b. Data b => b -> b)
-> FOF_defined_plain_term -> FOF_defined_plain_term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_defined_plain_term
-> c FOF_defined_plain_term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_plain_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) -> FOF_defined_plain_term -> u
forall u.
(forall d. Data d => d -> u) -> FOF_defined_plain_term -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_defined_plain_term
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_defined_plain_term
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_plain_term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_defined_plain_term
-> c FOF_defined_plain_term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_defined_plain_term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_defined_plain_term)
$cFOFDPT_functor :: Constr
$cFOFDPT_constant :: Constr
$tFOF_defined_plain_term :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
gmapM :: (forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_defined_plain_term -> m FOF_defined_plain_term
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_defined_plain_term -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FOF_defined_plain_term -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_defined_plain_term -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> FOF_defined_plain_term -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_defined_plain_term
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_defined_plain_term
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_defined_plain_term
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> FOF_defined_plain_term
-> r
gmapT :: (forall b. Data b => b -> b)
-> FOF_defined_plain_term -> FOF_defined_plain_term
$cgmapT :: (forall b. Data b => b -> b)
-> FOF_defined_plain_term -> FOF_defined_plain_term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_defined_plain_term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_defined_plain_term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_defined_plain_term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_defined_plain_term)
dataTypeOf :: FOF_defined_plain_term -> DataType
$cdataTypeOf :: FOF_defined_plain_term -> DataType
toConstr :: FOF_defined_plain_term -> Constr
$ctoConstr :: FOF_defined_plain_term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_plain_term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_defined_plain_term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_defined_plain_term
-> c FOF_defined_plain_term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> FOF_defined_plain_term
-> c FOF_defined_plain_term
$cp1Data :: Typeable FOF_defined_plain_term
Data, Typeable)

-- %----System terms have system specific interpretations
-- <fof_system_term>      ::= <system_constant> | <system_functor>(<fof_arguments>)
data FOF_system_term = FOFST_constant System_constant
                     | FOFST_functor System_functor FOF_arguments
                       deriving (Int -> FOF_system_term -> ShowS
[FOF_system_term] -> ShowS
FOF_system_term -> String
(Int -> FOF_system_term -> ShowS)
-> (FOF_system_term -> String)
-> ([FOF_system_term] -> ShowS)
-> Show FOF_system_term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_system_term] -> ShowS
$cshowList :: [FOF_system_term] -> ShowS
show :: FOF_system_term -> String
$cshow :: FOF_system_term -> String
showsPrec :: Int -> FOF_system_term -> ShowS
$cshowsPrec :: Int -> FOF_system_term -> ShowS
Show, Eq FOF_system_term
Eq FOF_system_term =>
(FOF_system_term -> FOF_system_term -> Ordering)
-> (FOF_system_term -> FOF_system_term -> Bool)
-> (FOF_system_term -> FOF_system_term -> Bool)
-> (FOF_system_term -> FOF_system_term -> Bool)
-> (FOF_system_term -> FOF_system_term -> Bool)
-> (FOF_system_term -> FOF_system_term -> FOF_system_term)
-> (FOF_system_term -> FOF_system_term -> FOF_system_term)
-> Ord FOF_system_term
FOF_system_term -> FOF_system_term -> Bool
FOF_system_term -> FOF_system_term -> Ordering
FOF_system_term -> FOF_system_term -> FOF_system_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 :: FOF_system_term -> FOF_system_term -> FOF_system_term
$cmin :: FOF_system_term -> FOF_system_term -> FOF_system_term
max :: FOF_system_term -> FOF_system_term -> FOF_system_term
$cmax :: FOF_system_term -> FOF_system_term -> FOF_system_term
>= :: FOF_system_term -> FOF_system_term -> Bool
$c>= :: FOF_system_term -> FOF_system_term -> Bool
> :: FOF_system_term -> FOF_system_term -> Bool
$c> :: FOF_system_term -> FOF_system_term -> Bool
<= :: FOF_system_term -> FOF_system_term -> Bool
$c<= :: FOF_system_term -> FOF_system_term -> Bool
< :: FOF_system_term -> FOF_system_term -> Bool
$c< :: FOF_system_term -> FOF_system_term -> Bool
compare :: FOF_system_term -> FOF_system_term -> Ordering
$ccompare :: FOF_system_term -> FOF_system_term -> Ordering
$cp1Ord :: Eq FOF_system_term
Ord, FOF_system_term -> FOF_system_term -> Bool
(FOF_system_term -> FOF_system_term -> Bool)
-> (FOF_system_term -> FOF_system_term -> Bool)
-> Eq FOF_system_term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_system_term -> FOF_system_term -> Bool
$c/= :: FOF_system_term -> FOF_system_term -> Bool
== :: FOF_system_term -> FOF_system_term -> Bool
$c== :: FOF_system_term -> FOF_system_term -> Bool
Eq, Typeable FOF_system_term
Constr
DataType
Typeable FOF_system_term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FOF_system_term -> c FOF_system_term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_system_term)
-> (FOF_system_term -> Constr)
-> (FOF_system_term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_system_term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_system_term))
-> ((forall b. Data b => b -> b)
    -> FOF_system_term -> FOF_system_term)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_system_term -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FOF_system_term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_system_term -> m FOF_system_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_system_term -> m FOF_system_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_system_term -> m FOF_system_term)
-> Data FOF_system_term
FOF_system_term -> Constr
FOF_system_term -> DataType
(forall b. Data b => b -> b) -> FOF_system_term -> FOF_system_term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_system_term -> c FOF_system_term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_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) -> FOF_system_term -> u
forall u. (forall d. Data d => d -> u) -> FOF_system_term -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_system_term -> c FOF_system_term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_system_term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_system_term)
$cFOFST_functor :: Constr
$cFOFST_constant :: Constr
$tFOF_system_term :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
gmapM :: (forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_system_term -> m FOF_system_term
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_system_term -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FOF_system_term -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_system_term -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FOF_system_term -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_system_term -> r
gmapT :: (forall b. Data b => b -> b) -> FOF_system_term -> FOF_system_term
$cgmapT :: (forall b. Data b => b -> b) -> FOF_system_term -> FOF_system_term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_system_term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_system_term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_system_term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_system_term)
dataTypeOf :: FOF_system_term -> DataType
$cdataTypeOf :: FOF_system_term -> DataType
toConstr :: FOF_system_term -> Constr
$ctoConstr :: FOF_system_term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_system_term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_system_term -> c FOF_system_term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_system_term -> c FOF_system_term
$cp1Data :: Typeable FOF_system_term
Data, Typeable)

-- %----Arguments recurse back up to terms (this is the FOF world here)
-- <fof_arguments>        ::= <fof_term> | <fof_term>,<fof_arguments>
type FOF_arguments = [FOF_term]

-- %----These are terms used as arguments. Not the entry point for terms because
-- %----<fof_plain_term> is also used as <fof_plain_atomic_formula>
-- <fof_term>             ::= <fof_function_term> | <variable> |
--                            <tff_conditional_term> | <tff_let_term>
data FOF_term = FOFT_function FOF_function_term
              | FOFT_variable Variable
              | FOFT_conditional TFF_conditional_term
              | FOFT_let TFF_let_term
                deriving (Int -> FOF_term -> ShowS
[FOF_term] -> ShowS
FOF_term -> String
(Int -> FOF_term -> ShowS)
-> (FOF_term -> String) -> ([FOF_term] -> ShowS) -> Show FOF_term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_term] -> ShowS
$cshowList :: [FOF_term] -> ShowS
show :: FOF_term -> String
$cshow :: FOF_term -> String
showsPrec :: Int -> FOF_term -> ShowS
$cshowsPrec :: Int -> FOF_term -> ShowS
Show, Eq FOF_term
Eq FOF_term =>
(FOF_term -> FOF_term -> Ordering)
-> (FOF_term -> FOF_term -> Bool)
-> (FOF_term -> FOF_term -> Bool)
-> (FOF_term -> FOF_term -> Bool)
-> (FOF_term -> FOF_term -> Bool)
-> (FOF_term -> FOF_term -> FOF_term)
-> (FOF_term -> FOF_term -> FOF_term)
-> Ord FOF_term
FOF_term -> FOF_term -> Bool
FOF_term -> FOF_term -> Ordering
FOF_term -> FOF_term -> FOF_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 :: FOF_term -> FOF_term -> FOF_term
$cmin :: FOF_term -> FOF_term -> FOF_term
max :: FOF_term -> FOF_term -> FOF_term
$cmax :: FOF_term -> FOF_term -> FOF_term
>= :: FOF_term -> FOF_term -> Bool
$c>= :: FOF_term -> FOF_term -> Bool
> :: FOF_term -> FOF_term -> Bool
$c> :: FOF_term -> FOF_term -> Bool
<= :: FOF_term -> FOF_term -> Bool
$c<= :: FOF_term -> FOF_term -> Bool
< :: FOF_term -> FOF_term -> Bool
$c< :: FOF_term -> FOF_term -> Bool
compare :: FOF_term -> FOF_term -> Ordering
$ccompare :: FOF_term -> FOF_term -> Ordering
$cp1Ord :: Eq FOF_term
Ord, FOF_term -> FOF_term -> Bool
(FOF_term -> FOF_term -> Bool)
-> (FOF_term -> FOF_term -> Bool) -> Eq FOF_term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_term -> FOF_term -> Bool
$c/= :: FOF_term -> FOF_term -> Bool
== :: FOF_term -> FOF_term -> Bool
$c== :: FOF_term -> FOF_term -> Bool
Eq, Typeable FOF_term
Constr
DataType
Typeable FOF_term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FOF_term -> c FOF_term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_term)
-> (FOF_term -> Constr)
-> (FOF_term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FOF_term))
-> ((forall b. Data b => b -> b) -> FOF_term -> FOF_term)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_term -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_term -> r)
-> (forall u. (forall d. Data d => d -> u) -> FOF_term -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FOF_term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FOF_term -> m FOF_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FOF_term -> m FOF_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FOF_term -> m FOF_term)
-> Data FOF_term
FOF_term -> Constr
FOF_term -> DataType
(forall b. Data b => b -> b) -> FOF_term -> FOF_term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_term -> c FOF_term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_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) -> FOF_term -> u
forall u. (forall d. Data d => d -> u) -> FOF_term -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_term -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_term -> c FOF_term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FOF_term)
$cFOFT_let :: Constr
$cFOFT_conditional :: Constr
$cFOFT_variable :: Constr
$cFOFT_function :: Constr
$tFOF_term :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
gmapMp :: (forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
gmapM :: (forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FOF_term -> m FOF_term
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_term -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FOF_term -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_term -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FOF_term -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_term -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_term -> r
gmapT :: (forall b. Data b => b -> b) -> FOF_term -> FOF_term
$cgmapT :: (forall b. Data b => b -> b) -> FOF_term -> FOF_term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FOF_term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FOF_term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_term)
dataTypeOf :: FOF_term -> DataType
$cdataTypeOf :: FOF_term -> DataType
toConstr :: FOF_term -> Constr
$ctoConstr :: FOF_term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_term -> c FOF_term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_term -> c FOF_term
$cp1Data :: Typeable FOF_term
Data, Typeable)

-- %% DAMN THIS JUST WON'T WORK | <tuple_term>
-- %----<tuple_term> is for TFF only, but it's here because it's used in
-- %----<fof_atomic_formula>, which is also used as <tff_atomic_formula>.
-- % <tuple_term>           ::= [] | [<fof_arguments>]
-- <fof_function_term>    ::= <fof_plain_term> | <fof_defined_term> |
--                            <fof_system_term>
data FOF_function_term = FOFFT_plain FOF_plain_term
                       | FOFFT_defined FOF_defined_term
                       | FOFFT_system FOF_system_term
                         deriving (Int -> FOF_function_term -> ShowS
[FOF_function_term] -> ShowS
FOF_function_term -> String
(Int -> FOF_function_term -> ShowS)
-> (FOF_function_term -> String)
-> ([FOF_function_term] -> ShowS)
-> Show FOF_function_term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FOF_function_term] -> ShowS
$cshowList :: [FOF_function_term] -> ShowS
show :: FOF_function_term -> String
$cshow :: FOF_function_term -> String
showsPrec :: Int -> FOF_function_term -> ShowS
$cshowsPrec :: Int -> FOF_function_term -> ShowS
Show, Eq FOF_function_term
Eq FOF_function_term =>
(FOF_function_term -> FOF_function_term -> Ordering)
-> (FOF_function_term -> FOF_function_term -> Bool)
-> (FOF_function_term -> FOF_function_term -> Bool)
-> (FOF_function_term -> FOF_function_term -> Bool)
-> (FOF_function_term -> FOF_function_term -> Bool)
-> (FOF_function_term -> FOF_function_term -> FOF_function_term)
-> (FOF_function_term -> FOF_function_term -> FOF_function_term)
-> Ord FOF_function_term
FOF_function_term -> FOF_function_term -> Bool
FOF_function_term -> FOF_function_term -> Ordering
FOF_function_term -> FOF_function_term -> FOF_function_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 :: FOF_function_term -> FOF_function_term -> FOF_function_term
$cmin :: FOF_function_term -> FOF_function_term -> FOF_function_term
max :: FOF_function_term -> FOF_function_term -> FOF_function_term
$cmax :: FOF_function_term -> FOF_function_term -> FOF_function_term
>= :: FOF_function_term -> FOF_function_term -> Bool
$c>= :: FOF_function_term -> FOF_function_term -> Bool
> :: FOF_function_term -> FOF_function_term -> Bool
$c> :: FOF_function_term -> FOF_function_term -> Bool
<= :: FOF_function_term -> FOF_function_term -> Bool
$c<= :: FOF_function_term -> FOF_function_term -> Bool
< :: FOF_function_term -> FOF_function_term -> Bool
$c< :: FOF_function_term -> FOF_function_term -> Bool
compare :: FOF_function_term -> FOF_function_term -> Ordering
$ccompare :: FOF_function_term -> FOF_function_term -> Ordering
$cp1Ord :: Eq FOF_function_term
Ord, FOF_function_term -> FOF_function_term -> Bool
(FOF_function_term -> FOF_function_term -> Bool)
-> (FOF_function_term -> FOF_function_term -> Bool)
-> Eq FOF_function_term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FOF_function_term -> FOF_function_term -> Bool
$c/= :: FOF_function_term -> FOF_function_term -> Bool
== :: FOF_function_term -> FOF_function_term -> Bool
$c== :: FOF_function_term -> FOF_function_term -> Bool
Eq, Typeable FOF_function_term
Constr
DataType
Typeable FOF_function_term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> FOF_function_term
 -> c FOF_function_term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FOF_function_term)
-> (FOF_function_term -> Constr)
-> (FOF_function_term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FOF_function_term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FOF_function_term))
-> ((forall b. Data b => b -> b)
    -> FOF_function_term -> FOF_function_term)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FOF_function_term -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FOF_function_term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FOF_function_term -> m FOF_function_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_function_term -> m FOF_function_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FOF_function_term -> m FOF_function_term)
-> Data FOF_function_term
FOF_function_term -> Constr
FOF_function_term -> DataType
(forall b. Data b => b -> b)
-> FOF_function_term -> FOF_function_term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_function_term -> c FOF_function_term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_function_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) -> FOF_function_term -> u
forall u. (forall d. Data d => d -> u) -> FOF_function_term -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_function_term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_function_term -> c FOF_function_term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_function_term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_function_term)
$cFOFFT_system :: Constr
$cFOFFT_defined :: Constr
$cFOFFT_plain :: Constr
$tFOF_function_term :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
gmapMp :: (forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
gmapM :: (forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FOF_function_term -> m FOF_function_term
gmapQi :: Int -> (forall d. Data d => d -> u) -> FOF_function_term -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FOF_function_term -> u
gmapQ :: (forall d. Data d => d -> u) -> FOF_function_term -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FOF_function_term -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FOF_function_term -> r
gmapT :: (forall b. Data b => b -> b)
-> FOF_function_term -> FOF_function_term
$cgmapT :: (forall b. Data b => b -> b)
-> FOF_function_term -> FOF_function_term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_function_term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FOF_function_term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FOF_function_term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FOF_function_term)
dataTypeOf :: FOF_function_term -> DataType
$cdataTypeOf :: FOF_function_term -> DataType
toConstr :: FOF_function_term -> Constr
$ctoConstr :: FOF_function_term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_function_term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FOF_function_term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_function_term -> c FOF_function_term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FOF_function_term -> c FOF_function_term
$cp1Data :: Typeable FOF_function_term
Data, Typeable)

-- %----Conditional terms should be used by only TFF.
-- <tff_conditional_term> ::= $ite_t(<tff_logic_formula>,<fof_term>,<fof_term>)
data TFF_conditional_term = TFF_conditional_term TFF_logic_formula FOF_term FOF_term
                            deriving (Int -> TFF_conditional_term -> ShowS
[TFF_conditional_term] -> ShowS
TFF_conditional_term -> String
(Int -> TFF_conditional_term -> ShowS)
-> (TFF_conditional_term -> String)
-> ([TFF_conditional_term] -> ShowS)
-> Show TFF_conditional_term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_conditional_term] -> ShowS
$cshowList :: [TFF_conditional_term] -> ShowS
show :: TFF_conditional_term -> String
$cshow :: TFF_conditional_term -> String
showsPrec :: Int -> TFF_conditional_term -> ShowS
$cshowsPrec :: Int -> TFF_conditional_term -> ShowS
Show, Eq TFF_conditional_term
Eq TFF_conditional_term =>
(TFF_conditional_term -> TFF_conditional_term -> Ordering)
-> (TFF_conditional_term -> TFF_conditional_term -> Bool)
-> (TFF_conditional_term -> TFF_conditional_term -> Bool)
-> (TFF_conditional_term -> TFF_conditional_term -> Bool)
-> (TFF_conditional_term -> TFF_conditional_term -> Bool)
-> (TFF_conditional_term
    -> TFF_conditional_term -> TFF_conditional_term)
-> (TFF_conditional_term
    -> TFF_conditional_term -> TFF_conditional_term)
-> Ord TFF_conditional_term
TFF_conditional_term -> TFF_conditional_term -> Bool
TFF_conditional_term -> TFF_conditional_term -> Ordering
TFF_conditional_term
-> TFF_conditional_term -> TFF_conditional_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 :: TFF_conditional_term
-> TFF_conditional_term -> TFF_conditional_term
$cmin :: TFF_conditional_term
-> TFF_conditional_term -> TFF_conditional_term
max :: TFF_conditional_term
-> TFF_conditional_term -> TFF_conditional_term
$cmax :: TFF_conditional_term
-> TFF_conditional_term -> TFF_conditional_term
>= :: TFF_conditional_term -> TFF_conditional_term -> Bool
$c>= :: TFF_conditional_term -> TFF_conditional_term -> Bool
> :: TFF_conditional_term -> TFF_conditional_term -> Bool
$c> :: TFF_conditional_term -> TFF_conditional_term -> Bool
<= :: TFF_conditional_term -> TFF_conditional_term -> Bool
$c<= :: TFF_conditional_term -> TFF_conditional_term -> Bool
< :: TFF_conditional_term -> TFF_conditional_term -> Bool
$c< :: TFF_conditional_term -> TFF_conditional_term -> Bool
compare :: TFF_conditional_term -> TFF_conditional_term -> Ordering
$ccompare :: TFF_conditional_term -> TFF_conditional_term -> Ordering
$cp1Ord :: Eq TFF_conditional_term
Ord, TFF_conditional_term -> TFF_conditional_term -> Bool
(TFF_conditional_term -> TFF_conditional_term -> Bool)
-> (TFF_conditional_term -> TFF_conditional_term -> Bool)
-> Eq TFF_conditional_term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_conditional_term -> TFF_conditional_term -> Bool
$c/= :: TFF_conditional_term -> TFF_conditional_term -> Bool
== :: TFF_conditional_term -> TFF_conditional_term -> Bool
$c== :: TFF_conditional_term -> TFF_conditional_term -> Bool
Eq, Typeable TFF_conditional_term
Constr
DataType
Typeable TFF_conditional_term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> TFF_conditional_term
 -> c TFF_conditional_term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_conditional_term)
-> (TFF_conditional_term -> Constr)
-> (TFF_conditional_term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_conditional_term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_conditional_term))
-> ((forall b. Data b => b -> b)
    -> TFF_conditional_term -> TFF_conditional_term)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TFF_conditional_term -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_conditional_term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TFF_conditional_term -> m TFF_conditional_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_conditional_term -> m TFF_conditional_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TFF_conditional_term -> m TFF_conditional_term)
-> Data TFF_conditional_term
TFF_conditional_term -> Constr
TFF_conditional_term -> DataType
(forall b. Data b => b -> b)
-> TFF_conditional_term -> TFF_conditional_term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_conditional_term
-> c TFF_conditional_term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_conditional_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) -> TFF_conditional_term -> u
forall u.
(forall d. Data d => d -> u) -> TFF_conditional_term -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_conditional_term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_conditional_term
-> c TFF_conditional_term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_conditional_term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_conditional_term)
$cTFF_conditional_term :: Constr
$tTFF_conditional_term :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
gmapMp :: (forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
gmapM :: (forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TFF_conditional_term -> m TFF_conditional_term
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_conditional_term -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TFF_conditional_term -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_conditional_term -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> TFF_conditional_term -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_conditional_term -> r
gmapT :: (forall b. Data b => b -> b)
-> TFF_conditional_term -> TFF_conditional_term
$cgmapT :: (forall b. Data b => b -> b)
-> TFF_conditional_term -> TFF_conditional_term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_conditional_term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_conditional_term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_conditional_term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_conditional_term)
dataTypeOf :: TFF_conditional_term -> DataType
$cdataTypeOf :: TFF_conditional_term -> DataType
toConstr :: TFF_conditional_term -> Constr
$ctoConstr :: TFF_conditional_term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_conditional_term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_conditional_term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_conditional_term
-> c TFF_conditional_term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TFF_conditional_term
-> c TFF_conditional_term
$cp1Data :: Typeable TFF_conditional_term
Data, Typeable)

-- %----Let terms should be used by only TFF. $let_ft is for use when there is
-- %----a $ite_t in the <fof_term>. See the commentary for $let_tf and $let_ff.
-- <tff_let_term>         ::= $let_ft(<tff_let_formula_defns>,<fof_term>) |
--                            $let_tt(<tff_let_term_defns>,<fof_term>)
data TFF_let_term = TFFLT_formula TFF_let_formula_defns FOF_term
                  | TFFLT_term TFF_let_term_defns FOF_term
                    deriving (Int -> TFF_let_term -> ShowS
[TFF_let_term] -> ShowS
TFF_let_term -> String
(Int -> TFF_let_term -> ShowS)
-> (TFF_let_term -> String)
-> ([TFF_let_term] -> ShowS)
-> Show TFF_let_term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TFF_let_term] -> ShowS
$cshowList :: [TFF_let_term] -> ShowS
show :: TFF_let_term -> String
$cshow :: TFF_let_term -> String
showsPrec :: Int -> TFF_let_term -> ShowS
$cshowsPrec :: Int -> TFF_let_term -> ShowS
Show, Eq TFF_let_term
Eq TFF_let_term =>
(TFF_let_term -> TFF_let_term -> Ordering)
-> (TFF_let_term -> TFF_let_term -> Bool)
-> (TFF_let_term -> TFF_let_term -> Bool)
-> (TFF_let_term -> TFF_let_term -> Bool)
-> (TFF_let_term -> TFF_let_term -> Bool)
-> (TFF_let_term -> TFF_let_term -> TFF_let_term)
-> (TFF_let_term -> TFF_let_term -> TFF_let_term)
-> Ord TFF_let_term
TFF_let_term -> TFF_let_term -> Bool
TFF_let_term -> TFF_let_term -> Ordering
TFF_let_term -> TFF_let_term -> TFF_let_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 :: TFF_let_term -> TFF_let_term -> TFF_let_term
$cmin :: TFF_let_term -> TFF_let_term -> TFF_let_term
max :: TFF_let_term -> TFF_let_term -> TFF_let_term
$cmax :: TFF_let_term -> TFF_let_term -> TFF_let_term
>= :: TFF_let_term -> TFF_let_term -> Bool
$c>= :: TFF_let_term -> TFF_let_term -> Bool
> :: TFF_let_term -> TFF_let_term -> Bool
$c> :: TFF_let_term -> TFF_let_term -> Bool
<= :: TFF_let_term -> TFF_let_term -> Bool
$c<= :: TFF_let_term -> TFF_let_term -> Bool
< :: TFF_let_term -> TFF_let_term -> Bool
$c< :: TFF_let_term -> TFF_let_term -> Bool
compare :: TFF_let_term -> TFF_let_term -> Ordering
$ccompare :: TFF_let_term -> TFF_let_term -> Ordering
$cp1Ord :: Eq TFF_let_term
Ord, TFF_let_term -> TFF_let_term -> Bool
(TFF_let_term -> TFF_let_term -> Bool)
-> (TFF_let_term -> TFF_let_term -> Bool) -> Eq TFF_let_term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TFF_let_term -> TFF_let_term -> Bool
$c/= :: TFF_let_term -> TFF_let_term -> Bool
== :: TFF_let_term -> TFF_let_term -> Bool
$c== :: TFF_let_term -> TFF_let_term -> Bool
Eq, Typeable TFF_let_term
Constr
DataType
Typeable TFF_let_term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TFF_let_term -> c TFF_let_term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TFF_let_term)
-> (TFF_let_term -> Constr)
-> (TFF_let_term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TFF_let_term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TFF_let_term))
-> ((forall b. Data b => b -> b) -> TFF_let_term -> TFF_let_term)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r)
-> (forall u. (forall d. Data d => d -> u) -> TFF_let_term -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TFF_let_term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term)
-> Data TFF_let_term
TFF_let_term -> Constr
TFF_let_term -> DataType
(forall b. Data b => b -> b) -> TFF_let_term -> TFF_let_term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_let_term -> c TFF_let_term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_let_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) -> TFF_let_term -> u
forall u. (forall d. Data d => d -> u) -> TFF_let_term -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_let_term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_let_term -> c TFF_let_term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_let_term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_let_term)
$cTFFLT_term :: Constr
$cTFFLT_formula :: Constr
$tTFF_let_term :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
gmapMp :: (forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
gmapM :: (forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TFF_let_term -> m TFF_let_term
gmapQi :: Int -> (forall d. Data d => d -> u) -> TFF_let_term -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TFF_let_term -> u
gmapQ :: (forall d. Data d => d -> u) -> TFF_let_term -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TFF_let_term -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TFF_let_term -> r
gmapT :: (forall b. Data b => b -> b) -> TFF_let_term -> TFF_let_term
$cgmapT :: (forall b. Data b => b -> b) -> TFF_let_term -> TFF_let_term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_let_term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TFF_let_term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TFF_let_term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TFF_let_term)
dataTypeOf :: TFF_let_term -> DataType
$cdataTypeOf :: TFF_let_term -> DataType
toConstr :: TFF_let_term -> Constr
$ctoConstr :: TFF_let_term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_let_term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TFF_let_term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_let_term -> c TFF_let_term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TFF_let_term -> c TFF_let_term
$cp1Data :: Typeable TFF_let_term
Data, Typeable)

{-
%----This section is the FOFX syntax. Not yet in use.
% <fof_let>            ::= := [<fof_let_list>] : <fof_unitary_formula>
% <fof_let_list>       ::= <fof_defined_var> |
%                          <fof_defined_var>,<fof_let_list>
% <fof_defined_var>    ::= <variable> := <fof_logic_formula> |
%                          <variable> :- <fof_term> | (<fof_defined_var>)
%
% <fof_conditional>    ::= $ite_f(<fof_logic_formula>,<fof_logic_formula>,
%                          <fof_logic_formula>)
%
% <fof_conditional_term> ::= $ite_t(<fof_logic_formula>,<fof_term>,<fof_term>)
-}

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

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

-- <fof_formula_tuple_list> ::= <fof_logic_formula> |
--                            <fof_logic_formula>,<fof_formula_tuple_list>
type FOF_formula_tuple_list = [FOF_logic_formula]


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

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

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



-- %----Connectives - THF
-- <thf_quantifier>       ::= <fof_quantifier> | <th0_quantifier> |
--                            <th1_quantifier>
data THF_quantifier = THFQ_fof FOF_quantifier
                    | THFQ_th0 TH0_quantifier
                    | THFQ_th1 TH1_quantifier
                      deriving (Int -> THF_quantifier -> ShowS
[THF_quantifier] -> ShowS
THF_quantifier -> String
(Int -> THF_quantifier -> ShowS)
-> (THF_quantifier -> String)
-> ([THF_quantifier] -> ShowS)
-> Show THF_quantifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [THF_quantifier] -> ShowS
$cshowList :: [THF_quantifier] -> ShowS
show :: THF_quantifier -> String
$cshow :: THF_quantifier -> String
showsPrec :: Int -> THF_quantifier -> ShowS
$cshowsPrec :: Int -> THF_quantifier -> ShowS
Show, Eq THF_quantifier
Eq THF_quantifier =>
(THF_quantifier -> THF_quantifier -> Ordering)
-> (THF_quantifier -> THF_quantifier -> Bool)
-> (THF_quantifier -> THF_quantifier -> Bool)
-> (THF_quantifier -> THF_quantifier -> Bool)
-> (THF_quantifier -> THF_quantifier -> Bool)
-> (THF_quantifier -> THF_quantifier -> THF_quantifier)
-> (THF_quantifier -> THF_quantifier -> THF_quantifier)
-> Ord THF_quantifier
THF_quantifier -> THF_quantifier -> Bool
THF_quantifier -> THF_quantifier -> Ordering
THF_quantifier -> THF_quantifier -> THF_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 :: THF_quantifier -> THF_quantifier -> THF_quantifier
$cmin :: THF_quantifier -> THF_quantifier -> THF_quantifier
max :: THF_quantifier -> THF_quantifier -> THF_quantifier
$cmax :: THF_quantifier -> THF_quantifier -> THF_quantifier
>= :: THF_quantifier -> THF_quantifier -> Bool
$c>= :: THF_quantifier -> THF_quantifier -> Bool
> :: THF_quantifier -> THF_quantifier -> Bool
$c> :: THF_quantifier -> THF_quantifier -> Bool
<= :: THF_quantifier -> THF_quantifier -> Bool
$c<= :: THF_quantifier -> THF_quantifier -> Bool
< :: THF_quantifier -> THF_quantifier -> Bool
$c< :: THF_quantifier -> THF_quantifier -> Bool
compare :: THF_quantifier -> THF_quantifier -> Ordering
$ccompare :: THF_quantifier -> THF_quantifier -> Ordering
$cp1Ord :: Eq THF_quantifier
Ord, THF_quantifier -> THF_quantifier -> Bool
(THF_quantifier -> THF_quantifier -> Bool)
-> (THF_quantifier -> THF_quantifier -> Bool) -> Eq THF_quantifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: THF_quantifier -> THF_quantifier -> Bool
$c/= :: THF_quantifier -> THF_quantifier -> Bool
== :: THF_quantifier -> THF_quantifier -> Bool
$c== :: THF_quantifier -> THF_quantifier -> Bool
Eq, Typeable THF_quantifier
Constr
DataType
Typeable THF_quantifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> THF_quantifier -> c THF_quantifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c THF_quantifier)
-> (THF_quantifier -> Constr)
-> (THF_quantifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c THF_quantifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c THF_quantifier))
-> ((forall b. Data b => b -> b)
    -> THF_quantifier -> THF_quantifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> THF_quantifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> THF_quantifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> THF_quantifier -> m THF_quantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_quantifier -> m THF_quantifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> THF_quantifier -> m THF_quantifier)
-> Data THF_quantifier
THF_quantifier -> Constr
THF_quantifier -> DataType
(forall b. Data b => b -> b) -> THF_quantifier -> THF_quantifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_quantifier -> c THF_quantifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_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) -> THF_quantifier -> u
forall u. (forall d. Data d => d -> u) -> THF_quantifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_quantifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_quantifier -> c THF_quantifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_quantifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_quantifier)
$cTHFQ_th1 :: Constr
$cTHFQ_th0 :: Constr
$cTHFQ_fof :: Constr
$tTHF_quantifier :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
gmapMp :: (forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
gmapM :: (forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> THF_quantifier -> m THF_quantifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> THF_quantifier -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> THF_quantifier -> u
gmapQ :: (forall d. Data d => d -> u) -> THF_quantifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> THF_quantifier -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> THF_quantifier -> r
gmapT :: (forall b. Data b => b -> b) -> THF_quantifier -> THF_quantifier
$cgmapT :: (forall b. Data b => b -> b) -> THF_quantifier -> THF_quantifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_quantifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c THF_quantifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c THF_quantifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c THF_quantifier)
dataTypeOf :: THF_quantifier -> DataType
$cdataTypeOf :: THF_quantifier -> DataType
toConstr :: THF_quantifier -> Constr
$ctoConstr :: THF_quantifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_quantifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c THF_quantifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_quantifier -> c THF_quantifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> THF_quantifier -> c THF_quantifier
$cp1Data :: Typeable THF_quantifier
Data, Typeable)


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

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

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

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

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


-- %----Connectives - TFF
-- % <tff_pair_connective>  ::= <binary_connective> | <assignment>
-- Note: not used
-- data TFF_pair_connective = TFFPC_binary Binary_connective
--                          | TFFPC_assignment TFF_assignment
--                            deriving (Show, Ord, Eq, Data, Typeable)

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

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

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

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


-- %----Types for THF and TFF
-- <type_constant>        ::= <type_functor>
type Type_constant = Type_functor

-- <type_functor>         ::= <atomic_word>
type Type_functor = Token

-- <defined_type>         ::= <atomic_defined_word>
-- <defined_type>         :== $oType | $o | $iType | $i | $tType |
--                            $real | $rat | $int
data Defined_type = OType --  $oType/$o is the Boolean type, i.e., the type of $true and $false.
                  | O     --  $oType/$o is the Boolean type, i.e., the type of $true and $false.
                  | IType --  $iType/$i is non-empty type of individuals, which may be finite or infinite.
                  | I     --  $iType/$i is non-empty type of individuals, which may be finite or infinite.
                  | TType --  $tType is the type (kind) of all types.
                  | Real  --  $real is the type of <real>s.
                  | Rat   --  $rat is the type of <rational>s.
                  | Int   --  $int is the type of <signed_integer>s and <unsigned_integer>s.
                    deriving (Int -> Defined_type -> ShowS
[Defined_type] -> ShowS
Defined_type -> String
(Int -> Defined_type -> ShowS)
-> (Defined_type -> String)
-> ([Defined_type] -> ShowS)
-> Show Defined_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Defined_type] -> ShowS
$cshowList :: [Defined_type] -> ShowS
show :: Defined_type -> String
$cshow :: Defined_type -> String
showsPrec :: Int -> Defined_type -> ShowS
$cshowsPrec :: Int -> Defined_type -> ShowS
Show, Eq Defined_type
Eq Defined_type =>
(Defined_type -> Defined_type -> Ordering)
-> (Defined_type -> Defined_type -> Bool)
-> (Defined_type -> Defined_type -> Bool)
-> (Defined_type -> Defined_type -> Bool)
-> (Defined_type -> Defined_type -> Bool)
-> (Defined_type -> Defined_type -> Defined_type)
-> (Defined_type -> Defined_type -> Defined_type)
-> Ord Defined_type
Defined_type -> Defined_type -> Bool
Defined_type -> Defined_type -> Ordering
Defined_type -> Defined_type -> Defined_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Defined_type -> Defined_type -> Defined_type
$cmin :: Defined_type -> Defined_type -> Defined_type
max :: Defined_type -> Defined_type -> Defined_type
$cmax :: Defined_type -> Defined_type -> Defined_type
>= :: Defined_type -> Defined_type -> Bool
$c>= :: Defined_type -> Defined_type -> Bool
> :: Defined_type -> Defined_type -> Bool
$c> :: Defined_type -> Defined_type -> Bool
<= :: Defined_type -> Defined_type -> Bool
$c<= :: Defined_type -> Defined_type -> Bool
< :: Defined_type -> Defined_type -> Bool
$c< :: Defined_type -> Defined_type -> Bool
compare :: Defined_type -> Defined_type -> Ordering
$ccompare :: Defined_type -> Defined_type -> Ordering
$cp1Ord :: Eq Defined_type
Ord, Defined_type -> Defined_type -> Bool
(Defined_type -> Defined_type -> Bool)
-> (Defined_type -> Defined_type -> Bool) -> Eq Defined_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Defined_type -> Defined_type -> Bool
$c/= :: Defined_type -> Defined_type -> Bool
== :: Defined_type -> Defined_type -> Bool
$c== :: Defined_type -> Defined_type -> Bool
Eq, Typeable Defined_type
Constr
DataType
Typeable Defined_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Defined_type -> c Defined_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Defined_type)
-> (Defined_type -> Constr)
-> (Defined_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Defined_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Defined_type))
-> ((forall b. Data b => b -> b) -> Defined_type -> Defined_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Defined_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Defined_type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Defined_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Defined_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Defined_type -> m Defined_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defined_type -> m Defined_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Defined_type -> m Defined_type)
-> Data Defined_type
Defined_type -> Constr
Defined_type -> DataType
(forall b. Data b => b -> b) -> Defined_type -> Defined_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_type -> c Defined_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Defined_type -> u
forall u. (forall d. Data d => d -> u) -> Defined_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_type -> c Defined_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Defined_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Defined_type)
$cInt :: Constr
$cRat :: Constr
$cReal :: Constr
$cTType :: Constr
$cI :: Constr
$cIType :: Constr
$cO :: Constr
$cOType :: Constr
$tDefined_type :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
gmapMp :: (forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
gmapM :: (forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Defined_type -> m Defined_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> Defined_type -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Defined_type -> u
gmapQ :: (forall d. Data d => d -> u) -> Defined_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Defined_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_type -> r
gmapT :: (forall b. Data b => b -> b) -> Defined_type -> Defined_type
$cgmapT :: (forall b. Data b => b -> b) -> Defined_type -> Defined_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Defined_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Defined_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Defined_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Defined_type)
dataTypeOf :: Defined_type -> DataType
$cdataTypeOf :: Defined_type -> DataType
toConstr :: Defined_type -> Constr
$ctoConstr :: Defined_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_type -> c Defined_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_type -> c Defined_type
$cp1Data :: Typeable Defined_type
Data, Typeable)

-- <system_type>          :== <atomic_system_word>
-- Note: not used
-- type System_type = Token

-- %----For all language types
-- <atom>                 ::= <untyped_atom> | <defined_constant>
data Atom = Atom_untyped Untyped_atom
          | Atom_constant Defined_constant
            deriving (Int -> Atom -> ShowS
[Atom] -> ShowS
Atom -> String
(Int -> Atom -> ShowS)
-> (Atom -> String) -> ([Atom] -> ShowS) -> Show Atom
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Atom] -> ShowS
$cshowList :: [Atom] -> ShowS
show :: Atom -> String
$cshow :: Atom -> String
showsPrec :: Int -> Atom -> ShowS
$cshowsPrec :: Int -> Atom -> ShowS
Show, Eq Atom
Eq Atom =>
(Atom -> Atom -> Ordering)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Bool)
-> (Atom -> Atom -> Atom)
-> (Atom -> Atom -> Atom)
-> Ord Atom
Atom -> Atom -> Bool
Atom -> Atom -> Ordering
Atom -> Atom -> Atom
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Atom -> Atom -> Atom
$cmin :: Atom -> Atom -> Atom
max :: Atom -> Atom -> Atom
$cmax :: Atom -> Atom -> Atom
>= :: Atom -> Atom -> Bool
$c>= :: Atom -> Atom -> Bool
> :: Atom -> Atom -> Bool
$c> :: Atom -> Atom -> Bool
<= :: Atom -> Atom -> Bool
$c<= :: Atom -> Atom -> Bool
< :: Atom -> Atom -> Bool
$c< :: Atom -> Atom -> Bool
compare :: Atom -> Atom -> Ordering
$ccompare :: Atom -> Atom -> Ordering
$cp1Ord :: Eq Atom
Ord, Atom -> Atom -> Bool
(Atom -> Atom -> Bool) -> (Atom -> Atom -> Bool) -> Eq Atom
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Atom -> Atom -> Bool
$c/= :: Atom -> Atom -> Bool
== :: Atom -> Atom -> Bool
$c== :: Atom -> Atom -> Bool
Eq, Typeable Atom
Constr
DataType
Typeable Atom =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Atom -> c Atom)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Atom)
-> (Atom -> Constr)
-> (Atom -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Atom))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Atom))
-> ((forall b. Data b => b -> b) -> Atom -> Atom)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r)
-> (forall u. (forall d. Data d => d -> u) -> Atom -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Atom -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Atom -> m Atom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Atom -> m Atom)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Atom -> m Atom)
-> Data Atom
Atom -> Constr
Atom -> DataType
(forall b. Data b => b -> b) -> Atom -> Atom
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Atom -> c Atom
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Atom
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Atom -> u
forall u. (forall d. Data d => d -> u) -> Atom -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Atom -> m Atom
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Atom -> m Atom
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Atom
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Atom -> c Atom
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Atom)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Atom)
$cAtom_constant :: Constr
$cAtom_untyped :: Constr
$tAtom :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Atom -> m Atom
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Atom -> m Atom
gmapMp :: (forall d. Data d => d -> m d) -> Atom -> m Atom
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Atom -> m Atom
gmapM :: (forall d. Data d => d -> m d) -> Atom -> m Atom
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Atom -> m Atom
gmapQi :: Int -> (forall d. Data d => d -> u) -> Atom -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Atom -> u
gmapQ :: (forall d. Data d => d -> u) -> Atom -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Atom -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Atom -> r
gmapT :: (forall b. Data b => b -> b) -> Atom -> Atom
$cgmapT :: (forall b. Data b => b -> b) -> Atom -> Atom
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Atom)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Atom)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Atom)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Atom)
dataTypeOf :: Atom -> DataType
$cdataTypeOf :: Atom -> DataType
toConstr :: Atom -> Constr
$ctoConstr :: Atom -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Atom
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Atom
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Atom -> c Atom
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Atom -> c Atom
$cp1Data :: Typeable Atom
Data, Typeable)

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

type Proposition = Predicate
type Predicate = Token

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

-- <defined_predicate>    :== <atomic_defined_word>
-- <defined_predicate>    :== $distinct |
--                            $less | $lesseq | $greater | $greatereq |
--                            $is_int | $is_rat |
--                            $box_P | $box_i | $box_int | $box |
--                            $dia_P | $dia_i | $dia_int | $dia
-- %----$distinct means that each of it's constant arguments are pairwise !=. It
-- %----is part of the TFF syntax. It can be used only as a fact, not under any
-- %----connective.
data Defined_predicate = Distinct
                       | Less
                       | Lesseq
                       | Greater
                       | Greatereq
                       | Is_int
                       | Is_rat
                       | Box_P
                       | Box_i
                       | Box_int
                       | Box
                       | Dia_P
                       | Dia_i
                       | Dia_int
                       | Dia
                         deriving (Int -> Defined_predicate -> ShowS
[Defined_predicate] -> ShowS
Defined_predicate -> String
(Int -> Defined_predicate -> ShowS)
-> (Defined_predicate -> String)
-> ([Defined_predicate] -> ShowS)
-> Show Defined_predicate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Defined_predicate] -> ShowS
$cshowList :: [Defined_predicate] -> ShowS
show :: Defined_predicate -> String
$cshow :: Defined_predicate -> String
showsPrec :: Int -> Defined_predicate -> ShowS
$cshowsPrec :: Int -> Defined_predicate -> ShowS
Show, Eq Defined_predicate
Eq Defined_predicate =>
(Defined_predicate -> Defined_predicate -> Ordering)
-> (Defined_predicate -> Defined_predicate -> Bool)
-> (Defined_predicate -> Defined_predicate -> Bool)
-> (Defined_predicate -> Defined_predicate -> Bool)
-> (Defined_predicate -> Defined_predicate -> Bool)
-> (Defined_predicate -> Defined_predicate -> Defined_predicate)
-> (Defined_predicate -> Defined_predicate -> Defined_predicate)
-> Ord Defined_predicate
Defined_predicate -> Defined_predicate -> Bool
Defined_predicate -> Defined_predicate -> Ordering
Defined_predicate -> Defined_predicate -> Defined_predicate
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 :: Defined_predicate -> Defined_predicate -> Defined_predicate
$cmin :: Defined_predicate -> Defined_predicate -> Defined_predicate
max :: Defined_predicate -> Defined_predicate -> Defined_predicate
$cmax :: Defined_predicate -> Defined_predicate -> Defined_predicate
>= :: Defined_predicate -> Defined_predicate -> Bool
$c>= :: Defined_predicate -> Defined_predicate -> Bool
> :: Defined_predicate -> Defined_predicate -> Bool
$c> :: Defined_predicate -> Defined_predicate -> Bool
<= :: Defined_predicate -> Defined_predicate -> Bool
$c<= :: Defined_predicate -> Defined_predicate -> Bool
< :: Defined_predicate -> Defined_predicate -> Bool
$c< :: Defined_predicate -> Defined_predicate -> Bool
compare :: Defined_predicate -> Defined_predicate -> Ordering
$ccompare :: Defined_predicate -> Defined_predicate -> Ordering
$cp1Ord :: Eq Defined_predicate
Ord, Defined_predicate -> Defined_predicate -> Bool
(Defined_predicate -> Defined_predicate -> Bool)
-> (Defined_predicate -> Defined_predicate -> Bool)
-> Eq Defined_predicate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Defined_predicate -> Defined_predicate -> Bool
$c/= :: Defined_predicate -> Defined_predicate -> Bool
== :: Defined_predicate -> Defined_predicate -> Bool
$c== :: Defined_predicate -> Defined_predicate -> Bool
Eq, Typeable Defined_predicate
Constr
DataType
Typeable Defined_predicate =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> Defined_predicate
 -> c Defined_predicate)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Defined_predicate)
-> (Defined_predicate -> Constr)
-> (Defined_predicate -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Defined_predicate))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Defined_predicate))
-> ((forall b. Data b => b -> b)
    -> Defined_predicate -> Defined_predicate)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Defined_predicate -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Defined_predicate -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Defined_predicate -> m Defined_predicate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Defined_predicate -> m Defined_predicate)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Defined_predicate -> m Defined_predicate)
-> Data Defined_predicate
Defined_predicate -> Constr
Defined_predicate -> DataType
(forall b. Data b => b -> b)
-> Defined_predicate -> Defined_predicate
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_predicate -> c Defined_predicate
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_predicate
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) -> Defined_predicate -> u
forall u. (forall d. Data d => d -> u) -> Defined_predicate -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_predicate
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_predicate -> c Defined_predicate
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Defined_predicate)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Defined_predicate)
$cDia :: Constr
$cDia_int :: Constr
$cDia_i :: Constr
$cDia_P :: Constr
$cBox :: Constr
$cBox_int :: Constr
$cBox_i :: Constr
$cBox_P :: Constr
$cIs_rat :: Constr
$cIs_int :: Constr
$cGreatereq :: Constr
$cGreater :: Constr
$cLesseq :: Constr
$cLess :: Constr
$cDistinct :: Constr
$tDefined_predicate :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
gmapMp :: (forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
gmapM :: (forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Defined_predicate -> m Defined_predicate
gmapQi :: Int -> (forall d. Data d => d -> u) -> Defined_predicate -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Defined_predicate -> u
gmapQ :: (forall d. Data d => d -> u) -> Defined_predicate -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Defined_predicate -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Defined_predicate -> r
gmapT :: (forall b. Data b => b -> b)
-> Defined_predicate -> Defined_predicate
$cgmapT :: (forall b. Data b => b -> b)
-> Defined_predicate -> Defined_predicate
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Defined_predicate)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Defined_predicate)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Defined_predicate)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Defined_predicate)
dataTypeOf :: Defined_predicate -> DataType
$cdataTypeOf :: Defined_predicate -> DataType
toConstr :: Defined_predicate -> Constr
$ctoConstr :: Defined_predicate -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_predicate
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Defined_predicate
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_predicate -> c Defined_predicate
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Defined_predicate -> c Defined_predicate
$cp1Data :: Typeable Defined_predicate
Data, Typeable)

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

-- <constant>             ::= <functor>
type Constant = TPTP_functor

-- <functor>              ::= <atomic_word>
type TPTP_functor = Token

-- <system_constant>      ::= <system_functor>
type System_constant = System_functor

-- <system_functor>       ::= <atomic_system_word>
type System_functor = Token

-- <defined_constant>     ::= <defined_functor>
type Defined_constant = Defined_functor

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

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

-- <variable>             ::= <upper_word>
type Variable = Token


-- %----Formula sources
-- <source>               ::= <general_term>
-- <source>               :== <dag_source> | <internal_source> |
--                            <external_source> | unknown | [<sources>]
data Source = Source_DAG DAG_source
            | Source_internal Internal_source
            | Source_external External_source
            | Unknown_source
            | Source_many Sources
              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, 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, 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, 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)
$cSource_many :: Constr
$cUnknown_source :: Constr
$cSource_external :: Constr
$cSource_internal :: Constr
$cSource_DAG :: 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, Typeable)

-- %----Alternative sources are recorded like this, thus allowing representation
-- %----of alternative derivations with shared parts.
-- <sources>              :== <source> | <source>,<sources>
type Sources = [Source]

-- %----Only a <dag_source> can be a <name>, i.e., derived formulae can be
-- %----identified by a <name> or an <inference_record>
-- <dag_source>           :== <name> | <inference_record>
data DAG_source = DAGS_name Name
                | DAGS_record Inference_record
                  deriving (Int -> DAG_source -> ShowS
[DAG_source] -> ShowS
DAG_source -> String
(Int -> DAG_source -> ShowS)
-> (DAG_source -> String)
-> ([DAG_source] -> ShowS)
-> Show DAG_source
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DAG_source] -> ShowS
$cshowList :: [DAG_source] -> ShowS
show :: DAG_source -> String
$cshow :: DAG_source -> String
showsPrec :: Int -> DAG_source -> ShowS
$cshowsPrec :: Int -> DAG_source -> ShowS
Show, Eq DAG_source
Eq DAG_source =>
(DAG_source -> DAG_source -> Ordering)
-> (DAG_source -> DAG_source -> Bool)
-> (DAG_source -> DAG_source -> Bool)
-> (DAG_source -> DAG_source -> Bool)
-> (DAG_source -> DAG_source -> Bool)
-> (DAG_source -> DAG_source -> DAG_source)
-> (DAG_source -> DAG_source -> DAG_source)
-> Ord DAG_source
DAG_source -> DAG_source -> Bool
DAG_source -> DAG_source -> Ordering
DAG_source -> DAG_source -> DAG_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 :: DAG_source -> DAG_source -> DAG_source
$cmin :: DAG_source -> DAG_source -> DAG_source
max :: DAG_source -> DAG_source -> DAG_source
$cmax :: DAG_source -> DAG_source -> DAG_source
>= :: DAG_source -> DAG_source -> Bool
$c>= :: DAG_source -> DAG_source -> Bool
> :: DAG_source -> DAG_source -> Bool
$c> :: DAG_source -> DAG_source -> Bool
<= :: DAG_source -> DAG_source -> Bool
$c<= :: DAG_source -> DAG_source -> Bool
< :: DAG_source -> DAG_source -> Bool
$c< :: DAG_source -> DAG_source -> Bool
compare :: DAG_source -> DAG_source -> Ordering
$ccompare :: DAG_source -> DAG_source -> Ordering
$cp1Ord :: Eq DAG_source
Ord, DAG_source -> DAG_source -> Bool
(DAG_source -> DAG_source -> Bool)
-> (DAG_source -> DAG_source -> Bool) -> Eq DAG_source
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DAG_source -> DAG_source -> Bool
$c/= :: DAG_source -> DAG_source -> Bool
== :: DAG_source -> DAG_source -> Bool
$c== :: DAG_source -> DAG_source -> Bool
Eq, Typeable DAG_source
Constr
DataType
Typeable DAG_source =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DAG_source -> c DAG_source)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DAG_source)
-> (DAG_source -> Constr)
-> (DAG_source -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DAG_source))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DAG_source))
-> ((forall b. Data b => b -> b) -> DAG_source -> DAG_source)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DAG_source -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DAG_source -> r)
-> (forall u. (forall d. Data d => d -> u) -> DAG_source -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DAG_source -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DAG_source -> m DAG_source)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DAG_source -> m DAG_source)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DAG_source -> m DAG_source)
-> Data DAG_source
DAG_source -> Constr
DAG_source -> DataType
(forall b. Data b => b -> b) -> DAG_source -> DAG_source
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DAG_source -> c DAG_source
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DAG_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) -> DAG_source -> u
forall u. (forall d. Data d => d -> u) -> DAG_source -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DAG_source -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DAG_source -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DAG_source
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DAG_source -> c DAG_source
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DAG_source)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DAG_source)
$cDAGS_record :: Constr
$cDAGS_name :: Constr
$tDAG_source :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
gmapMp :: (forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
gmapM :: (forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DAG_source -> m DAG_source
gmapQi :: Int -> (forall d. Data d => d -> u) -> DAG_source -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DAG_source -> u
gmapQ :: (forall d. Data d => d -> u) -> DAG_source -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DAG_source -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DAG_source -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DAG_source -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DAG_source -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DAG_source -> r
gmapT :: (forall b. Data b => b -> b) -> DAG_source -> DAG_source
$cgmapT :: (forall b. Data b => b -> b) -> DAG_source -> DAG_source
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DAG_source)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DAG_source)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DAG_source)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DAG_source)
dataTypeOf :: DAG_source -> DataType
$cdataTypeOf :: DAG_source -> DataType
toConstr :: DAG_source -> Constr
$ctoConstr :: DAG_source -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DAG_source
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DAG_source
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DAG_source -> c DAG_source
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DAG_source -> c DAG_source
$cp1Data :: Typeable DAG_source
Data, Typeable)

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

-- <inference_rule>       :== <atomic_word>
-- %----Examples are          deduction | modus_tollens | modus_ponens | rewrite |
-- %                          resolution | paramodulation | factorization |
-- %                          cnf_conversion | cnf_refutation | ...
type Inference_rule = Token

-- %----<inference_parents> can be empty in cases when there is a justification
-- %----for a tautologous theorem. In case when a tautology is introduced as
-- %----a leaf, e.g., for splitting, then use an <internal_source>.
-- <inference_parents>    :== [] | [<parent_list>]
type Inference_parents = Parent_list

-- <parent_list>          :== <parent_info> | <parent_info>,<parent_list>
type Parent_list = [Parent_info]

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

-- <parent_details>       :== :<general_list> | <null>
type Parent_details = Maybe General_list

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

-- <intro_type>           :== definition | axiom_of_choice | tautology | assumption
-- %----This should be used to record the symbol being defined, or the function
-- %----for the axiom of choice
data Intro_type = IntroTypeDefinition
                | AxiomOfChoice
                | Tautology
                | IntroTypeAssumption
                  deriving (Int -> Intro_type -> ShowS
[Intro_type] -> ShowS
Intro_type -> String
(Int -> Intro_type -> ShowS)
-> (Intro_type -> String)
-> ([Intro_type] -> ShowS)
-> Show Intro_type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Intro_type] -> ShowS
$cshowList :: [Intro_type] -> ShowS
show :: Intro_type -> String
$cshow :: Intro_type -> String
showsPrec :: Int -> Intro_type -> ShowS
$cshowsPrec :: Int -> Intro_type -> ShowS
Show, Eq Intro_type
Eq Intro_type =>
(Intro_type -> Intro_type -> Ordering)
-> (Intro_type -> Intro_type -> Bool)
-> (Intro_type -> Intro_type -> Bool)
-> (Intro_type -> Intro_type -> Bool)
-> (Intro_type -> Intro_type -> Bool)
-> (Intro_type -> Intro_type -> Intro_type)
-> (Intro_type -> Intro_type -> Intro_type)
-> Ord Intro_type
Intro_type -> Intro_type -> Bool
Intro_type -> Intro_type -> Ordering
Intro_type -> Intro_type -> Intro_type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Intro_type -> Intro_type -> Intro_type
$cmin :: Intro_type -> Intro_type -> Intro_type
max :: Intro_type -> Intro_type -> Intro_type
$cmax :: Intro_type -> Intro_type -> Intro_type
>= :: Intro_type -> Intro_type -> Bool
$c>= :: Intro_type -> Intro_type -> Bool
> :: Intro_type -> Intro_type -> Bool
$c> :: Intro_type -> Intro_type -> Bool
<= :: Intro_type -> Intro_type -> Bool
$c<= :: Intro_type -> Intro_type -> Bool
< :: Intro_type -> Intro_type -> Bool
$c< :: Intro_type -> Intro_type -> Bool
compare :: Intro_type -> Intro_type -> Ordering
$ccompare :: Intro_type -> Intro_type -> Ordering
$cp1Ord :: Eq Intro_type
Ord, Intro_type -> Intro_type -> Bool
(Intro_type -> Intro_type -> Bool)
-> (Intro_type -> Intro_type -> Bool) -> Eq Intro_type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Intro_type -> Intro_type -> Bool
$c/= :: Intro_type -> Intro_type -> Bool
== :: Intro_type -> Intro_type -> Bool
$c== :: Intro_type -> Intro_type -> Bool
Eq, Typeable Intro_type
Constr
DataType
Typeable Intro_type =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Intro_type -> c Intro_type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Intro_type)
-> (Intro_type -> Constr)
-> (Intro_type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Intro_type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Intro_type))
-> ((forall b. Data b => b -> b) -> Intro_type -> Intro_type)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Intro_type -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Intro_type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Intro_type -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Intro_type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Intro_type -> m Intro_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Intro_type -> m Intro_type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Intro_type -> m Intro_type)
-> Data Intro_type
Intro_type -> Constr
Intro_type -> DataType
(forall b. Data b => b -> b) -> Intro_type -> Intro_type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intro_type -> c Intro_type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Intro_type
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Intro_type -> u
forall u. (forall d. Data d => d -> u) -> Intro_type -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Intro_type -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Intro_type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Intro_type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intro_type -> c Intro_type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Intro_type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Intro_type)
$cIntroTypeAssumption :: Constr
$cTautology :: Constr
$cAxiomOfChoice :: Constr
$cIntroTypeDefinition :: Constr
$tIntro_type :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
gmapMp :: (forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
gmapM :: (forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Intro_type -> m Intro_type
gmapQi :: Int -> (forall d. Data d => d -> u) -> Intro_type -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Intro_type -> u
gmapQ :: (forall d. Data d => d -> u) -> Intro_type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Intro_type -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Intro_type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Intro_type -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Intro_type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Intro_type -> r
gmapT :: (forall b. Data b => b -> b) -> Intro_type -> Intro_type
$cgmapT :: (forall b. Data b => b -> b) -> Intro_type -> Intro_type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Intro_type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Intro_type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Intro_type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Intro_type)
dataTypeOf :: Intro_type -> DataType
$cdataTypeOf :: Intro_type -> DataType
toConstr :: Intro_type -> Constr
$ctoConstr :: Intro_type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Intro_type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Intro_type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intro_type -> c Intro_type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Intro_type -> c Intro_type
$cp1Data :: Typeable Intro_type
Data, Typeable)

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

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

-- <file_info>            :== ,<name> | <null>
type File_info = Maybe Name

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

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

-- %----More theory names may be added in the future. The <optional_info> is
-- %----used to store, e.g., which axioms of equality have been implicitly used,
-- %----e.g., theory(equality,[rst]). Standard format still to be decided.
-- <creator_source>       :== creator(<creator_name><optional_info>)
data Creator_source = Creator_source Creator_name Optional_info
                      deriving (Int -> Creator_source -> ShowS
[Creator_source] -> ShowS
Creator_source -> String
(Int -> Creator_source -> ShowS)
-> (Creator_source -> String)
-> ([Creator_source] -> ShowS)
-> Show Creator_source
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Creator_source] -> ShowS
$cshowList :: [Creator_source] -> ShowS
show :: Creator_source -> String
$cshow :: Creator_source -> String
showsPrec :: Int -> Creator_source -> ShowS
$cshowsPrec :: Int -> Creator_source -> ShowS
Show, Eq Creator_source
Eq Creator_source =>
(Creator_source -> Creator_source -> Ordering)
-> (Creator_source -> Creator_source -> Bool)
-> (Creator_source -> Creator_source -> Bool)
-> (Creator_source -> Creator_source -> Bool)
-> (Creator_source -> Creator_source -> Bool)
-> (Creator_source -> Creator_source -> Creator_source)
-> (Creator_source -> Creator_source -> Creator_source)
-> Ord Creator_source
Creator_source -> Creator_source -> Bool
Creator_source -> Creator_source -> Ordering
Creator_source -> Creator_source -> Creator_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 :: Creator_source -> Creator_source -> Creator_source
$cmin :: Creator_source -> Creator_source -> Creator_source
max :: Creator_source -> Creator_source -> Creator_source
$cmax :: Creator_source -> Creator_source -> Creator_source
>= :: Creator_source -> Creator_source -> Bool
$c>= :: Creator_source -> Creator_source -> Bool
> :: Creator_source -> Creator_source -> Bool
$c> :: Creator_source -> Creator_source -> Bool
<= :: Creator_source -> Creator_source -> Bool
$c<= :: Creator_source -> Creator_source -> Bool
< :: Creator_source -> Creator_source -> Bool
$c< :: Creator_source -> Creator_source -> Bool
compare :: Creator_source -> Creator_source -> Ordering
$ccompare :: Creator_source -> Creator_source -> Ordering
$cp1Ord :: Eq Creator_source
Ord, Creator_source -> Creator_source -> Bool
(Creator_source -> Creator_source -> Bool)
-> (Creator_source -> Creator_source -> Bool) -> Eq Creator_source
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Creator_source -> Creator_source -> Bool
$c/= :: Creator_source -> Creator_source -> Bool
== :: Creator_source -> Creator_source -> Bool
$c== :: Creator_source -> Creator_source -> Bool
Eq, Typeable Creator_source
Constr
DataType
Typeable Creator_source =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Creator_source -> c Creator_source)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Creator_source)
-> (Creator_source -> Constr)
-> (Creator_source -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Creator_source))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Creator_source))
-> ((forall b. Data b => b -> b)
    -> Creator_source -> Creator_source)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Creator_source -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Creator_source -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Creator_source -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Creator_source -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Creator_source -> m Creator_source)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Creator_source -> m Creator_source)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Creator_source -> m Creator_source)
-> Data Creator_source
Creator_source -> Constr
Creator_source -> DataType
(forall b. Data b => b -> b) -> Creator_source -> Creator_source
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Creator_source -> c Creator_source
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Creator_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) -> Creator_source -> u
forall u. (forall d. Data d => d -> u) -> Creator_source -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Creator_source -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Creator_source -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Creator_source
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Creator_source -> c Creator_source
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Creator_source)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Creator_source)
$cCreator_source :: Constr
$tCreator_source :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
gmapMp :: (forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
gmapM :: (forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Creator_source -> m Creator_source
gmapQi :: Int -> (forall d. Data d => d -> u) -> Creator_source -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Creator_source -> u
gmapQ :: (forall d. Data d => d -> u) -> Creator_source -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Creator_source -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Creator_source -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Creator_source -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Creator_source -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Creator_source -> r
gmapT :: (forall b. Data b => b -> b) -> Creator_source -> Creator_source
$cgmapT :: (forall b. Data b => b -> b) -> Creator_source -> Creator_source
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Creator_source)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Creator_source)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Creator_source)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Creator_source)
dataTypeOf :: Creator_source -> DataType
$cdataTypeOf :: Creator_source -> DataType
toConstr :: Creator_source -> Constr
$ctoConstr :: Creator_source -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Creator_source
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Creator_source
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Creator_source -> c Creator_source
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Creator_source -> c Creator_source
$cp1Data :: Typeable Creator_source
Data, Typeable)

-- <creator_name>         :== <atomic_word>
type Creator_name = Token


-- %----Useful info fields
-- <optional_info>        ::= ,<useful_info> | <null>
type Optional_info = Maybe Useful_info

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

-- <info_items>           :== <info_item> | <info_item>,<info_items>
type Info_items = [Info_item]

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

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

-- <description_item>     :== description(<atomic_word>)
type Description_item = Token

-- <iquote_item>          :== iquote(<atomic_word>)
-- %----<iquote_item>s are used for recording exactly what the system output about
-- %----the inference step. In the future it is planned to encode this information
-- %----in standardized forms as <parent_details> in each <inference_record>.
-- %----Useful info for inference records
type Iquote_item = Token

-- <inference_item>       :== <inference_status> | <assumptions_record> |
--                            <new_symbol_record> | <refutation>
data Inference_item = Inf_status Inference_status
                    | Inf_assumption Assumptions_record
                    | Inf_symbol New_symbol_record
                    | Inf_refutation Refutation
                      deriving (Int -> Inference_item -> ShowS
[Inference_item] -> ShowS
Inference_item -> String
(Int -> Inference_item -> ShowS)
-> (Inference_item -> String)
-> ([Inference_item] -> ShowS)
-> Show Inference_item
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Inference_item] -> ShowS
$cshowList :: [Inference_item] -> ShowS
show :: Inference_item -> String
$cshow :: Inference_item -> String
showsPrec :: Int -> Inference_item -> ShowS
$cshowsPrec :: Int -> Inference_item -> ShowS
Show, Eq Inference_item
Eq Inference_item =>
(Inference_item -> Inference_item -> Ordering)
-> (Inference_item -> Inference_item -> Bool)
-> (Inference_item -> Inference_item -> Bool)
-> (Inference_item -> Inference_item -> Bool)
-> (Inference_item -> Inference_item -> Bool)
-> (Inference_item -> Inference_item -> Inference_item)
-> (Inference_item -> Inference_item -> Inference_item)
-> Ord Inference_item
Inference_item -> Inference_item -> Bool
Inference_item -> Inference_item -> Ordering
Inference_item -> Inference_item -> Inference_item
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 :: Inference_item -> Inference_item -> Inference_item
$cmin :: Inference_item -> Inference_item -> Inference_item
max :: Inference_item -> Inference_item -> Inference_item
$cmax :: Inference_item -> Inference_item -> Inference_item
>= :: Inference_item -> Inference_item -> Bool
$c>= :: Inference_item -> Inference_item -> Bool
> :: Inference_item -> Inference_item -> Bool
$c> :: Inference_item -> Inference_item -> Bool
<= :: Inference_item -> Inference_item -> Bool
$c<= :: Inference_item -> Inference_item -> Bool
< :: Inference_item -> Inference_item -> Bool
$c< :: Inference_item -> Inference_item -> Bool
compare :: Inference_item -> Inference_item -> Ordering
$ccompare :: Inference_item -> Inference_item -> Ordering
$cp1Ord :: Eq Inference_item
Ord, Inference_item -> Inference_item -> Bool
(Inference_item -> Inference_item -> Bool)
-> (Inference_item -> Inference_item -> Bool) -> Eq Inference_item
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Inference_item -> Inference_item -> Bool
$c/= :: Inference_item -> Inference_item -> Bool
== :: Inference_item -> Inference_item -> Bool
$c== :: Inference_item -> Inference_item -> Bool
Eq, Typeable Inference_item
Constr
DataType
Typeable Inference_item =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Inference_item -> c Inference_item)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inference_item)
-> (Inference_item -> Constr)
-> (Inference_item -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inference_item))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Inference_item))
-> ((forall b. Data b => b -> b)
    -> Inference_item -> Inference_item)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Inference_item -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Inference_item -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Inference_item -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Inference_item -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Inference_item -> m Inference_item)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Inference_item -> m Inference_item)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Inference_item -> m Inference_item)
-> Data Inference_item
Inference_item -> Constr
Inference_item -> DataType
(forall b. Data b => b -> b) -> Inference_item -> Inference_item
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_item -> c Inference_item
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_item
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) -> Inference_item -> u
forall u. (forall d. Data d => d -> u) -> Inference_item -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_item -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_item -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_item
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_item -> c Inference_item
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inference_item)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Inference_item)
$cInf_refutation :: Constr
$cInf_symbol :: Constr
$cInf_assumption :: Constr
$cInf_status :: Constr
$tInference_item :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
gmapMp :: (forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
gmapM :: (forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Inference_item -> m Inference_item
gmapQi :: Int -> (forall d. Data d => d -> u) -> Inference_item -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Inference_item -> u
gmapQ :: (forall d. Data d => d -> u) -> Inference_item -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Inference_item -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_item -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_item -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_item -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_item -> r
gmapT :: (forall b. Data b => b -> b) -> Inference_item -> Inference_item
$cgmapT :: (forall b. Data b => b -> b) -> Inference_item -> Inference_item
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Inference_item)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Inference_item)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Inference_item)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inference_item)
dataTypeOf :: Inference_item -> DataType
$cdataTypeOf :: Inference_item -> DataType
toConstr :: Inference_item -> Constr
$ctoConstr :: Inference_item -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_item
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_item
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_item -> c Inference_item
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_item -> c Inference_item
$cp1Data :: Typeable Inference_item
Data, Typeable)

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

-- %----These are the success status values from the SZS ontology. The most
-- %----commonly used values are:
-- %----  thm - Every model of the parent formulae is a model of the inferred
-- %----        formula. Regular logical consequences.
-- %----  cth - Every model of the parent formulae is a model of the negation of
-- %----        the inferred formula. Used for negation of conjectures in FOF to
-- %----        CNF conversion.
-- %----  esa - There exists a model of the parent formulae iff there exists a
-- %----        model of the inferred formula. Used for Skolemization steps.
-- %----For the full hierarchy see the SZSOntology file distributed with the TPTP.
-- <status_value>         :== 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
data Status_value = 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 -> Status_value -> ShowS
[Status_value] -> ShowS
Status_value -> String
(Int -> Status_value -> ShowS)
-> (Status_value -> String)
-> ([Status_value] -> ShowS)
-> Show Status_value
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Status_value] -> ShowS
$cshowList :: [Status_value] -> ShowS
show :: Status_value -> String
$cshow :: Status_value -> String
showsPrec :: Int -> Status_value -> ShowS
$cshowsPrec :: Int -> Status_value -> ShowS
Show, Eq Status_value
Eq Status_value =>
(Status_value -> Status_value -> Ordering)
-> (Status_value -> Status_value -> Bool)
-> (Status_value -> Status_value -> Bool)
-> (Status_value -> Status_value -> Bool)
-> (Status_value -> Status_value -> Bool)
-> (Status_value -> Status_value -> Status_value)
-> (Status_value -> Status_value -> Status_value)
-> Ord Status_value
Status_value -> Status_value -> Bool
Status_value -> Status_value -> Ordering
Status_value -> Status_value -> Status_value
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 :: Status_value -> Status_value -> Status_value
$cmin :: Status_value -> Status_value -> Status_value
max :: Status_value -> Status_value -> Status_value
$cmax :: Status_value -> Status_value -> Status_value
>= :: Status_value -> Status_value -> Bool
$c>= :: Status_value -> Status_value -> Bool
> :: Status_value -> Status_value -> Bool
$c> :: Status_value -> Status_value -> Bool
<= :: Status_value -> Status_value -> Bool
$c<= :: Status_value -> Status_value -> Bool
< :: Status_value -> Status_value -> Bool
$c< :: Status_value -> Status_value -> Bool
compare :: Status_value -> Status_value -> Ordering
$ccompare :: Status_value -> Status_value -> Ordering
$cp1Ord :: Eq Status_value
Ord, Status_value -> Status_value -> Bool
(Status_value -> Status_value -> Bool)
-> (Status_value -> Status_value -> Bool) -> Eq Status_value
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Status_value -> Status_value -> Bool
$c/= :: Status_value -> Status_value -> Bool
== :: Status_value -> Status_value -> Bool
$c== :: Status_value -> Status_value -> Bool
Eq, Typeable Status_value
Constr
DataType
Typeable Status_value =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Status_value -> c Status_value)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Status_value)
-> (Status_value -> Constr)
-> (Status_value -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Status_value))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Status_value))
-> ((forall b. Data b => b -> b) -> Status_value -> Status_value)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Status_value -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Status_value -> r)
-> (forall u. (forall d. Data d => d -> u) -> Status_value -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Status_value -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Status_value -> m Status_value)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Status_value -> m Status_value)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Status_value -> m Status_value)
-> Data Status_value
Status_value -> Constr
Status_value -> DataType
(forall b. Data b => b -> b) -> Status_value -> Status_value
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Status_value -> c Status_value
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Status_value
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) -> Status_value -> u
forall u. (forall d. Data d => d -> u) -> Status_value -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Status_value -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Status_value -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Status_value -> m Status_value
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Status_value -> m Status_value
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Status_value
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Status_value -> c Status_value
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Status_value)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Status_value)
$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
$tStatus_value :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Status_value -> m Status_value
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Status_value -> m Status_value
gmapMp :: (forall d. Data d => d -> m d) -> Status_value -> m Status_value
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Status_value -> m Status_value
gmapM :: (forall d. Data d => d -> m d) -> Status_value -> m Status_value
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Status_value -> m Status_value
gmapQi :: Int -> (forall d. Data d => d -> u) -> Status_value -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Status_value -> u
gmapQ :: (forall d. Data d => d -> u) -> Status_value -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Status_value -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Status_value -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Status_value -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Status_value -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Status_value -> r
gmapT :: (forall b. Data b => b -> b) -> Status_value -> Status_value
$cgmapT :: (forall b. Data b => b -> b) -> Status_value -> Status_value
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Status_value)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Status_value)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Status_value)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Status_value)
dataTypeOf :: Status_value -> DataType
$cdataTypeOf :: Status_value -> DataType
toConstr :: Status_value -> Constr
$ctoConstr :: Status_value -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Status_value
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Status_value
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Status_value -> c Status_value
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Status_value -> c Status_value
$cp1Data :: Typeable Status_value
Data, Typeable)

-- %----<inference_info> is used to record standard information associated with an
-- %----arbitrary inference rule. The <inference_rule> is the same as the
-- %----<inference_rule> of the <inference_record>. The <atomic_word> indicates
-- %----the information being recorded in the <general_list>. The <atomic_word>
-- %----are (loosely) set by TPTP conventions, and include esplit, sr_split, and
-- %----discharge.
-- <inference_info>       :== <inference_rule>(<atomic_word>,<general_list>)
data Inference_info = Inference_info Inference_rule Atomic_word General_list
                      deriving (Int -> Inference_info -> ShowS
[Inference_info] -> ShowS
Inference_info -> String
(Int -> Inference_info -> ShowS)
-> (Inference_info -> String)
-> ([Inference_info] -> ShowS)
-> Show Inference_info
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Inference_info] -> ShowS
$cshowList :: [Inference_info] -> ShowS
show :: Inference_info -> String
$cshow :: Inference_info -> String
showsPrec :: Int -> Inference_info -> ShowS
$cshowsPrec :: Int -> Inference_info -> ShowS
Show, Eq Inference_info
Eq Inference_info =>
(Inference_info -> Inference_info -> Ordering)
-> (Inference_info -> Inference_info -> Bool)
-> (Inference_info -> Inference_info -> Bool)
-> (Inference_info -> Inference_info -> Bool)
-> (Inference_info -> Inference_info -> Bool)
-> (Inference_info -> Inference_info -> Inference_info)
-> (Inference_info -> Inference_info -> Inference_info)
-> Ord Inference_info
Inference_info -> Inference_info -> Bool
Inference_info -> Inference_info -> Ordering
Inference_info -> Inference_info -> Inference_info
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 :: Inference_info -> Inference_info -> Inference_info
$cmin :: Inference_info -> Inference_info -> Inference_info
max :: Inference_info -> Inference_info -> Inference_info
$cmax :: Inference_info -> Inference_info -> Inference_info
>= :: Inference_info -> Inference_info -> Bool
$c>= :: Inference_info -> Inference_info -> Bool
> :: Inference_info -> Inference_info -> Bool
$c> :: Inference_info -> Inference_info -> Bool
<= :: Inference_info -> Inference_info -> Bool
$c<= :: Inference_info -> Inference_info -> Bool
< :: Inference_info -> Inference_info -> Bool
$c< :: Inference_info -> Inference_info -> Bool
compare :: Inference_info -> Inference_info -> Ordering
$ccompare :: Inference_info -> Inference_info -> Ordering
$cp1Ord :: Eq Inference_info
Ord, Inference_info -> Inference_info -> Bool
(Inference_info -> Inference_info -> Bool)
-> (Inference_info -> Inference_info -> Bool) -> Eq Inference_info
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Inference_info -> Inference_info -> Bool
$c/= :: Inference_info -> Inference_info -> Bool
== :: Inference_info -> Inference_info -> Bool
$c== :: Inference_info -> Inference_info -> Bool
Eq, Typeable Inference_info
Constr
DataType
Typeable Inference_info =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Inference_info -> c Inference_info)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Inference_info)
-> (Inference_info -> Constr)
-> (Inference_info -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Inference_info))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Inference_info))
-> ((forall b. Data b => b -> b)
    -> Inference_info -> Inference_info)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Inference_info -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Inference_info -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Inference_info -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Inference_info -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Inference_info -> m Inference_info)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Inference_info -> m Inference_info)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Inference_info -> m Inference_info)
-> Data Inference_info
Inference_info -> Constr
Inference_info -> DataType
(forall b. Data b => b -> b) -> Inference_info -> Inference_info
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_info -> c Inference_info
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_info
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) -> Inference_info -> u
forall u. (forall d. Data d => d -> u) -> Inference_info -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_info -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_info -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_info
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_info -> c Inference_info
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inference_info)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Inference_info)
$cInference_info :: Constr
$tInference_info :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
gmapMp :: (forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
gmapM :: (forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Inference_info -> m Inference_info
gmapQi :: Int -> (forall d. Data d => d -> u) -> Inference_info -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Inference_info -> u
gmapQ :: (forall d. Data d => d -> u) -> Inference_info -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Inference_info -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_info -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_info -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_info -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Inference_info -> r
gmapT :: (forall b. Data b => b -> b) -> Inference_info -> Inference_info
$cgmapT :: (forall b. Data b => b -> b) -> Inference_info -> Inference_info
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Inference_info)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Inference_info)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Inference_info)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Inference_info)
dataTypeOf :: Inference_info -> DataType
$cdataTypeOf :: Inference_info -> DataType
toConstr :: Inference_info -> Constr
$ctoConstr :: Inference_info -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_info
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Inference_info
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_info -> c Inference_info
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Inference_info -> c Inference_info
$cp1Data :: Typeable Inference_info
Data, Typeable)

-- %----An <assumptions_record> lists the names of assumptions upon which this
-- %----inferred formula depends. These must be discharged in a completed proof.
-- <assumptions_record>   :== assumptions([<name_list>])
type Assumptions_record = Name_list

-- %----A <refutation> record names a file in which the inference recorded here
-- %----is recorded as a proof by refutation.
-- <refutation>           :== refutation(<file_source>)
type Refutation = File_source

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

-- <new_symbol_list>      :== <principal_symbol> |
--                            <principal_symbol>,<new_symbol_list>
type New_symbol_list = [Principal_symbol]

-- %----Principal symbols are predicates, functions, variables
-- <principal_symbol>   :== <functor> | <variable>
data Principal_symbol = PS_functor TPTP_functor
                      | PS_variable Variable
                        deriving (Int -> Principal_symbol -> ShowS
[Principal_symbol] -> ShowS
Principal_symbol -> String
(Int -> Principal_symbol -> ShowS)
-> (Principal_symbol -> String)
-> ([Principal_symbol] -> ShowS)
-> Show Principal_symbol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Principal_symbol] -> ShowS
$cshowList :: [Principal_symbol] -> ShowS
show :: Principal_symbol -> String
$cshow :: Principal_symbol -> String
showsPrec :: Int -> Principal_symbol -> ShowS
$cshowsPrec :: Int -> Principal_symbol -> ShowS
Show, Eq Principal_symbol
Eq Principal_symbol =>
(Principal_symbol -> Principal_symbol -> Ordering)
-> (Principal_symbol -> Principal_symbol -> Bool)
-> (Principal_symbol -> Principal_symbol -> Bool)
-> (Principal_symbol -> Principal_symbol -> Bool)
-> (Principal_symbol -> Principal_symbol -> Bool)
-> (Principal_symbol -> Principal_symbol -> Principal_symbol)
-> (Principal_symbol -> Principal_symbol -> Principal_symbol)
-> Ord Principal_symbol
Principal_symbol -> Principal_symbol -> Bool
Principal_symbol -> Principal_symbol -> Ordering
Principal_symbol -> Principal_symbol -> Principal_symbol
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Principal_symbol -> Principal_symbol -> Principal_symbol
$cmin :: Principal_symbol -> Principal_symbol -> Principal_symbol
max :: Principal_symbol -> Principal_symbol -> Principal_symbol
$cmax :: Principal_symbol -> Principal_symbol -> Principal_symbol
>= :: Principal_symbol -> Principal_symbol -> Bool
$c>= :: Principal_symbol -> Principal_symbol -> Bool
> :: Principal_symbol -> Principal_symbol -> Bool
$c> :: Principal_symbol -> Principal_symbol -> Bool
<= :: Principal_symbol -> Principal_symbol -> Bool
$c<= :: Principal_symbol -> Principal_symbol -> Bool
< :: Principal_symbol -> Principal_symbol -> Bool
$c< :: Principal_symbol -> Principal_symbol -> Bool
compare :: Principal_symbol -> Principal_symbol -> Ordering
$ccompare :: Principal_symbol -> Principal_symbol -> Ordering
$cp1Ord :: Eq Principal_symbol
Ord, Principal_symbol -> Principal_symbol -> Bool
(Principal_symbol -> Principal_symbol -> Bool)
-> (Principal_symbol -> Principal_symbol -> Bool)
-> Eq Principal_symbol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Principal_symbol -> Principal_symbol -> Bool
$c/= :: Principal_symbol -> Principal_symbol -> Bool
== :: Principal_symbol -> Principal_symbol -> Bool
$c== :: Principal_symbol -> Principal_symbol -> Bool
Eq, Typeable Principal_symbol
Constr
DataType
Typeable Principal_symbol =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Principal_symbol -> c Principal_symbol)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Principal_symbol)
-> (Principal_symbol -> Constr)
-> (Principal_symbol -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Principal_symbol))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Principal_symbol))
-> ((forall b. Data b => b -> b)
    -> Principal_symbol -> Principal_symbol)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Principal_symbol -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Principal_symbol -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Principal_symbol -> m Principal_symbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Principal_symbol -> m Principal_symbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Principal_symbol -> m Principal_symbol)
-> Data Principal_symbol
Principal_symbol -> Constr
Principal_symbol -> DataType
(forall b. Data b => b -> b)
-> Principal_symbol -> Principal_symbol
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Principal_symbol -> c Principal_symbol
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Principal_symbol
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Principal_symbol -> u
forall u. (forall d. Data d => d -> u) -> Principal_symbol -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Principal_symbol
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Principal_symbol -> c Principal_symbol
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Principal_symbol)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Principal_symbol)
$cPS_variable :: Constr
$cPS_functor :: Constr
$tPrincipal_symbol :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
gmapMp :: (forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
gmapM :: (forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Principal_symbol -> m Principal_symbol
gmapQi :: Int -> (forall d. Data d => d -> u) -> Principal_symbol -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Principal_symbol -> u
gmapQ :: (forall d. Data d => d -> u) -> Principal_symbol -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Principal_symbol -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Principal_symbol -> r
gmapT :: (forall b. Data b => b -> b)
-> Principal_symbol -> Principal_symbol
$cgmapT :: (forall b. Data b => b -> b)
-> Principal_symbol -> Principal_symbol
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Principal_symbol)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Principal_symbol)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Principal_symbol)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Principal_symbol)
dataTypeOf :: Principal_symbol -> DataType
$cdataTypeOf :: Principal_symbol -> DataType
toConstr :: Principal_symbol -> Constr
$ctoConstr :: Principal_symbol -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Principal_symbol
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Principal_symbol
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Principal_symbol -> c Principal_symbol
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Principal_symbol -> c Principal_symbol
$cp1Data :: Typeable Principal_symbol
Data, Typeable)

-- %----Include directives
-- <include>              ::= include(<file_name><formula_selection>).
data Include = Include File_name Formula_selection
               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, 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, 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, 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)
$cInclude :: 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, Typeable)

-- <formula_selection>    ::= ,[<name_list>] | <null>
type Formula_selection = Maybe [Name]

-- <name_list>            ::= <name> | <name>,<name_list>
type Name_list = [Name]


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

-- <general_data>         ::= <atomic_word> | <general_function> |
--                            <variable> | <number> | <distinct_object> |
--                            <formula_data>
data General_data = GD_atomic_word Atomic_word
                  | GD_general_function General_function
                  | GD_variable Variable
                  | GD_number Number
                  | GD_distinct_object Distinct_object
                  | GD_formula_data Formula_data
-- %----A <general_data> bind() term is used to record a variable binding in an
-- %----inference, as an element of the <parent_details> list.
-- <general_data>         :== bind(<variable>,<formula_data>)
                  | GD_bind Variable Formula_data -- only used in inference
                    deriving (Int -> General_data -> ShowS
[General_data] -> ShowS
General_data -> String
(Int -> General_data -> ShowS)
-> (General_data -> String)
-> ([General_data] -> ShowS)
-> Show General_data
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [General_data] -> ShowS
$cshowList :: [General_data] -> ShowS
show :: General_data -> String
$cshow :: General_data -> String
showsPrec :: Int -> General_data -> ShowS
$cshowsPrec :: Int -> General_data -> ShowS
Show, Eq General_data
Eq General_data =>
(General_data -> General_data -> Ordering)
-> (General_data -> General_data -> Bool)
-> (General_data -> General_data -> Bool)
-> (General_data -> General_data -> Bool)
-> (General_data -> General_data -> Bool)
-> (General_data -> General_data -> General_data)
-> (General_data -> General_data -> General_data)
-> Ord General_data
General_data -> General_data -> Bool
General_data -> General_data -> Ordering
General_data -> General_data -> General_data
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 :: General_data -> General_data -> General_data
$cmin :: General_data -> General_data -> General_data
max :: General_data -> General_data -> General_data
$cmax :: General_data -> General_data -> General_data
>= :: General_data -> General_data -> Bool
$c>= :: General_data -> General_data -> Bool
> :: General_data -> General_data -> Bool
$c> :: General_data -> General_data -> Bool
<= :: General_data -> General_data -> Bool
$c<= :: General_data -> General_data -> Bool
< :: General_data -> General_data -> Bool
$c< :: General_data -> General_data -> Bool
compare :: General_data -> General_data -> Ordering
$ccompare :: General_data -> General_data -> Ordering
$cp1Ord :: Eq General_data
Ord, General_data -> General_data -> Bool
(General_data -> General_data -> Bool)
-> (General_data -> General_data -> Bool) -> Eq General_data
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: General_data -> General_data -> Bool
$c/= :: General_data -> General_data -> Bool
== :: General_data -> General_data -> Bool
$c== :: General_data -> General_data -> Bool
Eq, Typeable General_data
Constr
DataType
Typeable General_data =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> General_data -> c General_data)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c General_data)
-> (General_data -> Constr)
-> (General_data -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c General_data))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c General_data))
-> ((forall b. Data b => b -> b) -> General_data -> General_data)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> General_data -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> General_data -> r)
-> (forall u. (forall d. Data d => d -> u) -> General_data -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> General_data -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> General_data -> m General_data)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> General_data -> m General_data)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> General_data -> m General_data)
-> Data General_data
General_data -> Constr
General_data -> DataType
(forall b. Data b => b -> b) -> General_data -> General_data
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> General_data -> c General_data
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c General_data
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) -> General_data -> u
forall u. (forall d. Data d => d -> u) -> General_data -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> General_data -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> General_data -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> General_data -> m General_data
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> General_data -> m General_data
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c General_data
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> General_data -> c General_data
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c General_data)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c General_data)
$cGD_bind :: Constr
$cGD_formula_data :: Constr
$cGD_distinct_object :: Constr
$cGD_number :: Constr
$cGD_variable :: Constr
$cGD_general_function :: Constr
$cGD_atomic_word :: Constr
$tGeneral_data :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> General_data -> m General_data
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> General_data -> m General_data
gmapMp :: (forall d. Data d => d -> m d) -> General_data -> m General_data
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> General_data -> m General_data
gmapM :: (forall d. Data d => d -> m d) -> General_data -> m General_data
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> General_data -> m General_data
gmapQi :: Int -> (forall d. Data d => d -> u) -> General_data -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> General_data -> u
gmapQ :: (forall d. Data d => d -> u) -> General_data -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> General_data -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> General_data -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> General_data -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> General_data -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> General_data -> r
gmapT :: (forall b. Data b => b -> b) -> General_data -> General_data
$cgmapT :: (forall b. Data b => b -> b) -> General_data -> General_data
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c General_data)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c General_data)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c General_data)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c General_data)
dataTypeOf :: General_data -> DataType
$cdataTypeOf :: General_data -> DataType
toConstr :: General_data -> Constr
$ctoConstr :: General_data -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c General_data
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c General_data
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> General_data -> c General_data
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> General_data -> c General_data
$cp1Data :: Typeable General_data
Data, Typeable)

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

-- <formula_data>         ::= $thf(<thf_formula>) | $tff(<tff_formula>) |
--                            $fof(<fof_formula>) | $cnf(<cnf_formula>) |
--                            $fot(<fof_term>)
-- only used in inference
data Formula_data = FD_THF THF_formula
                  | FD_TFF TFF_formula
                  | FD_FOF FOF_formula
                  | FD_CNF CNF_formula
                  | FD_FOT FOF_term
                    deriving (Int -> Formula_data -> ShowS
[Formula_data] -> ShowS
Formula_data -> String
(Int -> Formula_data -> ShowS)
-> (Formula_data -> String)
-> ([Formula_data] -> ShowS)
-> Show Formula_data
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Formula_data] -> ShowS
$cshowList :: [Formula_data] -> ShowS
show :: Formula_data -> String
$cshow :: Formula_data -> String
showsPrec :: Int -> Formula_data -> ShowS
$cshowsPrec :: Int -> Formula_data -> ShowS
Show, Eq Formula_data
Eq Formula_data =>
(Formula_data -> Formula_data -> Ordering)
-> (Formula_data -> Formula_data -> Bool)
-> (Formula_data -> Formula_data -> Bool)
-> (Formula_data -> Formula_data -> Bool)
-> (Formula_data -> Formula_data -> Bool)
-> (Formula_data -> Formula_data -> Formula_data)
-> (Formula_data -> Formula_data -> Formula_data)
-> Ord Formula_data
Formula_data -> Formula_data -> Bool
Formula_data -> Formula_data -> Ordering
Formula_data -> Formula_data -> Formula_data
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 :: Formula_data -> Formula_data -> Formula_data
$cmin :: Formula_data -> Formula_data -> Formula_data
max :: Formula_data -> Formula_data -> Formula_data
$cmax :: Formula_data -> Formula_data -> Formula_data
>= :: Formula_data -> Formula_data -> Bool
$c>= :: Formula_data -> Formula_data -> Bool
> :: Formula_data -> Formula_data -> Bool
$c> :: Formula_data -> Formula_data -> Bool
<= :: Formula_data -> Formula_data -> Bool
$c<= :: Formula_data -> Formula_data -> Bool
< :: Formula_data -> Formula_data -> Bool
$c< :: Formula_data -> Formula_data -> Bool
compare :: Formula_data -> Formula_data -> Ordering
$ccompare :: Formula_data -> Formula_data -> Ordering
$cp1Ord :: Eq Formula_data
Ord, Formula_data -> Formula_data -> Bool
(Formula_data -> Formula_data -> Bool)
-> (Formula_data -> Formula_data -> Bool) -> Eq Formula_data
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Formula_data -> Formula_data -> Bool
$c/= :: Formula_data -> Formula_data -> Bool
== :: Formula_data -> Formula_data -> Bool
$c== :: Formula_data -> Formula_data -> Bool
Eq, Typeable Formula_data
Constr
DataType
Typeable Formula_data =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Formula_data -> c Formula_data)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Formula_data)
-> (Formula_data -> Constr)
-> (Formula_data -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Formula_data))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Formula_data))
-> ((forall b. Data b => b -> b) -> Formula_data -> Formula_data)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Formula_data -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Formula_data -> r)
-> (forall u. (forall d. Data d => d -> u) -> Formula_data -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Formula_data -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Formula_data -> m Formula_data)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formula_data -> m Formula_data)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formula_data -> m Formula_data)
-> Data Formula_data
Formula_data -> Constr
Formula_data -> DataType
(forall b. Data b => b -> b) -> Formula_data -> Formula_data
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_data -> c Formula_data
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_data
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) -> Formula_data -> u
forall u. (forall d. Data d => d -> u) -> Formula_data -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_data -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_data -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_data
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_data -> c Formula_data
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formula_data)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Formula_data)
$cFD_FOT :: Constr
$cFD_CNF :: Constr
$cFD_FOF :: Constr
$cFD_TFF :: Constr
$cFD_THF :: Constr
$tFormula_data :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
gmapMp :: (forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
gmapM :: (forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formula_data -> m Formula_data
gmapQi :: Int -> (forall d. Data d => d -> u) -> Formula_data -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Formula_data -> u
gmapQ :: (forall d. Data d => d -> u) -> Formula_data -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Formula_data -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_data -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_data -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_data -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formula_data -> r
gmapT :: (forall b. Data b => b -> b) -> Formula_data -> Formula_data
$cgmapT :: (forall b. Data b => b -> b) -> Formula_data -> Formula_data
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Formula_data)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Formula_data)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Formula_data)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formula_data)
dataTypeOf :: Formula_data -> DataType
$cdataTypeOf :: Formula_data -> DataType
toConstr :: Formula_data -> Constr
$ctoConstr :: Formula_data -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_data
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formula_data
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_data -> c Formula_data
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formula_data -> c Formula_data
$cp1Data :: Typeable Formula_data
Data, Typeable)

-- <general_list>         ::= [] | [<general_terms>]
type General_list = [General_term]

-- <general_terms>        ::= <general_term> | <general_term>,<general_terms>
type General_terms = [General_term]


-- %----General purpose
-- <name>                 ::= <atomic_word> | <integer>
-- %----Integer names are expected to be unsigned
data Name = NameString Token
          | NameInteger Integer
            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, 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, 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, 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)
$cNameInteger :: Constr
$cNameString :: Constr
$tName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable Name
Data, Typeable)

-- <atomic_word>          ::= <lower_word> | <single_quoted>
type Atomic_word = Token

-- <atomic_defined_word>  ::= <dollar_word>
type Atomic_defined_word = Token

-- <atomic_system_word>   ::= <dollar_dollar_word>
type Atomic_system_word = Token

-- <number>               ::= <integer> | <rational> | <real>
data Number = NumInteger Integer
            | NumRational Rational
            | NumReal Double
              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, 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, 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, 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)
$cNumReal :: Constr
$cNumRational :: Constr
$cNumInteger :: 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, Typeable)


-- <distinct_object>      ::- <double_quote><do_char>*<double_quote>
type Distinct_object = Token

-- <file_name>            ::= <single_quoted>
type File_name = IRI


set_formula_role :: Annotated_formula -> Formula_role -> Annotated_formula
set_formula_role :: Annotated_formula -> Formula_role -> Annotated_formula
set_formula_role (AF_THF_Annotated (THF_annotated n :: Name
n _ f :: THF_formula
f an :: Annotations
an)) role :: Formula_role
role =
     (THF_annotated -> Annotated_formula
AF_THF_Annotated (Name -> Formula_role -> THF_formula -> Annotations -> THF_annotated
THF_annotated Name
n Formula_role
role THF_formula
f Annotations
an))
set_formula_role (AF_TFX_Annotated (TFX_annotated n :: Name
n _ f :: TFX_formula
f an :: Annotations
an)) role :: Formula_role
role =
     (TFX_annotated -> Annotated_formula
AF_TFX_Annotated (Name -> Formula_role -> TFX_formula -> Annotations -> TFX_annotated
TFX_annotated Name
n Formula_role
role TFX_formula
f Annotations
an))
set_formula_role (AF_TFF_Annotated (TFF_annotated n :: Name
n _ f :: TFF_formula
f an :: Annotations
an)) role :: Formula_role
role =
     (TFF_annotated -> Annotated_formula
AF_TFF_Annotated (Name -> Formula_role -> TFF_formula -> Annotations -> TFF_annotated
TFF_annotated Name
n Formula_role
role TFF_formula
f Annotations
an))
set_formula_role (AF_TCF_Annotated (TCF_annotated n :: Name
n _ f :: TCF_formula
f an :: Annotations
an)) role :: Formula_role
role =
     (TCF_annotated -> Annotated_formula
AF_TCF_Annotated (Name -> Formula_role -> TCF_formula -> Annotations -> TCF_annotated
TCF_annotated Name
n Formula_role
role TCF_formula
f Annotations
an))
set_formula_role (AF_FOF_Annotated (FOF_annotated n :: Name
n _ f :: FOF_formula
f an :: Annotations
an)) role :: Formula_role
role =
     (FOF_annotated -> Annotated_formula
AF_FOF_Annotated (Name -> Formula_role -> FOF_formula -> Annotations -> FOF_annotated
FOF_annotated Name
n Formula_role
role FOF_formula
f Annotations
an))
set_formula_role (AF_CNF_Annotated (CNF_annotated n :: Name
n _ f :: CNF_formula
f an :: Annotations
an)) role :: Formula_role
role =
     (CNF_annotated -> Annotated_formula
AF_CNF_Annotated (Name -> Formula_role -> CNF_formula -> Annotations -> CNF_annotated
CNF_annotated Name
n Formula_role
role CNF_formula
f Annotations
an))
set_formula_role (AF_TPI_Annotated (TPI_annotated n :: Name
n _ f :: FOF_formula
f an :: Annotations
an)) role :: Formula_role
role =
     (TPI_annotated -> Annotated_formula
AF_TPI_Annotated (Name -> Formula_role -> FOF_formula -> Annotations -> TPI_annotated
TPI_annotated Name
n Formula_role
role FOF_formula
f Annotations
an))

adjust_formula_role :: AS_Anno.Named Annotated_formula -> AS_Anno.Named Annotated_formula
adjust_formula_role :: Named Annotated_formula -> Named Annotated_formula
adjust_formula_role anno_sen :: Named Annotated_formula
anno_sen = 
  let sen1 :: Annotated_formula
sen1 = Named Annotated_formula -> Annotated_formula
forall s a. SenAttr s a -> s
AS_Anno.sentence Named Annotated_formula
anno_sen
      sen2 :: Annotated_formula
sen2 = if Named Annotated_formula -> Bool
forall s a. SenAttr s a -> Bool
AS_Anno.isAxiom Named Annotated_formula
anno_sen
             then Annotated_formula -> Formula_role -> Annotated_formula
set_formula_role Annotated_formula
sen1 Formula_role
Axiom
             else Annotated_formula
sen1
  in Named Annotated_formula
anno_sen { sentence :: Annotated_formula
AS_Anno.sentence = Annotated_formula
sen2 }                


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

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

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

instance GetRange TPTP_input where
  getRange :: TPTP_input -> Range
getRange = Range -> TPTP_input -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TPTP_input -> [Pos]
rangeSpan x :: TPTP_input
x = case TPTP_input
x of
    Annotated_formula a :: Annotated_formula
a -> [[Pos]] -> [Pos]
joinRanges [Annotated_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotated_formula
a]
    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]

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 Annotated_formula where
  getRange :: Annotated_formula -> Range
getRange = Range -> Annotated_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Annotated_formula -> [Pos]
rangeSpan x :: Annotated_formula
x = case Annotated_formula
x of
    AF_THF_Annotated a :: THF_annotated
a -> [[Pos]] -> [Pos]
joinRanges [THF_annotated -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_annotated
a]
    AF_TFX_Annotated a :: TFX_annotated
a -> [[Pos]] -> [Pos]
joinRanges [TFX_annotated -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFX_annotated
a]
    AF_TFF_Annotated a :: TFF_annotated
a -> [[Pos]] -> [Pos]
joinRanges [TFF_annotated -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_annotated
a]
    AF_TCF_Annotated a :: TCF_annotated
a -> [[Pos]] -> [Pos]
joinRanges [TCF_annotated -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TCF_annotated
a]
    AF_FOF_Annotated a :: FOF_annotated
a -> [[Pos]] -> [Pos]
joinRanges [FOF_annotated -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_annotated
a]
    AF_CNF_Annotated a :: CNF_annotated
a -> [[Pos]] -> [Pos]
joinRanges [CNF_annotated -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan CNF_annotated
a]
    AF_TPI_Annotated a :: TPI_annotated
a -> [[Pos]] -> [Pos]
joinRanges [TPI_annotated -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TPI_annotated
a]

instance GetRange TPI_annotated where
  getRange :: TPI_annotated -> Range
getRange = Range -> TPI_annotated -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TPI_annotated -> [Pos]
rangeSpan x :: TPI_annotated
x = case TPI_annotated
x of
    TPI_annotated a :: Name
a b :: Formula_role
b c :: FOF_formula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a, Formula_role -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_role
b,
                                         FOF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_formula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]

instance GetRange THF_annotated where
  getRange :: THF_annotated -> Range
getRange = Range -> THF_annotated -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_annotated -> [Pos]
rangeSpan x :: THF_annotated
x = case THF_annotated
x of
    THF_annotated a :: Name
a b :: Formula_role
b c :: THF_formula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a, Formula_role -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_role
b,
                                         THF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_formula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]

instance GetRange TFX_annotated where
  getRange :: TFX_annotated -> Range
getRange = Range -> TFX_annotated -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFX_annotated -> [Pos]
rangeSpan x :: TFX_annotated
x = case TFX_annotated
x of
    TFX_annotated a :: Name
a b :: Formula_role
b c :: TFX_formula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a, Formula_role -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_role
b,
                                         TFX_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFX_formula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]

instance GetRange TFF_annotated where
  getRange :: TFF_annotated -> Range
getRange = Range -> TFF_annotated -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_annotated -> [Pos]
rangeSpan x :: TFF_annotated
x = case TFF_annotated
x of
    TFF_annotated a :: Name
a b :: Formula_role
b c :: TFF_formula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a, Formula_role -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_role
b,
                                         TFF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_formula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]

instance GetRange TCF_annotated where
  getRange :: TCF_annotated -> Range
getRange = Range -> TCF_annotated -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TCF_annotated -> [Pos]
rangeSpan x :: TCF_annotated
x = case TCF_annotated
x of
    TCF_annotated a :: Name
a b :: Formula_role
b c :: TCF_formula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a, Formula_role -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_role
b,
                                         TCF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TCF_formula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]

instance GetRange FOF_annotated where
  getRange :: FOF_annotated -> Range
getRange = Range -> FOF_annotated -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_annotated -> [Pos]
rangeSpan x :: FOF_annotated
x = case FOF_annotated
x of
    FOF_annotated a :: Name
a b :: Formula_role
b c :: FOF_formula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a, Formula_role -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_role
b,
                                         FOF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_formula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]

instance GetRange CNF_annotated where
  getRange :: CNF_annotated -> Range
getRange = Range -> CNF_annotated -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: CNF_annotated -> [Pos]
rangeSpan x :: CNF_annotated
x = case CNF_annotated
x of
    CNF_annotated a :: Name
a b :: Formula_role
b c :: CNF_formula
c d :: Annotations
d -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a, Formula_role -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_role
b,
                                         CNF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan CNF_formula
c, Annotations -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annotations
d]

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 :: Maybe (Source, Optional_info)
a -> [[Pos]] -> [Pos]
joinRanges [Maybe (Source, Optional_info) -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe (Source, Optional_info)
a]

instance GetRange Formula_role where
  getRange :: Formula_role -> Range
getRange = Range -> Formula_role -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Formula_role -> [Pos]
rangeSpan x :: Formula_role
x = case Formula_role
x of
    Axiom -> []
    Hypothesis -> []
    Definition -> []
    Assumption -> []
    Lemma -> []
    Theorem -> []
    Corollary -> []
    Conjecture -> []
    Negated_conjecture -> []
    Plain -> []
    Type -> []
    Fi_domain -> []
    Fi_functors -> []
    Fi_predicates -> []
    Unknown -> []
    Other_formula_role a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange THF_formula where
  getRange :: THF_formula -> Range
getRange = Range -> THF_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_formula -> [Pos]
rangeSpan x :: THF_formula
x = case THF_formula
x of
    THFF_logic a :: THF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_logic_formula
a]
    THFF_sequent a :: THF_sequent
a -> [[Pos]] -> [Pos]
joinRanges [THF_sequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_sequent
a]

instance GetRange THF_logic_formula where
  getRange :: THF_logic_formula -> Range
getRange = Range -> THF_logic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_logic_formula -> [Pos]
rangeSpan x :: THF_logic_formula
x = case THF_logic_formula
x of
    THFLF_binary a :: THF_binary_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_binary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_binary_formula
a]
    THFLF_unitary a :: THF_unitary_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unitary_formula
a]
    THFLF_type a :: THF_type_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_type_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_type_formula
a]
    THFLF_subtype a :: THF_subtype
a -> [[Pos]] -> [Pos]
joinRanges [THF_subtype -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_subtype
a]

instance GetRange THF_binary_formula where
  getRange :: THF_binary_formula -> Range
getRange = Range -> THF_binary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_binary_formula -> [Pos]
rangeSpan x :: THF_binary_formula
x = case THF_binary_formula
x of
    THFBF_pair a :: THF_binary_pair
a -> [[Pos]] -> [Pos]
joinRanges [THF_binary_pair -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_binary_pair
a]
    THFBF_tuple a :: THF_binary_tuple
a -> [[Pos]] -> [Pos]
joinRanges [THF_binary_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_binary_tuple
a]

instance GetRange THF_binary_pair where
  getRange :: THF_binary_pair -> Range
getRange = Range -> THF_binary_pair -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_binary_pair -> [Pos]
rangeSpan x :: THF_binary_pair
x = case THF_binary_pair
x of
    THF_binary_pair a :: THF_pair_connective
a b :: THF_unitary_formula
b c :: THF_unitary_formula
c -> [[Pos]] -> [Pos]
joinRanges [THF_pair_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_pair_connective
a, THF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unitary_formula
b,
                                         THF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unitary_formula
c]

instance GetRange THF_binary_tuple where
  getRange :: THF_binary_tuple -> Range
getRange = Range -> THF_binary_tuple -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_binary_tuple -> [Pos]
rangeSpan x :: THF_binary_tuple
x = case THF_binary_tuple
x of
    THFBT_or a :: [THF_unitary_formula]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_unitary_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_unitary_formula]
a]
    THFBT_and a :: [THF_unitary_formula]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_unitary_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_unitary_formula]
a]
    THFBT_apply a :: [THF_unitary_formula]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_unitary_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_unitary_formula]
a]

instance GetRange THF_unitary_formula where
  getRange :: THF_unitary_formula -> Range
getRange = Range -> THF_unitary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_unitary_formula -> [Pos]
rangeSpan x :: THF_unitary_formula
x = case THF_unitary_formula
x of
    THFUF_quantified a :: THF_quantified_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_quantified_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_quantified_formula
a]
    THFUF_unary a :: THF_unary_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_unary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unary_formula
a]
    THFUF_atom a :: THF_atom
a -> [[Pos]] -> [Pos]
joinRanges [THF_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_atom
a]
    THFUF_conditional a :: THF_conditional
a -> [[Pos]] -> [Pos]
joinRanges [THF_conditional -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_conditional
a]
    THFUF_let a :: THF_let
a -> [[Pos]] -> [Pos]
joinRanges [THF_let -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_let
a]
    THFUF_tuple a :: THF_tuple
a -> [[Pos]] -> [Pos]
joinRanges [THF_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_tuple
a]
    THFUF_logic a :: THF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_logic_formula
a]

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

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

instance GetRange THF_variable where
  getRange :: THF_variable -> Range
getRange = Range -> THF_variable -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_variable -> [Pos]
rangeSpan x :: THF_variable
x = case THF_variable
x of
    THFV_typed a :: THF_typed_variable
a -> [[Pos]] -> [Pos]
joinRanges [THF_typed_variable -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_typed_variable
a]
    THFV_variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

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

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

instance GetRange THF_atom where
  getRange :: THF_atom -> Range
getRange = Range -> THF_atom -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_atom -> [Pos]
rangeSpan x :: THF_atom
x = case THF_atom
x of
    THF_atom_function a :: THF_function
a -> [[Pos]] -> [Pos]
joinRanges [THF_function -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_function
a]
    THF_atom_variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    THF_atom_defined a :: Defined_term
a -> [[Pos]] -> [Pos]
joinRanges [Defined_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_term
a]
    THF_atom_conn a :: THF_conn_term
a -> [[Pos]] -> [Pos]
joinRanges [THF_conn_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_conn_term
a]

instance GetRange THF_function where
  getRange :: THF_function -> Range
getRange = Range -> THF_function -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_function -> [Pos]
rangeSpan x :: THF_function
x = case THF_function
x of
    THFF_atom a :: Atom
a -> [[Pos]] -> [Pos]
joinRanges [Atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Atom
a]
    THFF_functor a :: Token
a b :: [THF_logic_formula]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [THF_logic_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_logic_formula]
b]
    THFF_defined a :: Defined_functor
a b :: [THF_logic_formula]
b -> [[Pos]] -> [Pos]
joinRanges [Defined_functor -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_functor
a, [THF_logic_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_logic_formula]
b]
    THFF_system a :: Token
a b :: [THF_logic_formula]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [THF_logic_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_logic_formula]
b]

instance GetRange THF_conn_term where
  getRange :: THF_conn_term -> Range
getRange = Range -> THF_conn_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_conn_term -> [Pos]
rangeSpan x :: THF_conn_term
x = case THF_conn_term
x of
    THFC_pair a :: THF_pair_connective
a -> [[Pos]] -> [Pos]
joinRanges [THF_pair_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_pair_connective
a]
    THFC_assoc a :: Assoc_connective
a -> [[Pos]] -> [Pos]
joinRanges [Assoc_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Assoc_connective
a]
    THFC_unary a :: THF_unary_connective
a -> [[Pos]] -> [Pos]
joinRanges [THF_unary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unary_connective
a]

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

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

instance GetRange THF_let_defns where
  getRange :: THF_let_defns -> Range
getRange = Range -> THF_let_defns -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_let_defns -> [Pos]
rangeSpan x :: THF_let_defns
x = case THF_let_defns
x of
    THFLD_single a :: THF_let_defn
a -> [[Pos]] -> [Pos]
joinRanges [THF_let_defn -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_let_defn
a]
    THFLD_many a :: [THF_let_defn]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_let_defn] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_let_defn]
a]

instance GetRange THF_let_defn where
  getRange :: THF_let_defn -> Range
getRange = Range -> THF_let_defn -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_let_defn -> [Pos]
rangeSpan x :: THF_let_defn
x = case THF_let_defn
x of
    THFLD_quantified a :: THF_let_quantified_defn
a -> [[Pos]] -> [Pos]
joinRanges [THF_let_quantified_defn -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_let_quantified_defn
a]
    THFLD_plain a :: THF_let_plain_defn
a -> [[Pos]] -> [Pos]
joinRanges [THF_let_plain_defn -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_let_plain_defn
a]

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

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

instance GetRange THF_let_defn_LHS where
  getRange :: THF_let_defn_LHS -> Range
getRange = Range -> THF_let_defn_LHS -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_let_defn_LHS -> [Pos]
rangeSpan x :: THF_let_defn_LHS
x = case THF_let_defn_LHS
x of
    THFLDL_constant a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    THFLDL_functor a :: Token
a b :: [FOF_term]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [FOF_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_term]
b]
    THFLDL_tuple a :: THF_tuple
a -> [[Pos]] -> [Pos]
joinRanges [THF_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_tuple
a]

instance GetRange THF_type_formula where
  getRange :: THF_type_formula -> Range
getRange = Range -> THF_type_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_type_formula -> [Pos]
rangeSpan x :: THF_type_formula
x = case THF_type_formula
x of
    THFTF_typeable a :: THF_typeable_formula
a b :: THF_top_level_type
b -> [[Pos]] -> [Pos]
joinRanges [THF_typeable_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_typeable_formula
a, THF_top_level_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_top_level_type
b]
    THFTF_constant a :: Token
a b :: THF_top_level_type
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, THF_top_level_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_top_level_type
b]

instance GetRange THF_typeable_formula where
  getRange :: THF_typeable_formula -> Range
getRange = Range -> THF_typeable_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_typeable_formula -> [Pos]
rangeSpan x :: THF_typeable_formula
x = case THF_typeable_formula
x of
    THFTF_atom a :: THF_atom
a -> [[Pos]] -> [Pos]
joinRanges [THF_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_atom
a]
    THFTF_logic a :: THF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_logic_formula
a]

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

instance GetRange THF_top_level_type where
  getRange :: THF_top_level_type -> Range
getRange = Range -> THF_top_level_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_top_level_type -> [Pos]
rangeSpan x :: THF_top_level_type
x = case THF_top_level_type
x of
    THFTLT_unitary a :: THF_unitary_type
a -> [[Pos]] -> [Pos]
joinRanges [THF_unitary_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unitary_type
a]
    THFTLT_mapping a :: [THF_unitary_type]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_unitary_type] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_unitary_type]
a]

instance GetRange THF_unitary_type where
  getRange :: THF_unitary_type -> Range
getRange = Range -> THF_unitary_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_unitary_type -> [Pos]
rangeSpan x :: THF_unitary_type
x = case THF_unitary_type
x of
    THFUT_unitary a :: THF_unitary_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unitary_formula
a]
    THFUT_binary a :: THF_binary_type
a -> [[Pos]] -> [Pos]
joinRanges [THF_binary_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_binary_type
a]

instance GetRange THF_binary_type where
  getRange :: THF_binary_type -> Range
getRange = Range -> THF_binary_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_binary_type -> [Pos]
rangeSpan x :: THF_binary_type
x = case THF_binary_type
x of
    THFBT_mapping a :: [THF_unitary_type]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_unitary_type] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_unitary_type]
a]
    THFBT_xprod a :: [THF_unitary_type]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_unitary_type] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_unitary_type]
a]
    THFBT_union a :: [THF_unitary_type]
a -> [[Pos]] -> [Pos]
joinRanges [[THF_unitary_type] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [THF_unitary_type]
a]

instance GetRange THF_sequent where
  getRange :: THF_sequent -> Range
getRange = Range -> THF_sequent -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_sequent -> [Pos]
rangeSpan x :: THF_sequent
x = case THF_sequent
x of
    THFS_plain a :: THF_tuple
a b :: THF_tuple
b -> [[Pos]] -> [Pos]
joinRanges [THF_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_tuple
a, THF_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_tuple
b]
    THFS_parens a :: THF_sequent
a -> [[Pos]] -> [Pos]
joinRanges [THF_sequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_sequent
a]

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

instance GetRange TFX_formula where
  getRange :: TFX_formula -> Range
getRange = Range -> TFX_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFX_formula -> [Pos]
rangeSpan x :: TFX_formula
x = case TFX_formula
x of
    TFXF_logic a :: TFX_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFX_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFX_logic_formula
a]
    TFXF_sequent a :: THF_sequent
a -> [[Pos]] -> [Pos]
joinRanges [THF_sequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_sequent
a]

instance GetRange TFX_logic_formula where
  getRange :: TFX_logic_formula -> Range
getRange = Range -> TFX_logic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFX_logic_formula -> [Pos]
rangeSpan x :: TFX_logic_formula
x = case TFX_logic_formula
x of
    TFXLF_binary a :: THF_binary_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_binary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_binary_formula
a]
    TFXLF_unitary a :: THF_unitary_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_unitary_formula
a]
    TFXLF_typed a :: TFF_typed_atom
a -> [[Pos]] -> [Pos]
joinRanges [TFF_typed_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_typed_atom
a]
    TFXLF_subtype a :: TFF_subtype
a -> [[Pos]] -> [Pos]
joinRanges [TFF_subtype -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_subtype
a]

instance GetRange TFF_formula where
  getRange :: TFF_formula -> Range
getRange = Range -> TFF_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_formula -> [Pos]
rangeSpan x :: TFF_formula
x = case TFF_formula
x of
    TFFF_logic a :: TFF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_logic_formula
a]
    TFFF_atom a :: TFF_typed_atom
a -> [[Pos]] -> [Pos]
joinRanges [TFF_typed_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_typed_atom
a]
    TFFF_sequent a :: TFF_sequent
a -> [[Pos]] -> [Pos]
joinRanges [TFF_sequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_sequent
a]

instance GetRange TFF_logic_formula where
  getRange :: TFF_logic_formula -> Range
getRange = Range -> TFF_logic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_logic_formula -> [Pos]
rangeSpan x :: TFF_logic_formula
x = case TFF_logic_formula
x of
    TFFLF_binary a :: TFF_binary_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFF_binary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_binary_formula
a]
    TFFLF_unitary a :: TFF_unitary_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_unitary_formula
a]
    TFFLF_subtype a :: TFF_subtype
a -> [[Pos]] -> [Pos]
joinRanges [TFF_subtype -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_subtype
a]

instance GetRange TFF_binary_formula where
  getRange :: TFF_binary_formula -> Range
getRange = Range -> TFF_binary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_binary_formula -> [Pos]
rangeSpan x :: TFF_binary_formula
x = case TFF_binary_formula
x of
    TFFBF_nonassoc a :: TFF_binary_nonassoc
a -> [[Pos]] -> [Pos]
joinRanges [TFF_binary_nonassoc -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_binary_nonassoc
a]
    TFFBF_assoc a :: TFF_binary_assoc
a -> [[Pos]] -> [Pos]
joinRanges [TFF_binary_assoc -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_binary_assoc
a]

instance GetRange TFF_binary_nonassoc where
  getRange :: TFF_binary_nonassoc -> Range
getRange = Range -> TFF_binary_nonassoc -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_binary_nonassoc -> [Pos]
rangeSpan x :: TFF_binary_nonassoc
x = case TFF_binary_nonassoc
x of
    TFF_binary_nonassoc a :: Binary_connective
a b :: TFF_unitary_formula
b c :: TFF_unitary_formula
c -> [[Pos]] -> [Pos]
joinRanges [Binary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Binary_connective
a, TFF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_unitary_formula
b,
                                             TFF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_unitary_formula
c]

instance GetRange TFF_binary_assoc where
  getRange :: TFF_binary_assoc -> Range
getRange = Range -> TFF_binary_assoc -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_binary_assoc -> [Pos]
rangeSpan x :: TFF_binary_assoc
x = case TFF_binary_assoc
x of
    TFFBA_or a :: [TFF_unitary_formula]
a -> [[Pos]] -> [Pos]
joinRanges [[TFF_unitary_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_unitary_formula]
a]
    TFFBA_and a :: [TFF_unitary_formula]
a -> [[Pos]] -> [Pos]
joinRanges [[TFF_unitary_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_unitary_formula]
a]

instance GetRange TFF_unitary_formula where
  getRange :: TFF_unitary_formula -> Range
getRange = Range -> TFF_unitary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_unitary_formula -> [Pos]
rangeSpan x :: TFF_unitary_formula
x = case TFF_unitary_formula
x of
    TFFUF_quantified a :: TFF_quantified_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFF_quantified_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_quantified_formula
a]
    TFFUF_unary a :: TFF_unary_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFF_unary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_unary_formula
a]
    TFFUF_atomic a :: FOF_atomic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_atomic_formula
a]
    TFFUF_conditional a :: TFF_conditional
a -> [[Pos]] -> [Pos]
joinRanges [TFF_conditional -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_conditional
a]
    TFFUF_let a :: TFF_let
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let
a]
    TFFUF_logic a :: TFF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_logic_formula
a]

instance GetRange TFF_quantified_formula where
  getRange :: TFF_quantified_formula -> Range
getRange = Range -> TFF_quantified_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_quantified_formula -> [Pos]
rangeSpan x :: TFF_quantified_formula
x = case TFF_quantified_formula
x of
    TFF_quantified_formula a :: FOF_quantifier
a b :: [TFF_variable]
b c :: TFF_unitary_formula
c -> [[Pos]] -> [Pos]
joinRanges [FOF_quantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_quantifier
a,
                                                [TFF_variable] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_variable]
b, TFF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_unitary_formula
c]

instance GetRange TFF_variable where
  getRange :: TFF_variable -> Range
getRange = Range -> TFF_variable -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_variable -> [Pos]
rangeSpan x :: TFF_variable
x = case TFF_variable
x of
    TFFV_typed a :: TFF_typed_variable
a -> [[Pos]] -> [Pos]
joinRanges [TFF_typed_variable -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_typed_variable
a]
    TFFV_variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

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

instance GetRange TFF_unary_formula where
  getRange :: TFF_unary_formula -> Range
getRange = Range -> TFF_unary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_unary_formula -> [Pos]
rangeSpan x :: TFF_unary_formula
x = case TFF_unary_formula
x of
    TFFUF_connective a :: Unary_connective
a b :: TFF_unitary_formula
b -> [[Pos]] -> [Pos]
joinRanges [Unary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Unary_connective
a, TFF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_unitary_formula
b]
    TFFUF_infix a :: FOF_infix_unary
a -> [[Pos]] -> [Pos]
joinRanges [FOF_infix_unary -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_infix_unary
a]

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

instance GetRange TFF_let where
  getRange :: TFF_let -> Range
getRange = Range -> TFF_let -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let -> [Pos]
rangeSpan x :: TFF_let
x = case TFF_let
x of
    TFF_let_term_defns a :: TFF_let_term_defns
a b :: TFF_formula
b -> [[Pos]] -> [Pos]
joinRanges [TFF_let_term_defns -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_term_defns
a, TFF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_formula
b]
    TFF_let_formula_defns a :: TFF_let_formula_defns
a b :: TFF_formula
b -> [[Pos]] -> [Pos]
joinRanges [TFF_let_formula_defns -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_formula_defns
a, TFF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_formula
b]

instance GetRange TFF_let_term_defns where
  getRange :: TFF_let_term_defns -> Range
getRange = Range -> TFF_let_term_defns -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let_term_defns -> [Pos]
rangeSpan x :: TFF_let_term_defns
x = case TFF_let_term_defns
x of
    TFFLTD_single a :: TFF_let_term_defn
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let_term_defn -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_term_defn
a]
    TFFLTD_many a :: [TFF_let_term_defn]
a -> [[Pos]] -> [Pos]
joinRanges [[TFF_let_term_defn] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_let_term_defn]
a]

instance GetRange TFF_let_term_defn where
  getRange :: TFF_let_term_defn -> Range
getRange = Range -> TFF_let_term_defn -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let_term_defn -> [Pos]
rangeSpan x :: TFF_let_term_defn
x = case TFF_let_term_defn
x of
    TFFLTD_variable a :: [TFF_variable]
a b :: TFF_let_term_defn
b -> [[Pos]] -> [Pos]
joinRanges [[TFF_variable] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_variable]
a, TFF_let_term_defn -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_term_defn
b]
    TFFLTD_binding a :: TFF_let_term_binding
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let_term_binding -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_term_binding
a]

instance GetRange TFF_let_term_binding where
  getRange :: TFF_let_term_binding -> Range
getRange = Range -> TFF_let_term_binding -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let_term_binding -> [Pos]
rangeSpan x :: TFF_let_term_binding
x = case TFF_let_term_binding
x of
    TFFLTB_plain a :: FOF_plain_term
a b :: FOF_term
b -> [[Pos]] -> [Pos]
joinRanges [FOF_plain_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_plain_term
a, FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
b]
    TFFLTB_binding a :: TFF_let_term_binding
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let_term_binding -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_term_binding
a]

instance GetRange TFF_let_formula_defns where
  getRange :: TFF_let_formula_defns -> Range
getRange = Range -> TFF_let_formula_defns -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let_formula_defns -> [Pos]
rangeSpan x :: TFF_let_formula_defns
x = case TFF_let_formula_defns
x of
    TFFLFD_single a :: TFF_let_formula_defn
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let_formula_defn -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_formula_defn
a]
    TFFLFD_many a :: [TFF_let_formula_defn]
a -> [[Pos]] -> [Pos]
joinRanges [[TFF_let_formula_defn] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_let_formula_defn]
a]

instance GetRange TFF_let_formula_defn where
  getRange :: TFF_let_formula_defn -> Range
getRange = Range -> TFF_let_formula_defn -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let_formula_defn -> [Pos]
rangeSpan x :: TFF_let_formula_defn
x = case TFF_let_formula_defn
x of
    TFFLFD_variable a :: [TFF_variable]
a b :: TFF_let_formula_defn
b -> [[Pos]] -> [Pos]
joinRanges [[TFF_variable] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_variable]
a, TFF_let_formula_defn -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_formula_defn
b]
    TFFLFD_binding a :: TFF_let_formula_binding
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let_formula_binding -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_formula_binding
a]

instance GetRange TFF_let_formula_binding where
  getRange :: TFF_let_formula_binding -> Range
getRange = Range -> TFF_let_formula_binding -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let_formula_binding -> [Pos]
rangeSpan x :: TFF_let_formula_binding
x = case TFF_let_formula_binding
x of
    TFFLFB_plain a :: FOF_plain_atomic_formula
a b :: TFF_unitary_formula
b -> [[Pos]] -> [Pos]
joinRanges [FOF_plain_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_plain_atomic_formula
a, TFF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_unitary_formula
b]
    TFFLFB_binding a :: TFF_let_formula_binding
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let_formula_binding -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_formula_binding
a]

instance GetRange TFF_sequent where
  getRange :: TFF_sequent -> Range
getRange = Range -> TFF_sequent -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_sequent -> [Pos]
rangeSpan x :: TFF_sequent
x = case TFF_sequent
x of
    TFFS_plain a :: TFF_formula_tuple
a b :: TFF_formula_tuple
b -> [[Pos]] -> [Pos]
joinRanges [TFF_formula_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_formula_tuple
a, TFF_formula_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_formula_tuple
b]
    TFFS_parens a :: TFF_sequent
a -> [[Pos]] -> [Pos]
joinRanges [TFF_sequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_sequent
a]

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

instance GetRange TFF_typed_atom where
  getRange :: TFF_typed_atom -> Range
getRange = Range -> TFF_typed_atom -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_typed_atom -> [Pos]
rangeSpan x :: TFF_typed_atom
x = case TFF_typed_atom
x of
    TFFTA_plain a :: Untyped_atom
a b :: TFF_top_level_type
b -> [[Pos]] -> [Pos]
joinRanges [Untyped_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Untyped_atom
a, TFF_top_level_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_top_level_type
b]
    TFFTA_parens a :: TFF_typed_atom
a -> [[Pos]] -> [Pos]
joinRanges [TFF_typed_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_typed_atom
a]

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

instance GetRange TFF_top_level_type where
  getRange :: TFF_top_level_type -> Range
getRange = Range -> TFF_top_level_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_top_level_type -> [Pos]
rangeSpan x :: TFF_top_level_type
x = case TFF_top_level_type
x of
    TFFTLT_atomic a :: TFF_atomic_type
a -> [[Pos]] -> [Pos]
joinRanges [TFF_atomic_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_atomic_type
a]
    TFFTLT_mapping a :: TFF_mapping_type
a -> [[Pos]] -> [Pos]
joinRanges [TFF_mapping_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_mapping_type
a]
    TFFTLT_quantified a :: TF1_quantified_type
a -> [[Pos]] -> [Pos]
joinRanges [TF1_quantified_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TF1_quantified_type
a]
    TFFTLT_parens a :: TFF_top_level_type
a -> [[Pos]] -> [Pos]
joinRanges [TFF_top_level_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_top_level_type
a]

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

instance GetRange TFF_monotype where
  getRange :: TFF_monotype -> Range
getRange = Range -> TFF_monotype -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_monotype -> [Pos]
rangeSpan x :: TFF_monotype
x = case TFF_monotype
x of
    TFFMT_atomic a :: TFF_atomic_type
a -> [[Pos]] -> [Pos]
joinRanges [TFF_atomic_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_atomic_type
a]
    TFFMT_mapping a :: TFF_mapping_type
a -> [[Pos]] -> [Pos]
joinRanges [TFF_mapping_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_mapping_type
a]

instance GetRange TFF_unitary_type where
  getRange :: TFF_unitary_type -> Range
getRange = Range -> TFF_unitary_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_unitary_type -> [Pos]
rangeSpan x :: TFF_unitary_type
x = case TFF_unitary_type
x of
    TFFUT_atomic a :: TFF_atomic_type
a -> [[Pos]] -> [Pos]
joinRanges [TFF_atomic_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_atomic_type
a]
    TFFUT_xprod a :: TFF_xprod_type
a -> [[Pos]] -> [Pos]
joinRanges [TFF_xprod_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_xprod_type
a]

instance GetRange TFF_atomic_type where
  getRange :: TFF_atomic_type -> Range
getRange = Range -> TFF_atomic_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_atomic_type -> [Pos]
rangeSpan x :: TFF_atomic_type
x = case TFF_atomic_type
x of
    TFFAT_constant a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    TFFAT_defined a :: Defined_type
a -> [[Pos]] -> [Pos]
joinRanges [Defined_type -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_type
a]
    TFFAT_functor a :: Token
a b :: [TFF_atomic_type]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [TFF_atomic_type] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_atomic_type]
b]
    TFFAT_variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

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

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

instance GetRange TCF_formula where
  getRange :: TCF_formula -> Range
getRange = Range -> TCF_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TCF_formula -> [Pos]
rangeSpan x :: TCF_formula
x = case TCF_formula
x of
    TCFF_logic a :: TCF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [TCF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TCF_logic_formula
a]
    TCFF_atom a :: TFF_typed_atom
a -> [[Pos]] -> [Pos]
joinRanges [TFF_typed_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_typed_atom
a]

instance GetRange TCF_logic_formula where
  getRange :: TCF_logic_formula -> Range
getRange = Range -> TCF_logic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TCF_logic_formula -> [Pos]
rangeSpan x :: TCF_logic_formula
x = case TCF_logic_formula
x of
    TCFLF_quantified a :: TCF_quantified_formula
a -> [[Pos]] -> [Pos]
joinRanges [TCF_quantified_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TCF_quantified_formula
a]
    TCFLF_cnf a :: CNF_formula
a -> [[Pos]] -> [Pos]
joinRanges [CNF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan CNF_formula
a]

instance GetRange TCF_quantified_formula where
  getRange :: TCF_quantified_formula -> Range
getRange = Range -> TCF_quantified_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TCF_quantified_formula -> [Pos]
rangeSpan x :: TCF_quantified_formula
x = case TCF_quantified_formula
x of
    TCF_quantified a :: [TFF_variable]
a b :: CNF_formula
b -> [[Pos]] -> [Pos]
joinRanges [[TFF_variable] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TFF_variable]
a, CNF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan CNF_formula
b]

instance GetRange FOF_formula where
  getRange :: FOF_formula -> Range
getRange = Range -> FOF_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_formula -> [Pos]
rangeSpan x :: FOF_formula
x = case FOF_formula
x of
    FOFF_logic a :: FOF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_logic_formula
a]
    FOFF_sequent a :: FOF_sequent
a -> [[Pos]] -> [Pos]
joinRanges [FOF_sequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_sequent
a]

instance GetRange FOF_logic_formula where
  getRange :: FOF_logic_formula -> Range
getRange = Range -> FOF_logic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_logic_formula -> [Pos]
rangeSpan x :: FOF_logic_formula
x = case FOF_logic_formula
x of
    FOFLF_binary a :: FOF_binary_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_binary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_binary_formula
a]
    FOFLF_unitary a :: FOF_unitary_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_unitary_formula
a]

instance GetRange FOF_binary_formula where
  getRange :: FOF_binary_formula -> Range
getRange = Range -> FOF_binary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_binary_formula -> [Pos]
rangeSpan x :: FOF_binary_formula
x = case FOF_binary_formula
x of
    FOFBF_nonassoc a :: FOF_binary_nonassoc
a -> [[Pos]] -> [Pos]
joinRanges [FOF_binary_nonassoc -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_binary_nonassoc
a]
    FOFBF_assoc a :: FOF_binary_assoc
a -> [[Pos]] -> [Pos]
joinRanges [FOF_binary_assoc -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_binary_assoc
a]

instance GetRange FOF_binary_nonassoc where
  getRange :: FOF_binary_nonassoc -> Range
getRange = Range -> FOF_binary_nonassoc -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_binary_nonassoc -> [Pos]
rangeSpan x :: FOF_binary_nonassoc
x = case FOF_binary_nonassoc
x of
    FOF_binary_nonassoc a :: Binary_connective
a b :: FOF_unitary_formula
b c :: FOF_unitary_formula
c -> [[Pos]] -> [Pos]
joinRanges [Binary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Binary_connective
a, FOF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_unitary_formula
b,
                                             FOF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_unitary_formula
c]

instance GetRange FOF_binary_assoc where
  getRange :: FOF_binary_assoc -> Range
getRange = Range -> FOF_binary_assoc -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_binary_assoc -> [Pos]
rangeSpan x :: FOF_binary_assoc
x = case FOF_binary_assoc
x of
    FOFBA_or a :: [FOF_unitary_formula]
a -> [[Pos]] -> [Pos]
joinRanges [[FOF_unitary_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_unitary_formula]
a]
    FOFBA_and a :: [FOF_unitary_formula]
a -> [[Pos]] -> [Pos]
joinRanges [[FOF_unitary_formula] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_unitary_formula]
a]

instance GetRange FOF_unitary_formula where
  getRange :: FOF_unitary_formula -> Range
getRange = Range -> FOF_unitary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_unitary_formula -> [Pos]
rangeSpan x :: FOF_unitary_formula
x = case FOF_unitary_formula
x of
    FOFUF_quantified a :: FOF_quantified_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_quantified_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_quantified_formula
a]
    FOFUF_unary a :: FOF_unary_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_unary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_unary_formula
a]
    FOFUF_atomic a :: FOF_atomic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_atomic_formula
a]
    FOFUF_logic a :: FOF_logic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_logic_formula
a]

instance GetRange FOF_quantified_formula where
  getRange :: FOF_quantified_formula -> Range
getRange = Range -> FOF_quantified_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_quantified_formula -> [Pos]
rangeSpan x :: FOF_quantified_formula
x = case FOF_quantified_formula
x of
    FOF_quantified_formula a :: FOF_quantifier
a b :: FOF_variable_list
b c :: FOF_unitary_formula
c -> [[Pos]] -> [Pos]
joinRanges [FOF_quantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_quantifier
a,
                                                FOF_variable_list -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_variable_list
b, FOF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_unitary_formula
c]

instance GetRange FOF_unary_formula where
  getRange :: FOF_unary_formula -> Range
getRange = Range -> FOF_unary_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_unary_formula -> [Pos]
rangeSpan x :: FOF_unary_formula
x = case FOF_unary_formula
x of
    FOFUF_connective a :: Unary_connective
a b :: FOF_unitary_formula
b -> [[Pos]] -> [Pos]
joinRanges [Unary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Unary_connective
a, FOF_unitary_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_unitary_formula
b]
    FOFUF_infix a :: FOF_infix_unary
a -> [[Pos]] -> [Pos]
joinRanges [FOF_infix_unary -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_infix_unary
a]

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

instance GetRange FOF_atomic_formula where
  getRange :: FOF_atomic_formula -> Range
getRange = Range -> FOF_atomic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_atomic_formula -> [Pos]
rangeSpan x :: FOF_atomic_formula
x = case FOF_atomic_formula
x of
    FOFAT_plain a :: FOF_plain_atomic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_plain_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_plain_atomic_formula
a]
    FOFAT_defined a :: FOF_defined_atomic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_defined_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_defined_atomic_formula
a]
    FOFAT_system a :: FOF_system_atomic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_system_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_system_atomic_formula
a]

instance GetRange FOF_plain_atomic_formula where
  getRange :: FOF_plain_atomic_formula -> Range
getRange = Range -> FOF_plain_atomic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_plain_atomic_formula -> [Pos]
rangeSpan x :: FOF_plain_atomic_formula
x = case FOF_plain_atomic_formula
x of
    FOFPAF_proposition a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    FOFPAF_predicate a :: Token
a b :: [FOF_term]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [FOF_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_term]
b]

instance GetRange FOF_defined_atomic_formula where
  getRange :: FOF_defined_atomic_formula -> Range
getRange = Range -> FOF_defined_atomic_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_defined_atomic_formula -> [Pos]
rangeSpan x :: FOF_defined_atomic_formula
x = case FOF_defined_atomic_formula
x of
    FOFDAF_plain a :: FOF_defined_plain_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_defined_plain_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_defined_plain_formula
a]
    FOFDAF_infix a :: FOF_defined_infix_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_defined_infix_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_defined_infix_formula
a]

instance GetRange FOF_defined_plain_formula where
  getRange :: FOF_defined_plain_formula -> Range
getRange = Range -> FOF_defined_plain_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_defined_plain_formula -> [Pos]
rangeSpan x :: FOF_defined_plain_formula
x = case FOF_defined_plain_formula
x of
    FOFDPF_proposition a :: Defined_proposition
a -> [[Pos]] -> [Pos]
joinRanges [Defined_proposition -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_proposition
a]
    FOFDPF_predicate a :: Defined_predicate
a b :: [FOF_term]
b -> [[Pos]] -> [Pos]
joinRanges [Defined_predicate -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_predicate
a, [FOF_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_term]
b]

instance GetRange FOF_defined_infix_formula where
  getRange :: FOF_defined_infix_formula -> Range
getRange = Range -> FOF_defined_infix_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_defined_infix_formula -> [Pos]
rangeSpan x :: FOF_defined_infix_formula
x = case FOF_defined_infix_formula
x of
    FOF_defined_infix_formula a :: Defined_infix_pred
a b :: FOF_term
b c :: FOF_term
c -> [[Pos]] -> [Pos]
joinRanges [Defined_infix_pred -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_infix_pred
a,
                                                   FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
b, FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
c]

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

instance GetRange FOF_plain_term where
  getRange :: FOF_plain_term -> Range
getRange = Range -> FOF_plain_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_plain_term -> [Pos]
rangeSpan x :: FOF_plain_term
x = case FOF_plain_term
x of
    FOFPT_constant a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    FOFPT_functor a :: Token
a b :: [FOF_term]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [FOF_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_term]
b]

instance GetRange FOF_defined_term where
  getRange :: FOF_defined_term -> Range
getRange = Range -> FOF_defined_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_defined_term -> [Pos]
rangeSpan x :: FOF_defined_term
x = case FOF_defined_term
x of
    FOFDT_term a :: Defined_term
a -> [[Pos]] -> [Pos]
joinRanges [Defined_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_term
a]
    FOFDT_atomic a :: FOF_defined_atomic_term
a -> [[Pos]] -> [Pos]
joinRanges [FOF_defined_atomic_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_defined_atomic_term
a]

instance GetRange FOF_defined_atomic_term where
  getRange :: FOF_defined_atomic_term -> Range
getRange = Range -> FOF_defined_atomic_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_defined_atomic_term -> [Pos]
rangeSpan x :: FOF_defined_atomic_term
x = case FOF_defined_atomic_term
x of
    FOFDAT_plain a :: FOF_defined_plain_term
a -> [[Pos]] -> [Pos]
joinRanges [FOF_defined_plain_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_defined_plain_term
a]

instance GetRange FOF_defined_plain_term where
  getRange :: FOF_defined_plain_term -> Range
getRange = Range -> FOF_defined_plain_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_defined_plain_term -> [Pos]
rangeSpan x :: FOF_defined_plain_term
x = case FOF_defined_plain_term
x of
    FOFDPT_constant a :: Defined_functor
a -> [[Pos]] -> [Pos]
joinRanges [Defined_functor -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_functor
a]
    FOFDPT_functor a :: Defined_functor
a b :: [FOF_term]
b -> [[Pos]] -> [Pos]
joinRanges [Defined_functor -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_functor
a, [FOF_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_term]
b]

instance GetRange FOF_system_term where
  getRange :: FOF_system_term -> Range
getRange = Range -> FOF_system_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_system_term -> [Pos]
rangeSpan x :: FOF_system_term
x = case FOF_system_term
x of
    FOFST_constant a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    FOFST_functor a :: Token
a b :: [FOF_term]
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, [FOF_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FOF_term]
b]

instance GetRange FOF_term where
  getRange :: FOF_term -> Range
getRange = Range -> FOF_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_term -> [Pos]
rangeSpan x :: FOF_term
x = case FOF_term
x of
    FOFT_function a :: FOF_function_term
a -> [[Pos]] -> [Pos]
joinRanges [FOF_function_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_function_term
a]
    FOFT_variable a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    FOFT_conditional a :: TFF_conditional_term
a -> [[Pos]] -> [Pos]
joinRanges [TFF_conditional_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_conditional_term
a]
    FOFT_let a :: TFF_let_term
a -> [[Pos]] -> [Pos]
joinRanges [TFF_let_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_term
a]

instance GetRange FOF_function_term where
  getRange :: FOF_function_term -> Range
getRange = Range -> FOF_function_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_function_term -> [Pos]
rangeSpan x :: FOF_function_term
x = case FOF_function_term
x of
    FOFFT_plain a :: FOF_plain_term
a -> [[Pos]] -> [Pos]
joinRanges [FOF_plain_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_plain_term
a]
    FOFFT_defined a :: FOF_defined_term
a -> [[Pos]] -> [Pos]
joinRanges [FOF_defined_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_defined_term
a]
    FOFFT_system a :: FOF_system_term
a -> [[Pos]] -> [Pos]
joinRanges [FOF_system_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_system_term
a]

instance GetRange TFF_conditional_term where
  getRange :: TFF_conditional_term -> Range
getRange = Range -> TFF_conditional_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_conditional_term -> [Pos]
rangeSpan x :: TFF_conditional_term
x = case TFF_conditional_term
x of
    TFF_conditional_term a :: TFF_logic_formula
a b :: FOF_term
b c :: FOF_term
c -> [[Pos]] -> [Pos]
joinRanges [TFF_logic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_logic_formula
a, FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
b,
                                              FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
c]

instance GetRange TFF_let_term where
  getRange :: TFF_let_term -> Range
getRange = Range -> TFF_let_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TFF_let_term -> [Pos]
rangeSpan x :: TFF_let_term
x = case TFF_let_term
x of
    TFFLT_formula a :: TFF_let_formula_defns
a b :: FOF_term
b -> [[Pos]] -> [Pos]
joinRanges [TFF_let_formula_defns -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_formula_defns
a, FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
b]
    TFFLT_term a :: TFF_let_term_defns
a b :: FOF_term
b -> [[Pos]] -> [Pos]
joinRanges [TFF_let_term_defns -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_let_term_defns
a, FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
b]

instance GetRange FOF_sequent where
  getRange :: FOF_sequent -> Range
getRange = Range -> FOF_sequent -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_sequent -> [Pos]
rangeSpan x :: FOF_sequent
x = case FOF_sequent
x of
    FOFS_plain a :: FOF_formula_tuple
a b :: FOF_formula_tuple
b -> [[Pos]] -> [Pos]
joinRanges [FOF_formula_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_formula_tuple
a, FOF_formula_tuple -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_formula_tuple
b]
    FOFS_parens a :: FOF_sequent
a -> [[Pos]] -> [Pos]
joinRanges [FOF_sequent -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_sequent
a]

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

instance GetRange CNF_formula where
  getRange :: CNF_formula -> Range
getRange = Range -> CNF_formula -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: CNF_formula -> [Pos]
rangeSpan x :: CNF_formula
x = case CNF_formula
x of
    CNFF_plain a :: Disjunction
a -> [[Pos]] -> [Pos]
joinRanges [Disjunction -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Disjunction
a]
    CNFF_parens a :: Disjunction
a -> [[Pos]] -> [Pos]
joinRanges [Disjunction -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Disjunction
a]

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

instance GetRange Literal where
  getRange :: Literal -> Range
getRange = Range -> Literal -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Literal -> [Pos]
rangeSpan x :: Literal
x = case Literal
x of
    Lit_atomic a :: FOF_atomic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_atomic_formula
a]
    Lit_negative a :: FOF_atomic_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_atomic_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_atomic_formula
a]
    Lit_fof_infix a :: FOF_infix_unary
a -> [[Pos]] -> [Pos]
joinRanges [FOF_infix_unary -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_infix_unary
a]

instance GetRange THF_quantifier where
  getRange :: THF_quantifier -> Range
getRange = Range -> THF_quantifier -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_quantifier -> [Pos]
rangeSpan x :: THF_quantifier
x = case THF_quantifier
x of
    THFQ_fof a :: FOF_quantifier
a -> [[Pos]] -> [Pos]
joinRanges [FOF_quantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_quantifier
a]
    THFQ_th0 a :: TH0_quantifier
a -> [[Pos]] -> [Pos]
joinRanges [TH0_quantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TH0_quantifier
a]
    THFQ_th1 a :: TH1_quantifier
a -> [[Pos]] -> [Pos]
joinRanges [TH1_quantifier -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TH1_quantifier
a]

instance GetRange TH1_quantifier where
  getRange :: TH1_quantifier -> Range
getRange = Range -> TH1_quantifier -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TH1_quantifier -> [Pos]
rangeSpan x :: TH1_quantifier
x = case TH1_quantifier
x of
    TH1_DependentProduct -> []
    TH1_DependentSum -> []

instance GetRange TH0_quantifier where
  getRange :: TH0_quantifier -> Range
getRange = Range -> TH0_quantifier -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TH0_quantifier -> [Pos]
rangeSpan x :: TH0_quantifier
x = case TH0_quantifier
x of
    TH0_LambdaBinder -> []
    TH0_IndefiniteDescription -> []
    TH0_DefiniteDescription -> []

instance GetRange THF_pair_connective where
  getRange :: THF_pair_connective -> Range
getRange = Range -> THF_pair_connective -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_pair_connective -> [Pos]
rangeSpan x :: THF_pair_connective
x = case THF_pair_connective
x of
    THF_infix_equality -> []
    Infix_inequality -> []
    THFPC_binary a :: Binary_connective
a -> [[Pos]] -> [Pos]
joinRanges [Binary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Binary_connective
a]
    THF_assignment -> []

instance GetRange THF_unary_connective where
  getRange :: THF_unary_connective -> Range
getRange = Range -> THF_unary_connective -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: THF_unary_connective -> [Pos]
rangeSpan x :: THF_unary_connective
x = case THF_unary_connective
x of
    THFUC_unary a :: Unary_connective
a -> [[Pos]] -> [Pos]
joinRanges [Unary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Unary_connective
a]
    THFUC_th1 a :: TH1_unary_connective
a -> [[Pos]] -> [Pos]
joinRanges [TH1_unary_connective -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TH1_unary_connective
a]

instance GetRange TH1_unary_connective where
  getRange :: TH1_unary_connective -> Range
getRange = Range -> TH1_unary_connective -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TH1_unary_connective -> [Pos]
rangeSpan x :: TH1_unary_connective
x = case TH1_unary_connective
x of
    TH1_PiForAll -> []
    TH1_PiSigmaExists -> []
    TH1_PiIndefiniteDescription -> []
    TH1_PiDefiniteDescription -> []
    TH1_PiEquality -> []

instance GetRange FOF_quantifier where
  getRange :: FOF_quantifier -> Range
getRange = Range -> FOF_quantifier -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: FOF_quantifier -> [Pos]
rangeSpan x :: FOF_quantifier
x = case FOF_quantifier
x of
    ForAll -> []
    Exists -> []

instance GetRange Binary_connective where
  getRange :: Binary_connective -> Range
getRange = Range -> Binary_connective -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Binary_connective -> [Pos]
rangeSpan x :: Binary_connective
x = case Binary_connective
x of
    Equivalence -> []
    Implication -> []
    ReverseImplication -> []
    XOR -> []
    NOR -> []
    NAND -> []

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

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

instance GetRange Defined_type where
  getRange :: Defined_type -> Range
getRange = Range -> Defined_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Defined_type -> [Pos]
rangeSpan x :: Defined_type
x = case Defined_type
x of
    OType -> []
    O -> []
    IType -> []
    I -> []
    TType -> []
    Real -> []
    Rat -> []
    Int -> []

instance GetRange Atom where
  getRange :: Atom -> Range
getRange = Range -> Atom -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Atom -> [Pos]
rangeSpan x :: Atom
x = case Atom
x of
    Atom_untyped a :: Untyped_atom
a -> [[Pos]] -> [Pos]
joinRanges [Untyped_atom -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Untyped_atom
a]
    Atom_constant a :: Defined_functor
a -> [[Pos]] -> [Pos]
joinRanges [Defined_functor -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Defined_functor
a]

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

instance GetRange Defined_proposition where
  getRange :: Defined_proposition -> Range
getRange = Range -> Defined_proposition -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Defined_proposition -> [Pos]
rangeSpan x :: Defined_proposition
x = case Defined_proposition
x of
    TPTP_true -> []
    TPTP_false -> []

instance GetRange Defined_predicate where
  getRange :: Defined_predicate -> Range
getRange = Range -> Defined_predicate -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Defined_predicate -> [Pos]
rangeSpan x :: Defined_predicate
x = case Defined_predicate
x of
    Distinct -> []
    Less -> []
    Lesseq -> []
    Greater -> []
    Greatereq -> []
    Is_int -> []
    Is_rat -> []
    Box_P -> []
    Box_i -> []
    Box_int -> []
    Box -> []
    Dia_P -> []
    Dia_i -> []
    Dia_int -> []
    Dia -> []

instance GetRange Defined_infix_pred where
  getRange :: Defined_infix_pred -> Range
getRange = Range -> Defined_infix_pred -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Defined_infix_pred -> [Pos]
rangeSpan x :: Defined_infix_pred
x = case Defined_infix_pred
x of
    Defined_infix_equality -> []
    Defined_assignment -> []

instance GetRange Defined_functor where
  getRange :: Defined_functor -> Range
getRange = Range -> Defined_functor -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Defined_functor -> [Pos]
rangeSpan x :: Defined_functor
x = case Defined_functor
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 -> []
    DF_atomic_defined_word a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]

instance GetRange Defined_term where
  getRange :: Defined_term -> Range
getRange = Range -> Defined_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Defined_term -> [Pos]
rangeSpan x :: Defined_term
x = case Defined_term
x of
    DT_number a :: Number
a -> [[Pos]] -> [Pos]
joinRanges [Number -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Number
a]
    DT_object 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
    Source_DAG a :: DAG_source
a -> [[Pos]] -> [Pos]
joinRanges [DAG_source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan DAG_source
a]
    Source_internal a :: Internal_source
a -> [[Pos]] -> [Pos]
joinRanges [Internal_source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Internal_source
a]
    Source_external a :: External_source
a -> [[Pos]] -> [Pos]
joinRanges [External_source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan External_source
a]
    Unknown_source -> []
    Source_many a :: [Source]
a -> [[Pos]] -> [Pos]
joinRanges [[Source] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Source]
a]

instance GetRange DAG_source where
  getRange :: DAG_source -> Range
getRange = Range -> DAG_source -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: DAG_source -> [Pos]
rangeSpan x :: DAG_source
x = case DAG_source
x of
    DAGS_name a :: Name
a -> [[Pos]] -> [Pos]
joinRanges [Name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Name
a]
    DAGS_record a :: Inference_record
a -> [[Pos]] -> [Pos]
joinRanges [Inference_record -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Inference_record
a]

instance GetRange Inference_record where
  getRange :: Inference_record -> Range
getRange = Range -> Inference_record -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Inference_record -> [Pos]
rangeSpan x :: Inference_record
x = case Inference_record
x of
    Inference_record a :: Token
a b :: Useful_info
b c :: [Parent_info]
c -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, Useful_info -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Useful_info
b,
                                          [Parent_info] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Parent_info]
c]

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

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

instance GetRange Intro_type where
  getRange :: Intro_type -> Range
getRange = Range -> Intro_type -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Intro_type -> [Pos]
rangeSpan x :: Intro_type
x = case Intro_type
x of
    IntroTypeDefinition -> []
    AxiomOfChoice -> []
    Tautology -> []
    IntroTypeAssumption -> []

instance GetRange External_source where
  getRange :: External_source -> Range
getRange = Range -> External_source -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: External_source -> [Pos]
rangeSpan x :: External_source
x = case External_source
x of
    ExtSrc_file a :: File_source
a -> [[Pos]] -> [Pos]
joinRanges [File_source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan File_source
a]
    ExtSrc_theory a :: Theory
a -> [[Pos]] -> [Pos]
joinRanges [Theory -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Theory
a]
    ExtSrc_creator a :: Creator_source
a -> [[Pos]] -> [Pos]
joinRanges [Creator_source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Creator_source
a]

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

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

instance GetRange Theory_name where
  getRange :: Theory_name -> Range
getRange = Range -> Theory_name -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Theory_name -> [Pos]
rangeSpan x :: Theory_name
x = case Theory_name
x of
    TN_equality -> []
    TN_ac -> []

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

instance GetRange Useful_info where
  getRange :: Useful_info -> Range
getRange = Range -> Useful_info -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Useful_info -> [Pos]
rangeSpan x :: Useful_info
x = case Useful_info
x of
    UI_items a :: [Info_item]
a -> [[Pos]] -> [Pos]
joinRanges [[Info_item] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Info_item]
a]
    UI_general_list a :: [General_term]
a -> [[Pos]] -> [Pos]
joinRanges [[General_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [General_term]
a]

instance GetRange Info_item where
  getRange :: Info_item -> Range
getRange = Range -> Info_item -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Info_item -> [Pos]
rangeSpan x :: Info_item
x = case Info_item
x of
    Info_formula a :: Formula_item
a -> [[Pos]] -> [Pos]
joinRanges [Formula_item -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_item
a]
    Info_inference a :: Inference_item
a -> [[Pos]] -> [Pos]
joinRanges [Inference_item -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Inference_item
a]
    Info_general a :: General_function
a -> [[Pos]] -> [Pos]
joinRanges [General_function -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan General_function
a]

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

instance GetRange Inference_item where
  getRange :: Inference_item -> Range
getRange = Range -> Inference_item -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Inference_item -> [Pos]
rangeSpan x :: Inference_item
x = case Inference_item
x of
    Inf_status a :: Inference_status
a -> [[Pos]] -> [Pos]
joinRanges [Inference_status -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Inference_status
a]
    Inf_assumption a :: [Name]
a -> [[Pos]] -> [Pos]
joinRanges [[Name] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Name]
a]
    Inf_symbol a :: New_symbol_record
a -> [[Pos]] -> [Pos]
joinRanges [New_symbol_record -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan New_symbol_record
a]
    Inf_refutation a :: File_source
a -> [[Pos]] -> [Pos]
joinRanges [File_source -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan File_source
a]

instance GetRange Inference_status where
  getRange :: Inference_status -> Range
getRange = Range -> Inference_status -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Inference_status -> [Pos]
rangeSpan x :: Inference_status
x = case Inference_status
x of
    Inf_value a :: Status_value
a -> [[Pos]] -> [Pos]
joinRanges [Status_value -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Status_value
a]
    Inf_info a :: Inference_info
a -> [[Pos]] -> [Pos]
joinRanges [Inference_info -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Inference_info
a]

instance GetRange Status_value where
  getRange :: Status_value -> Range
getRange = Range -> Status_value -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Status_value -> [Pos]
rangeSpan x :: Status_value
x = case Status_value
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 Inference_info where
  getRange :: Inference_info -> Range
getRange = Range -> Inference_info -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Inference_info -> [Pos]
rangeSpan x :: Inference_info
x = case Inference_info
x of
    Inference_info a :: Token
a b :: Token
b c :: [General_term]
c -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
b,
                                        [General_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [General_term]
c]

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

instance GetRange Principal_symbol where
  getRange :: Principal_symbol -> Range
getRange = Range -> Principal_symbol -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Principal_symbol -> [Pos]
rangeSpan x :: Principal_symbol
x = case Principal_symbol
x of
    PS_functor a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    PS_variable 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
    Include a :: File_name
a b :: Formula_selection
b -> [[Pos]] -> [Pos]
joinRanges [File_name -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan File_name
a, Formula_selection -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_selection
b]

instance GetRange General_term where
  getRange :: General_term -> Range
getRange = Range -> General_term -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: General_term -> [Pos]
rangeSpan x :: General_term
x = case General_term
x of
    GT_data a :: General_data
a -> [[Pos]] -> [Pos]
joinRanges [General_data -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan General_data
a]
    GT_DataTerm a :: General_data
a b :: General_term
b -> [[Pos]] -> [Pos]
joinRanges [General_data -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan General_data
a, General_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan General_term
b]
    GT_list a :: [General_term]
a -> [[Pos]] -> [Pos]
joinRanges [[General_term] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [General_term]
a]

instance GetRange General_data where
  getRange :: General_data -> Range
getRange = Range -> General_data -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: General_data -> [Pos]
rangeSpan x :: General_data
x = case General_data
x of
    GD_atomic_word a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    GD_general_function a :: General_function
a -> [[Pos]] -> [Pos]
joinRanges [General_function -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan General_function
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 :: Formula_data
a -> [[Pos]] -> [Pos]
joinRanges [Formula_data -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_data
a]
    GD_bind a :: Token
a b :: Formula_data
b -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a, Formula_data -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Formula_data
b]

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

instance GetRange Formula_data where
  getRange :: Formula_data -> Range
getRange = Range -> Formula_data -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Formula_data -> [Pos]
rangeSpan x :: Formula_data
x = case Formula_data
x of
    FD_THF a :: THF_formula
a -> [[Pos]] -> [Pos]
joinRanges [THF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan THF_formula
a]
    FD_TFF a :: TFF_formula
a -> [[Pos]] -> [Pos]
joinRanges [TFF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TFF_formula
a]
    FD_FOF a :: FOF_formula
a -> [[Pos]] -> [Pos]
joinRanges [FOF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_formula
a]
    FD_CNF a :: CNF_formula
a -> [[Pos]] -> [Pos]
joinRanges [CNF_formula -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan CNF_formula
a]
    FD_FOT a :: FOF_term
a -> [[Pos]] -> [Pos]
joinRanges [FOF_term -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FOF_term
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
    NameString a :: Token
a -> [[Pos]] -> [Pos]
joinRanges [Token -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Token
a]
    NameInteger a :: Integer
a -> [[Pos]] -> [Pos]
joinRanges [Integer -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Integer
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
    NumInteger a :: Integer
a -> [[Pos]] -> [Pos]
joinRanges [Integer -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Integer
a]
    NumRational a :: Rational
a -> [[Pos]] -> [Pos]
joinRanges [Rational -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Rational
a]
    NumReal a :: Double
a -> [[Pos]] -> [Pos]
joinRanges [Double -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Double
a]