{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./SoftFOL/Sign.hs
Description :  Data structures representing SPASS signatures.
Copyright   :  (c) Rene Wagner, Heng Jiang, Uni Bremen 2007
License     :  GPLv2 or higher, see LICENSE.txt

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

Data structures representing SPASS signatures.
   Refer to <http://spass.mpi-sb.mpg.de/webspass/help/syntax/dfgsyntax.html>
   for the SPASS syntax documentation.
-}

module SoftFOL.Sign where

import Data.Data
import Data.Char
import Data.Maybe (isNothing)
import qualified Data.Map as Map
import qualified Data.Set as Set

import qualified Common.Lib.Rel as Rel
import Common.AS_Annotation hiding (Name)
import Common.Id
import Common.DefaultMorphism
import qualified Control.Monad.Fail as Fail

-- * Externally used data structures

{- |
  We use the DefaultMorphism for SPASS.
-}
type SoftFOLMorphism = DefaultMorphism Sign

type SortMap = Map.Map SPIdentifier (Maybe Generated)

type FuncMap = Map.Map SPIdentifier (Set.Set ([SPIdentifier], SPIdentifier))

type PredMap = Map.Map SPIdentifier (Set.Set [SPIdentifier])

{- |
  This Signature data type will be translated to the SoftFOL data types
  internally.

  sortRel contains the sorts relation. For each sort we need to know
  if it is a generated sort and if so by which functions it is
  possibly freely generated (sortMap).

  For each function the types of all arguments and the return type
  must be known (funcMap). The same goes for the arguments of a predicate
  (predMap).
-}
data Sign = Sign { Sign -> Rel SPIdentifier
sortRel :: Rel.Rel SPIdentifier
                 , Sign -> SortMap
sortMap :: SortMap
                 , Sign -> FuncMap
funcMap :: FuncMap
                 , Sign -> PredMap
predMap :: PredMap
                 , Sign -> Bool
singleSorted :: Bool
                 } deriving (Int -> Sign -> ShowS
[Sign] -> ShowS
Sign -> String
(Int -> Sign -> ShowS)
-> (Sign -> String) -> ([Sign] -> ShowS) -> Show Sign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sign] -> ShowS
$cshowList :: [Sign] -> ShowS
show :: Sign -> String
$cshow :: Sign -> String
showsPrec :: Int -> Sign -> ShowS
$cshowsPrec :: Int -> Sign -> ShowS
Show, Sign -> Sign -> Bool
(Sign -> Sign -> Bool) -> (Sign -> Sign -> Bool) -> Eq Sign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sign -> Sign -> Bool
$c/= :: Sign -> Sign -> Bool
== :: Sign -> Sign -> Bool
$c== :: Sign -> Sign -> Bool
Eq, Eq Sign
Eq Sign =>
(Sign -> Sign -> Ordering)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Bool)
-> (Sign -> Sign -> Sign)
-> (Sign -> Sign -> Sign)
-> Ord Sign
Sign -> Sign -> Bool
Sign -> Sign -> Ordering
Sign -> Sign -> Sign
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sign -> Sign -> Sign
$cmin :: Sign -> Sign -> Sign
max :: Sign -> Sign -> Sign
$cmax :: Sign -> Sign -> Sign
>= :: Sign -> Sign -> Bool
$c>= :: Sign -> Sign -> Bool
> :: Sign -> Sign -> Bool
$c> :: Sign -> Sign -> Bool
<= :: Sign -> Sign -> Bool
$c<= :: Sign -> Sign -> Bool
< :: Sign -> Sign -> Bool
$c< :: Sign -> Sign -> Bool
compare :: Sign -> Sign -> Ordering
$ccompare :: Sign -> Sign -> Ordering
$cp1Ord :: Eq Sign
Ord, Typeable, Typeable Sign
Constr
DataType
Typeable Sign =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Sign -> c Sign)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Sign)
-> (Sign -> Constr)
-> (Sign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Sign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign))
-> ((forall b. Data b => b -> b) -> Sign -> Sign)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sign -> m Sign)
-> Data Sign
Sign -> Constr
Sign -> DataType
(forall b. Data b => b -> b) -> Sign -> Sign
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
forall u. (forall d. Data d => d -> u) -> Sign -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cSign :: Constr
$tSign :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapMp :: (forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapM :: (forall d. Data d => d -> m d) -> Sign -> m Sign
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sign -> m Sign
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sign -> u
gmapQ :: (forall d. Data d => d -> u) -> Sign -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sign -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign -> r
gmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
$cgmapT :: (forall b. Data b => b -> b) -> Sign -> Sign
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sign)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Sign)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sign)
dataTypeOf :: Sign -> DataType
$cdataTypeOf :: Sign -> DataType
toConstr :: Sign -> Constr
$ctoConstr :: Sign -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sign
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sign -> c Sign
$cp1Data :: Typeable Sign
Data)

{- |
  Sorts can be (freely) generated by a set of functions.
-}
data Generated = Generated { Generated -> Bool
freely :: Bool
                           , Generated -> [SPIdentifier]
byFunctions :: [SPIdentifier]
                           } deriving (Int -> Generated -> ShowS
[Generated] -> ShowS
Generated -> String
(Int -> Generated -> ShowS)
-> (Generated -> String)
-> ([Generated] -> ShowS)
-> Show Generated
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Generated] -> ShowS
$cshowList :: [Generated] -> ShowS
show :: Generated -> String
$cshow :: Generated -> String
showsPrec :: Int -> Generated -> ShowS
$cshowsPrec :: Int -> Generated -> ShowS
Show, Generated -> Generated -> Bool
(Generated -> Generated -> Bool)
-> (Generated -> Generated -> Bool) -> Eq Generated
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Generated -> Generated -> Bool
$c/= :: Generated -> Generated -> Bool
== :: Generated -> Generated -> Bool
$c== :: Generated -> Generated -> Bool
Eq, Eq Generated
Eq Generated =>
(Generated -> Generated -> Ordering)
-> (Generated -> Generated -> Bool)
-> (Generated -> Generated -> Bool)
-> (Generated -> Generated -> Bool)
-> (Generated -> Generated -> Bool)
-> (Generated -> Generated -> Generated)
-> (Generated -> Generated -> Generated)
-> Ord Generated
Generated -> Generated -> Bool
Generated -> Generated -> Ordering
Generated -> Generated -> Generated
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Generated -> Generated -> Generated
$cmin :: Generated -> Generated -> Generated
max :: Generated -> Generated -> Generated
$cmax :: Generated -> Generated -> Generated
>= :: Generated -> Generated -> Bool
$c>= :: Generated -> Generated -> Bool
> :: Generated -> Generated -> Bool
$c> :: Generated -> Generated -> Bool
<= :: Generated -> Generated -> Bool
$c<= :: Generated -> Generated -> Bool
< :: Generated -> Generated -> Bool
$c< :: Generated -> Generated -> Bool
compare :: Generated -> Generated -> Ordering
$ccompare :: Generated -> Generated -> Ordering
$cp1Ord :: Eq Generated
Ord, Typeable, Typeable Generated
Constr
DataType
Typeable Generated =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Generated -> c Generated)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Generated)
-> (Generated -> Constr)
-> (Generated -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Generated))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Generated))
-> ((forall b. Data b => b -> b) -> Generated -> Generated)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Generated -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Generated -> r)
-> (forall u. (forall d. Data d => d -> u) -> Generated -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Generated -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Generated -> m Generated)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Generated -> m Generated)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Generated -> m Generated)
-> Data Generated
Generated -> Constr
Generated -> DataType
(forall b. Data b => b -> b) -> Generated -> Generated
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Generated -> c Generated
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Generated
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Generated -> u
forall u. (forall d. Data d => d -> u) -> Generated -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Generated -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Generated -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Generated -> m Generated
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Generated -> m Generated
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Generated
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Generated -> c Generated
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Generated)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Generated)
$cGenerated :: Constr
$tGenerated :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Generated -> m Generated
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Generated -> m Generated
gmapMp :: (forall d. Data d => d -> m d) -> Generated -> m Generated
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Generated -> m Generated
gmapM :: (forall d. Data d => d -> m d) -> Generated -> m Generated
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Generated -> m Generated
gmapQi :: Int -> (forall d. Data d => d -> u) -> Generated -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Generated -> u
gmapQ :: (forall d. Data d => d -> u) -> Generated -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Generated -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Generated -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Generated -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Generated -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Generated -> r
gmapT :: (forall b. Data b => b -> b) -> Generated -> Generated
$cgmapT :: (forall b. Data b => b -> b) -> Generated -> Generated
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Generated)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Generated)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Generated)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Generated)
dataTypeOf :: Generated -> DataType
$cdataTypeOf :: Generated -> DataType
toConstr :: Generated -> Constr
$ctoConstr :: Generated -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Generated
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Generated
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Generated -> c Generated
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Generated -> c Generated
$cp1Data :: Typeable Generated
Data)

{- |
  Creates an empty Signature.
-}
emptySign :: Sign
emptySign :: Sign
emptySign = Sign :: Rel SPIdentifier -> SortMap -> FuncMap -> PredMap -> Bool -> Sign
Sign { sortRel :: Rel SPIdentifier
sortRel = Rel SPIdentifier
forall a. Rel a
Rel.empty
                 , sortMap :: SortMap
sortMap = SortMap
forall k a. Map k a
Map.empty
                 , funcMap :: FuncMap
funcMap = FuncMap
forall k a. Map k a
Map.empty
                 , predMap :: PredMap
predMap = PredMap
forall k a. Map k a
Map.empty
                 , singleSorted :: Bool
singleSorted = Bool
True
                 }

{- |
  A Sentence is a SoftFOL Term.
-}
type Sentence = SPTerm

{- |
  A SPASS Identifier is a String for now.
-}
type SPIdentifier = Token


{- |
  Check a Sign if it is single sorted (and the sort is non-generated).
-}
singleSortNotGen :: Sign -> Bool
singleSortNotGen :: Sign -> Bool
singleSortNotGen spSig :: Sign
spSig = Sign -> Bool
singleSorted Sign
spSig Bool -> Bool -> Bool
&&
                  Maybe Generated -> Bool
forall a. Maybe a -> Bool
isNothing ([Maybe Generated] -> Maybe Generated
forall a. [a] -> a
head ([Maybe Generated] -> Maybe Generated)
-> (SortMap -> [Maybe Generated]) -> SortMap -> Maybe Generated
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SortMap -> [Maybe Generated]
forall k a. Map k a -> [a]
Map.elems (SortMap -> Maybe Generated) -> SortMap -> Maybe Generated
forall a b. (a -> b) -> a -> b
$ Sign -> SortMap
sortMap Sign
spSig)

-- ** Symbol related datatypes

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

instance GetRange SFSymbol

{- |
   Symbol types of SoftFOL. (not related to CASL)
-}

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

sfSymbKind :: SFSymbType -> String
sfSymbKind :: SFSymbType -> String
sfSymbKind t :: SFSymbType
t = case SFSymbType
t of
  SFOpType {} -> "function"
  SFPredType {} -> "predicate"
  SFSortType -> "sort"

-- * Internal data structures

-- ** SPASS Problems

{- |
  A SPASS problem consists of a description and a logical part. The optional
  settings part hasn't been implemented yet.
-}
data SPProblem =
        SPProblem { SPProblem -> String
identifier :: String,
                    SPProblem -> SPDescription
description :: SPDescription,
                    SPProblem -> SPLogicalPart
logicalPart :: SPLogicalPart,
                    SPProblem -> [SPSetting]
settings :: [SPSetting]
                    }
      deriving (Int -> SPProblem -> ShowS
[SPProblem] -> ShowS
SPProblem -> String
(Int -> SPProblem -> ShowS)
-> (SPProblem -> String)
-> ([SPProblem] -> ShowS)
-> Show SPProblem
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPProblem] -> ShowS
$cshowList :: [SPProblem] -> ShowS
show :: SPProblem -> String
$cshow :: SPProblem -> String
showsPrec :: Int -> SPProblem -> ShowS
$cshowsPrec :: Int -> SPProblem -> ShowS
Show, SPProblem -> SPProblem -> Bool
(SPProblem -> SPProblem -> Bool)
-> (SPProblem -> SPProblem -> Bool) -> Eq SPProblem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPProblem -> SPProblem -> Bool
$c/= :: SPProblem -> SPProblem -> Bool
== :: SPProblem -> SPProblem -> Bool
$c== :: SPProblem -> SPProblem -> Bool
Eq, Eq SPProblem
Eq SPProblem =>
(SPProblem -> SPProblem -> Ordering)
-> (SPProblem -> SPProblem -> Bool)
-> (SPProblem -> SPProblem -> Bool)
-> (SPProblem -> SPProblem -> Bool)
-> (SPProblem -> SPProblem -> Bool)
-> (SPProblem -> SPProblem -> SPProblem)
-> (SPProblem -> SPProblem -> SPProblem)
-> Ord SPProblem
SPProblem -> SPProblem -> Bool
SPProblem -> SPProblem -> Ordering
SPProblem -> SPProblem -> SPProblem
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPProblem -> SPProblem -> SPProblem
$cmin :: SPProblem -> SPProblem -> SPProblem
max :: SPProblem -> SPProblem -> SPProblem
$cmax :: SPProblem -> SPProblem -> SPProblem
>= :: SPProblem -> SPProblem -> Bool
$c>= :: SPProblem -> SPProblem -> Bool
> :: SPProblem -> SPProblem -> Bool
$c> :: SPProblem -> SPProblem -> Bool
<= :: SPProblem -> SPProblem -> Bool
$c<= :: SPProblem -> SPProblem -> Bool
< :: SPProblem -> SPProblem -> Bool
$c< :: SPProblem -> SPProblem -> Bool
compare :: SPProblem -> SPProblem -> Ordering
$ccompare :: SPProblem -> SPProblem -> Ordering
$cp1Ord :: Eq SPProblem
Ord, Typeable, Typeable SPProblem
Constr
DataType
Typeable SPProblem =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPProblem -> c SPProblem)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPProblem)
-> (SPProblem -> Constr)
-> (SPProblem -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPProblem))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPProblem))
-> ((forall b. Data b => b -> b) -> SPProblem -> SPProblem)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPProblem -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPProblem -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPProblem -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPProblem -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPProblem -> m SPProblem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPProblem -> m SPProblem)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPProblem -> m SPProblem)
-> Data SPProblem
SPProblem -> Constr
SPProblem -> DataType
(forall b. Data b => b -> b) -> SPProblem -> SPProblem
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProblem -> c SPProblem
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProblem
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPProblem -> u
forall u. (forall d. Data d => d -> u) -> SPProblem -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProblem -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProblem -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProblem
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProblem -> c SPProblem
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPProblem)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPProblem)
$cSPProblem :: Constr
$tSPProblem :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
gmapMp :: (forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
gmapM :: (forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPProblem -> m SPProblem
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPProblem -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPProblem -> u
gmapQ :: (forall d. Data d => d -> u) -> SPProblem -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPProblem -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProblem -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProblem -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProblem -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProblem -> r
gmapT :: (forall b. Data b => b -> b) -> SPProblem -> SPProblem
$cgmapT :: (forall b. Data b => b -> b) -> SPProblem -> SPProblem
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPProblem)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPProblem)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPProblem)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPProblem)
dataTypeOf :: SPProblem -> DataType
$cdataTypeOf :: SPProblem -> DataType
toConstr :: SPProblem -> Constr
$ctoConstr :: SPProblem -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProblem
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProblem
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProblem -> c SPProblem
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProblem -> c SPProblem
$cp1Data :: Typeable SPProblem
Data)

-- ** SPASS Logical Parts

{- |
  A SPASS logical part consists of a symbol list, a declaration list, and a
  set of formula lists. Support for clause lists and proof lists hasn't
  been implemented yet.
-}
data SPLogicalPart =
        SPLogicalPart { SPLogicalPart -> Maybe SPSymbolList
symbolList :: Maybe SPSymbolList,
                        SPLogicalPart -> Maybe [SPDeclaration]
declarationList :: Maybe [SPDeclaration],
                        SPLogicalPart -> [SPFormulaList]
formulaLists :: [SPFormulaList],
                        SPLogicalPart -> [SPClauseList]
clauseLists :: [SPClauseList],
                        SPLogicalPart -> [SPProofList]
proofLists :: [SPProofList]
                        }
      deriving (Int -> SPLogicalPart -> ShowS
[SPLogicalPart] -> ShowS
SPLogicalPart -> String
(Int -> SPLogicalPart -> ShowS)
-> (SPLogicalPart -> String)
-> ([SPLogicalPart] -> ShowS)
-> Show SPLogicalPart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPLogicalPart] -> ShowS
$cshowList :: [SPLogicalPart] -> ShowS
show :: SPLogicalPart -> String
$cshow :: SPLogicalPart -> String
showsPrec :: Int -> SPLogicalPart -> ShowS
$cshowsPrec :: Int -> SPLogicalPart -> ShowS
Show, SPLogicalPart -> SPLogicalPart -> Bool
(SPLogicalPart -> SPLogicalPart -> Bool)
-> (SPLogicalPart -> SPLogicalPart -> Bool) -> Eq SPLogicalPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPLogicalPart -> SPLogicalPart -> Bool
$c/= :: SPLogicalPart -> SPLogicalPart -> Bool
== :: SPLogicalPart -> SPLogicalPart -> Bool
$c== :: SPLogicalPart -> SPLogicalPart -> Bool
Eq, Eq SPLogicalPart
Eq SPLogicalPart =>
(SPLogicalPart -> SPLogicalPart -> Ordering)
-> (SPLogicalPart -> SPLogicalPart -> Bool)
-> (SPLogicalPart -> SPLogicalPart -> Bool)
-> (SPLogicalPart -> SPLogicalPart -> Bool)
-> (SPLogicalPart -> SPLogicalPart -> Bool)
-> (SPLogicalPart -> SPLogicalPart -> SPLogicalPart)
-> (SPLogicalPart -> SPLogicalPart -> SPLogicalPart)
-> Ord SPLogicalPart
SPLogicalPart -> SPLogicalPart -> Bool
SPLogicalPart -> SPLogicalPart -> Ordering
SPLogicalPart -> SPLogicalPart -> SPLogicalPart
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPLogicalPart -> SPLogicalPart -> SPLogicalPart
$cmin :: SPLogicalPart -> SPLogicalPart -> SPLogicalPart
max :: SPLogicalPart -> SPLogicalPart -> SPLogicalPart
$cmax :: SPLogicalPart -> SPLogicalPart -> SPLogicalPart
>= :: SPLogicalPart -> SPLogicalPart -> Bool
$c>= :: SPLogicalPart -> SPLogicalPart -> Bool
> :: SPLogicalPart -> SPLogicalPart -> Bool
$c> :: SPLogicalPart -> SPLogicalPart -> Bool
<= :: SPLogicalPart -> SPLogicalPart -> Bool
$c<= :: SPLogicalPart -> SPLogicalPart -> Bool
< :: SPLogicalPart -> SPLogicalPart -> Bool
$c< :: SPLogicalPart -> SPLogicalPart -> Bool
compare :: SPLogicalPart -> SPLogicalPart -> Ordering
$ccompare :: SPLogicalPart -> SPLogicalPart -> Ordering
$cp1Ord :: Eq SPLogicalPart
Ord, Typeable, Typeable SPLogicalPart
Constr
DataType
Typeable SPLogicalPart =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPLogicalPart -> c SPLogicalPart)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPLogicalPart)
-> (SPLogicalPart -> Constr)
-> (SPLogicalPart -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPLogicalPart))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPLogicalPart))
-> ((forall b. Data b => b -> b) -> SPLogicalPart -> SPLogicalPart)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPLogicalPart -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPLogicalPart -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart)
-> Data SPLogicalPart
SPLogicalPart -> Constr
SPLogicalPart -> DataType
(forall b. Data b => b -> b) -> SPLogicalPart -> SPLogicalPart
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogicalPart -> c SPLogicalPart
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogicalPart
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPLogicalPart -> u
forall u. (forall d. Data d => d -> u) -> SPLogicalPart -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogicalPart
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogicalPart -> c SPLogicalPart
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPLogicalPart)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPLogicalPart)
$cSPLogicalPart :: Constr
$tSPLogicalPart :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
gmapMp :: (forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
gmapM :: (forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPLogicalPart -> m SPLogicalPart
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPLogicalPart -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPLogicalPart -> u
gmapQ :: (forall d. Data d => d -> u) -> SPLogicalPart -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPLogicalPart -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogicalPart -> r
gmapT :: (forall b. Data b => b -> b) -> SPLogicalPart -> SPLogicalPart
$cgmapT :: (forall b. Data b => b -> b) -> SPLogicalPart -> SPLogicalPart
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPLogicalPart)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPLogicalPart)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPLogicalPart)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPLogicalPart)
dataTypeOf :: SPLogicalPart -> DataType
$cdataTypeOf :: SPLogicalPart -> DataType
toConstr :: SPLogicalPart -> Constr
$ctoConstr :: SPLogicalPart -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogicalPart
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogicalPart
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogicalPart -> c SPLogicalPart
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogicalPart -> c SPLogicalPart
$cp1Data :: Typeable SPLogicalPart
Data)

emptySPLogicalPart :: SPLogicalPart
emptySPLogicalPart :: SPLogicalPart
emptySPLogicalPart = SPLogicalPart :: Maybe SPSymbolList
-> Maybe [SPDeclaration]
-> [SPFormulaList]
-> [SPClauseList]
-> [SPProofList]
-> SPLogicalPart
SPLogicalPart { symbolList :: Maybe SPSymbolList
symbolList = Maybe SPSymbolList
forall a. Maybe a
Nothing,
                                     declarationList :: Maybe [SPDeclaration]
declarationList = Maybe [SPDeclaration]
forall a. Maybe a
Nothing,
                                     formulaLists :: [SPFormulaList]
formulaLists = [],
                                     clauseLists :: [SPClauseList]
clauseLists = [],
                                     proofLists :: [SPProofList]
proofLists = []
                                   }

-- *** Symbol Lists

{- |
  All non-predefined signature symbols must be declared as part of a SPASS
  symbol list.
-}
data SPSymbolList =
        SPSymbolList { SPSymbolList -> [SPSignSym]
functions :: [SPSignSym],
                       SPSymbolList -> [SPSignSym]
predicates :: [SPSignSym],
                       SPSymbolList -> [SPSignSym]
sorts :: [SPSignSym]}
      deriving (Int -> SPSymbolList -> ShowS
[SPSymbolList] -> ShowS
SPSymbolList -> String
(Int -> SPSymbolList -> ShowS)
-> (SPSymbolList -> String)
-> ([SPSymbolList] -> ShowS)
-> Show SPSymbolList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPSymbolList] -> ShowS
$cshowList :: [SPSymbolList] -> ShowS
show :: SPSymbolList -> String
$cshow :: SPSymbolList -> String
showsPrec :: Int -> SPSymbolList -> ShowS
$cshowsPrec :: Int -> SPSymbolList -> ShowS
Show, SPSymbolList -> SPSymbolList -> Bool
(SPSymbolList -> SPSymbolList -> Bool)
-> (SPSymbolList -> SPSymbolList -> Bool) -> Eq SPSymbolList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPSymbolList -> SPSymbolList -> Bool
$c/= :: SPSymbolList -> SPSymbolList -> Bool
== :: SPSymbolList -> SPSymbolList -> Bool
$c== :: SPSymbolList -> SPSymbolList -> Bool
Eq, Eq SPSymbolList
Eq SPSymbolList =>
(SPSymbolList -> SPSymbolList -> Ordering)
-> (SPSymbolList -> SPSymbolList -> Bool)
-> (SPSymbolList -> SPSymbolList -> Bool)
-> (SPSymbolList -> SPSymbolList -> Bool)
-> (SPSymbolList -> SPSymbolList -> Bool)
-> (SPSymbolList -> SPSymbolList -> SPSymbolList)
-> (SPSymbolList -> SPSymbolList -> SPSymbolList)
-> Ord SPSymbolList
SPSymbolList -> SPSymbolList -> Bool
SPSymbolList -> SPSymbolList -> Ordering
SPSymbolList -> SPSymbolList -> SPSymbolList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPSymbolList -> SPSymbolList -> SPSymbolList
$cmin :: SPSymbolList -> SPSymbolList -> SPSymbolList
max :: SPSymbolList -> SPSymbolList -> SPSymbolList
$cmax :: SPSymbolList -> SPSymbolList -> SPSymbolList
>= :: SPSymbolList -> SPSymbolList -> Bool
$c>= :: SPSymbolList -> SPSymbolList -> Bool
> :: SPSymbolList -> SPSymbolList -> Bool
$c> :: SPSymbolList -> SPSymbolList -> Bool
<= :: SPSymbolList -> SPSymbolList -> Bool
$c<= :: SPSymbolList -> SPSymbolList -> Bool
< :: SPSymbolList -> SPSymbolList -> Bool
$c< :: SPSymbolList -> SPSymbolList -> Bool
compare :: SPSymbolList -> SPSymbolList -> Ordering
$ccompare :: SPSymbolList -> SPSymbolList -> Ordering
$cp1Ord :: Eq SPSymbolList
Ord, Typeable, Typeable SPSymbolList
Constr
DataType
Typeable SPSymbolList =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPSymbolList -> c SPSymbolList)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPSymbolList)
-> (SPSymbolList -> Constr)
-> (SPSymbolList -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPSymbolList))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPSymbolList))
-> ((forall b. Data b => b -> b) -> SPSymbolList -> SPSymbolList)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPSymbolList -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPSymbolList -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList)
-> Data SPSymbolList
SPSymbolList -> Constr
SPSymbolList -> DataType
(forall b. Data b => b -> b) -> SPSymbolList -> SPSymbolList
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbolList -> c SPSymbolList
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbolList
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPSymbolList -> u
forall u. (forall d. Data d => d -> u) -> SPSymbolList -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbolList
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbolList -> c SPSymbolList
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSymbolList)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPSymbolList)
$cSPSymbolList :: Constr
$tSPSymbolList :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
gmapMp :: (forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
gmapM :: (forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSymbolList -> m SPSymbolList
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPSymbolList -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPSymbolList -> u
gmapQ :: (forall d. Data d => d -> u) -> SPSymbolList -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPSymbolList -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbolList -> r
gmapT :: (forall b. Data b => b -> b) -> SPSymbolList -> SPSymbolList
$cgmapT :: (forall b. Data b => b -> b) -> SPSymbolList -> SPSymbolList
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPSymbolList)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPSymbolList)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPSymbolList)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSymbolList)
dataTypeOf :: SPSymbolList -> DataType
$cdataTypeOf :: SPSymbolList -> DataType
toConstr :: SPSymbolList -> Constr
$ctoConstr :: SPSymbolList -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbolList
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbolList
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbolList -> c SPSymbolList
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbolList -> c SPSymbolList
$cp1Data :: Typeable SPSymbolList
Data)

{- |
  Creates an empty SPASS Symbol List.
-}
emptySymbolList :: SPSymbolList
emptySymbolList :: SPSymbolList
emptySymbolList =
        SPSymbolList :: [SPSignSym] -> [SPSignSym] -> [SPSignSym] -> SPSymbolList
SPSymbolList { functions :: [SPSignSym]
functions = [],
                       predicates :: [SPSignSym]
predicates = [],
                       sorts :: [SPSignSym]
sorts = []}


{- |
  A common data type used for all signature symbols.
-}
data SPSignSym =
        SPSignSym { SPSignSym -> SPIdentifier
sym :: SPIdentifier,
                    SPSignSym -> Int
arity :: Int }
      | SPSimpleSignSym SPIdentifier
      deriving (Int -> SPSignSym -> ShowS
[SPSignSym] -> ShowS
SPSignSym -> String
(Int -> SPSignSym -> ShowS)
-> (SPSignSym -> String)
-> ([SPSignSym] -> ShowS)
-> Show SPSignSym
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPSignSym] -> ShowS
$cshowList :: [SPSignSym] -> ShowS
show :: SPSignSym -> String
$cshow :: SPSignSym -> String
showsPrec :: Int -> SPSignSym -> ShowS
$cshowsPrec :: Int -> SPSignSym -> ShowS
Show, SPSignSym -> SPSignSym -> Bool
(SPSignSym -> SPSignSym -> Bool)
-> (SPSignSym -> SPSignSym -> Bool) -> Eq SPSignSym
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPSignSym -> SPSignSym -> Bool
$c/= :: SPSignSym -> SPSignSym -> Bool
== :: SPSignSym -> SPSignSym -> Bool
$c== :: SPSignSym -> SPSignSym -> Bool
Eq, Eq SPSignSym
Eq SPSignSym =>
(SPSignSym -> SPSignSym -> Ordering)
-> (SPSignSym -> SPSignSym -> Bool)
-> (SPSignSym -> SPSignSym -> Bool)
-> (SPSignSym -> SPSignSym -> Bool)
-> (SPSignSym -> SPSignSym -> Bool)
-> (SPSignSym -> SPSignSym -> SPSignSym)
-> (SPSignSym -> SPSignSym -> SPSignSym)
-> Ord SPSignSym
SPSignSym -> SPSignSym -> Bool
SPSignSym -> SPSignSym -> Ordering
SPSignSym -> SPSignSym -> SPSignSym
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPSignSym -> SPSignSym -> SPSignSym
$cmin :: SPSignSym -> SPSignSym -> SPSignSym
max :: SPSignSym -> SPSignSym -> SPSignSym
$cmax :: SPSignSym -> SPSignSym -> SPSignSym
>= :: SPSignSym -> SPSignSym -> Bool
$c>= :: SPSignSym -> SPSignSym -> Bool
> :: SPSignSym -> SPSignSym -> Bool
$c> :: SPSignSym -> SPSignSym -> Bool
<= :: SPSignSym -> SPSignSym -> Bool
$c<= :: SPSignSym -> SPSignSym -> Bool
< :: SPSignSym -> SPSignSym -> Bool
$c< :: SPSignSym -> SPSignSym -> Bool
compare :: SPSignSym -> SPSignSym -> Ordering
$ccompare :: SPSignSym -> SPSignSym -> Ordering
$cp1Ord :: Eq SPSignSym
Ord, Typeable, Typeable SPSignSym
Constr
DataType
Typeable SPSignSym =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPSignSym -> c SPSignSym)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPSignSym)
-> (SPSignSym -> Constr)
-> (SPSignSym -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPSignSym))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSignSym))
-> ((forall b. Data b => b -> b) -> SPSignSym -> SPSignSym)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSignSym -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSignSym -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPSignSym -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPSignSym -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym)
-> Data SPSignSym
SPSignSym -> Constr
SPSignSym -> DataType
(forall b. Data b => b -> b) -> SPSignSym -> SPSignSym
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSignSym -> c SPSignSym
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSignSym
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPSignSym -> u
forall u. (forall d. Data d => d -> u) -> SPSignSym -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSignSym -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSignSym -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSignSym
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSignSym -> c SPSignSym
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSignSym)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSignSym)
$cSPSimpleSignSym :: Constr
$cSPSignSym :: Constr
$tSPSignSym :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
gmapMp :: (forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
gmapM :: (forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSignSym -> m SPSignSym
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPSignSym -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPSignSym -> u
gmapQ :: (forall d. Data d => d -> u) -> SPSignSym -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPSignSym -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSignSym -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSignSym -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSignSym -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSignSym -> r
gmapT :: (forall b. Data b => b -> b) -> SPSignSym -> SPSignSym
$cgmapT :: (forall b. Data b => b -> b) -> SPSignSym -> SPSignSym
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSignSym)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSignSym)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPSignSym)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSignSym)
dataTypeOf :: SPSignSym -> DataType
$cdataTypeOf :: SPSignSym -> DataType
toConstr :: SPSignSym -> Constr
$ctoConstr :: SPSignSym -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSignSym
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSignSym
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSignSym -> c SPSignSym
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSignSym -> c SPSignSym
$cp1Data :: Typeable SPSignSym
Data)

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

-- *** Declarations

{- |
  SPASS Declarations allow the introduction of sorts.
-}
data SPDeclaration =
        SPSubsortDecl { SPDeclaration -> SPIdentifier
sortSymA :: SPIdentifier,
                        SPDeclaration -> SPIdentifier
sortSymB :: SPIdentifier }
      | SPTermDecl { SPDeclaration -> [SPTerm]
termDeclTermList :: [SPTerm],
                     SPDeclaration -> SPTerm
termDeclTerm :: SPTerm }
      | SPSimpleTermDecl SPTerm
      | SPPredDecl { SPDeclaration -> SPIdentifier
predSym :: SPIdentifier,
                     SPDeclaration -> [SPIdentifier]
sortSyms :: [SPIdentifier] }
      | SPGenDecl { SPDeclaration -> SPIdentifier
sortSym :: SPIdentifier,
                    SPDeclaration -> Bool
freelyGenerated :: Bool,
                    SPDeclaration -> [SPIdentifier]
funcList :: [SPIdentifier]}
      deriving (Int -> SPDeclaration -> ShowS
[SPDeclaration] -> ShowS
SPDeclaration -> String
(Int -> SPDeclaration -> ShowS)
-> (SPDeclaration -> String)
-> ([SPDeclaration] -> ShowS)
-> Show SPDeclaration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPDeclaration] -> ShowS
$cshowList :: [SPDeclaration] -> ShowS
show :: SPDeclaration -> String
$cshow :: SPDeclaration -> String
showsPrec :: Int -> SPDeclaration -> ShowS
$cshowsPrec :: Int -> SPDeclaration -> ShowS
Show, SPDeclaration -> SPDeclaration -> Bool
(SPDeclaration -> SPDeclaration -> Bool)
-> (SPDeclaration -> SPDeclaration -> Bool) -> Eq SPDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPDeclaration -> SPDeclaration -> Bool
$c/= :: SPDeclaration -> SPDeclaration -> Bool
== :: SPDeclaration -> SPDeclaration -> Bool
$c== :: SPDeclaration -> SPDeclaration -> Bool
Eq, Eq SPDeclaration
Eq SPDeclaration =>
(SPDeclaration -> SPDeclaration -> Ordering)
-> (SPDeclaration -> SPDeclaration -> Bool)
-> (SPDeclaration -> SPDeclaration -> Bool)
-> (SPDeclaration -> SPDeclaration -> Bool)
-> (SPDeclaration -> SPDeclaration -> Bool)
-> (SPDeclaration -> SPDeclaration -> SPDeclaration)
-> (SPDeclaration -> SPDeclaration -> SPDeclaration)
-> Ord SPDeclaration
SPDeclaration -> SPDeclaration -> Bool
SPDeclaration -> SPDeclaration -> Ordering
SPDeclaration -> SPDeclaration -> SPDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPDeclaration -> SPDeclaration -> SPDeclaration
$cmin :: SPDeclaration -> SPDeclaration -> SPDeclaration
max :: SPDeclaration -> SPDeclaration -> SPDeclaration
$cmax :: SPDeclaration -> SPDeclaration -> SPDeclaration
>= :: SPDeclaration -> SPDeclaration -> Bool
$c>= :: SPDeclaration -> SPDeclaration -> Bool
> :: SPDeclaration -> SPDeclaration -> Bool
$c> :: SPDeclaration -> SPDeclaration -> Bool
<= :: SPDeclaration -> SPDeclaration -> Bool
$c<= :: SPDeclaration -> SPDeclaration -> Bool
< :: SPDeclaration -> SPDeclaration -> Bool
$c< :: SPDeclaration -> SPDeclaration -> Bool
compare :: SPDeclaration -> SPDeclaration -> Ordering
$ccompare :: SPDeclaration -> SPDeclaration -> Ordering
$cp1Ord :: Eq SPDeclaration
Ord, Typeable, Typeable SPDeclaration
Constr
DataType
Typeable SPDeclaration =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPDeclaration -> c SPDeclaration)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPDeclaration)
-> (SPDeclaration -> Constr)
-> (SPDeclaration -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPDeclaration))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPDeclaration))
-> ((forall b. Data b => b -> b) -> SPDeclaration -> SPDeclaration)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPDeclaration -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPDeclaration -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration)
-> Data SPDeclaration
SPDeclaration -> Constr
SPDeclaration -> DataType
(forall b. Data b => b -> b) -> SPDeclaration -> SPDeclaration
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDeclaration -> c SPDeclaration
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDeclaration
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPDeclaration -> u
forall u. (forall d. Data d => d -> u) -> SPDeclaration -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDeclaration
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDeclaration -> c SPDeclaration
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPDeclaration)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPDeclaration)
$cSPGenDecl :: Constr
$cSPPredDecl :: Constr
$cSPSimpleTermDecl :: Constr
$cSPTermDecl :: Constr
$cSPSubsortDecl :: Constr
$tSPDeclaration :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
gmapMp :: (forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
gmapM :: (forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPDeclaration -> m SPDeclaration
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPDeclaration -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPDeclaration -> u
gmapQ :: (forall d. Data d => d -> u) -> SPDeclaration -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPDeclaration -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPDeclaration -> r
gmapT :: (forall b. Data b => b -> b) -> SPDeclaration -> SPDeclaration
$cgmapT :: (forall b. Data b => b -> b) -> SPDeclaration -> SPDeclaration
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPDeclaration)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPDeclaration)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPDeclaration)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPDeclaration)
dataTypeOf :: SPDeclaration -> DataType
$cdataTypeOf :: SPDeclaration -> DataType
toConstr :: SPDeclaration -> Constr
$ctoConstr :: SPDeclaration -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDeclaration
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDeclaration
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDeclaration -> c SPDeclaration
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDeclaration -> c SPDeclaration
$cp1Data :: Typeable SPDeclaration
Data)

-- *** Formula List

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

-- | test the origin type of the formula list
isAxiomFormula :: SPFormulaList -> Bool
isAxiomFormula :: SPFormulaList -> Bool
isAxiomFormula fl :: SPFormulaList
fl =
    case SPFormulaList -> SPOriginType
originType SPFormulaList
fl of
      SPOriginAxioms -> Bool
True
      _ -> Bool
False

-- *** Clause List

-- | SPASS Clause List
data SPClauseList =
        SPClauseList { SPClauseList -> SPOriginType
coriginType :: SPOriginType,
                        SPClauseList -> SPClauseType
clauseType :: SPClauseType,
                        SPClauseList -> [SPClause]
clauses :: [SPClause] }
      deriving (Int -> SPClauseList -> ShowS
[SPClauseList] -> ShowS
SPClauseList -> String
(Int -> SPClauseList -> ShowS)
-> (SPClauseList -> String)
-> ([SPClauseList] -> ShowS)
-> Show SPClauseList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPClauseList] -> ShowS
$cshowList :: [SPClauseList] -> ShowS
show :: SPClauseList -> String
$cshow :: SPClauseList -> String
showsPrec :: Int -> SPClauseList -> ShowS
$cshowsPrec :: Int -> SPClauseList -> ShowS
Show, SPClauseList -> SPClauseList -> Bool
(SPClauseList -> SPClauseList -> Bool)
-> (SPClauseList -> SPClauseList -> Bool) -> Eq SPClauseList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPClauseList -> SPClauseList -> Bool
$c/= :: SPClauseList -> SPClauseList -> Bool
== :: SPClauseList -> SPClauseList -> Bool
$c== :: SPClauseList -> SPClauseList -> Bool
Eq, Eq SPClauseList
Eq SPClauseList =>
(SPClauseList -> SPClauseList -> Ordering)
-> (SPClauseList -> SPClauseList -> Bool)
-> (SPClauseList -> SPClauseList -> Bool)
-> (SPClauseList -> SPClauseList -> Bool)
-> (SPClauseList -> SPClauseList -> Bool)
-> (SPClauseList -> SPClauseList -> SPClauseList)
-> (SPClauseList -> SPClauseList -> SPClauseList)
-> Ord SPClauseList
SPClauseList -> SPClauseList -> Bool
SPClauseList -> SPClauseList -> Ordering
SPClauseList -> SPClauseList -> SPClauseList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPClauseList -> SPClauseList -> SPClauseList
$cmin :: SPClauseList -> SPClauseList -> SPClauseList
max :: SPClauseList -> SPClauseList -> SPClauseList
$cmax :: SPClauseList -> SPClauseList -> SPClauseList
>= :: SPClauseList -> SPClauseList -> Bool
$c>= :: SPClauseList -> SPClauseList -> Bool
> :: SPClauseList -> SPClauseList -> Bool
$c> :: SPClauseList -> SPClauseList -> Bool
<= :: SPClauseList -> SPClauseList -> Bool
$c<= :: SPClauseList -> SPClauseList -> Bool
< :: SPClauseList -> SPClauseList -> Bool
$c< :: SPClauseList -> SPClauseList -> Bool
compare :: SPClauseList -> SPClauseList -> Ordering
$ccompare :: SPClauseList -> SPClauseList -> Ordering
$cp1Ord :: Eq SPClauseList
Ord, Typeable, Typeable SPClauseList
Constr
DataType
Typeable SPClauseList =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPClauseList -> c SPClauseList)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPClauseList)
-> (SPClauseList -> Constr)
-> (SPClauseList -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPClauseList))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPClauseList))
-> ((forall b. Data b => b -> b) -> SPClauseList -> SPClauseList)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPClauseList -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPClauseList -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPClauseList -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPClauseList -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList)
-> Data SPClauseList
SPClauseList -> Constr
SPClauseList -> DataType
(forall b. Data b => b -> b) -> SPClauseList -> SPClauseList
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseList -> c SPClauseList
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseList
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPClauseList -> u
forall u. (forall d. Data d => d -> u) -> SPClauseList -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseList -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseList -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseList
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseList -> c SPClauseList
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPClauseList)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPClauseList)
$cSPClauseList :: Constr
$tSPClauseList :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
gmapMp :: (forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
gmapM :: (forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPClauseList -> m SPClauseList
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPClauseList -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPClauseList -> u
gmapQ :: (forall d. Data d => d -> u) -> SPClauseList -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPClauseList -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseList -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseList -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseList -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseList -> r
gmapT :: (forall b. Data b => b -> b) -> SPClauseList -> SPClauseList
$cgmapT :: (forall b. Data b => b -> b) -> SPClauseList -> SPClauseList
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPClauseList)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPClauseList)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPClauseList)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPClauseList)
dataTypeOf :: SPClauseList -> DataType
$cdataTypeOf :: SPClauseList -> DataType
toConstr :: SPClauseList -> Constr
$ctoConstr :: SPClauseList -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseList
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseList
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseList -> c SPClauseList
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseList -> c SPClauseList
$cp1Data :: Typeable SPClauseList
Data)


{- |
  There are axiom formulae and conjecture formulae.
-}
data SPOriginType =
        SPOriginAxioms
      | SPOriginConjectures
      deriving (Int -> SPOriginType -> ShowS
[SPOriginType] -> ShowS
SPOriginType -> String
(Int -> SPOriginType -> ShowS)
-> (SPOriginType -> String)
-> ([SPOriginType] -> ShowS)
-> Show SPOriginType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPOriginType] -> ShowS
$cshowList :: [SPOriginType] -> ShowS
show :: SPOriginType -> String
$cshow :: SPOriginType -> String
showsPrec :: Int -> SPOriginType -> ShowS
$cshowsPrec :: Int -> SPOriginType -> ShowS
Show, SPOriginType -> SPOriginType -> Bool
(SPOriginType -> SPOriginType -> Bool)
-> (SPOriginType -> SPOriginType -> Bool) -> Eq SPOriginType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPOriginType -> SPOriginType -> Bool
$c/= :: SPOriginType -> SPOriginType -> Bool
== :: SPOriginType -> SPOriginType -> Bool
$c== :: SPOriginType -> SPOriginType -> Bool
Eq, Eq SPOriginType
Eq SPOriginType =>
(SPOriginType -> SPOriginType -> Ordering)
-> (SPOriginType -> SPOriginType -> Bool)
-> (SPOriginType -> SPOriginType -> Bool)
-> (SPOriginType -> SPOriginType -> Bool)
-> (SPOriginType -> SPOriginType -> Bool)
-> (SPOriginType -> SPOriginType -> SPOriginType)
-> (SPOriginType -> SPOriginType -> SPOriginType)
-> Ord SPOriginType
SPOriginType -> SPOriginType -> Bool
SPOriginType -> SPOriginType -> Ordering
SPOriginType -> SPOriginType -> SPOriginType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPOriginType -> SPOriginType -> SPOriginType
$cmin :: SPOriginType -> SPOriginType -> SPOriginType
max :: SPOriginType -> SPOriginType -> SPOriginType
$cmax :: SPOriginType -> SPOriginType -> SPOriginType
>= :: SPOriginType -> SPOriginType -> Bool
$c>= :: SPOriginType -> SPOriginType -> Bool
> :: SPOriginType -> SPOriginType -> Bool
$c> :: SPOriginType -> SPOriginType -> Bool
<= :: SPOriginType -> SPOriginType -> Bool
$c<= :: SPOriginType -> SPOriginType -> Bool
< :: SPOriginType -> SPOriginType -> Bool
$c< :: SPOriginType -> SPOriginType -> Bool
compare :: SPOriginType -> SPOriginType -> Ordering
$ccompare :: SPOriginType -> SPOriginType -> Ordering
$cp1Ord :: Eq SPOriginType
Ord, Typeable, Typeable SPOriginType
Constr
DataType
Typeable SPOriginType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPOriginType -> c SPOriginType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPOriginType)
-> (SPOriginType -> Constr)
-> (SPOriginType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPOriginType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPOriginType))
-> ((forall b. Data b => b -> b) -> SPOriginType -> SPOriginType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPOriginType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPOriginType -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPOriginType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPOriginType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType)
-> Data SPOriginType
SPOriginType -> Constr
SPOriginType -> DataType
(forall b. Data b => b -> b) -> SPOriginType -> SPOriginType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPOriginType -> c SPOriginType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPOriginType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPOriginType -> u
forall u. (forall d. Data d => d -> u) -> SPOriginType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPOriginType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPOriginType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPOriginType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPOriginType -> c SPOriginType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPOriginType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPOriginType)
$cSPOriginConjectures :: Constr
$cSPOriginAxioms :: Constr
$tSPOriginType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
gmapMp :: (forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
gmapM :: (forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPOriginType -> m SPOriginType
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPOriginType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPOriginType -> u
gmapQ :: (forall d. Data d => d -> u) -> SPOriginType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPOriginType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPOriginType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPOriginType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPOriginType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPOriginType -> r
gmapT :: (forall b. Data b => b -> b) -> SPOriginType -> SPOriginType
$cgmapT :: (forall b. Data b => b -> b) -> SPOriginType -> SPOriginType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPOriginType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPOriginType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPOriginType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPOriginType)
dataTypeOf :: SPOriginType -> DataType
$cdataTypeOf :: SPOriginType -> DataType
toConstr :: SPOriginType -> Constr
$ctoConstr :: SPOriginType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPOriginType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPOriginType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPOriginType -> c SPOriginType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPOriginType -> c SPOriginType
$cp1Data :: Typeable SPOriginType
Data)

{- |
   Formulae can be in cnf or dnf
-}
data SPClauseType = SPCNF
                  | SPDNF
    deriving (Int -> SPClauseType -> ShowS
[SPClauseType] -> ShowS
SPClauseType -> String
(Int -> SPClauseType -> ShowS)
-> (SPClauseType -> String)
-> ([SPClauseType] -> ShowS)
-> Show SPClauseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPClauseType] -> ShowS
$cshowList :: [SPClauseType] -> ShowS
show :: SPClauseType -> String
$cshow :: SPClauseType -> String
showsPrec :: Int -> SPClauseType -> ShowS
$cshowsPrec :: Int -> SPClauseType -> ShowS
Show, SPClauseType -> SPClauseType -> Bool
(SPClauseType -> SPClauseType -> Bool)
-> (SPClauseType -> SPClauseType -> Bool) -> Eq SPClauseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPClauseType -> SPClauseType -> Bool
$c/= :: SPClauseType -> SPClauseType -> Bool
== :: SPClauseType -> SPClauseType -> Bool
$c== :: SPClauseType -> SPClauseType -> Bool
Eq, Eq SPClauseType
Eq SPClauseType =>
(SPClauseType -> SPClauseType -> Ordering)
-> (SPClauseType -> SPClauseType -> Bool)
-> (SPClauseType -> SPClauseType -> Bool)
-> (SPClauseType -> SPClauseType -> Bool)
-> (SPClauseType -> SPClauseType -> Bool)
-> (SPClauseType -> SPClauseType -> SPClauseType)
-> (SPClauseType -> SPClauseType -> SPClauseType)
-> Ord SPClauseType
SPClauseType -> SPClauseType -> Bool
SPClauseType -> SPClauseType -> Ordering
SPClauseType -> SPClauseType -> SPClauseType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPClauseType -> SPClauseType -> SPClauseType
$cmin :: SPClauseType -> SPClauseType -> SPClauseType
max :: SPClauseType -> SPClauseType -> SPClauseType
$cmax :: SPClauseType -> SPClauseType -> SPClauseType
>= :: SPClauseType -> SPClauseType -> Bool
$c>= :: SPClauseType -> SPClauseType -> Bool
> :: SPClauseType -> SPClauseType -> Bool
$c> :: SPClauseType -> SPClauseType -> Bool
<= :: SPClauseType -> SPClauseType -> Bool
$c<= :: SPClauseType -> SPClauseType -> Bool
< :: SPClauseType -> SPClauseType -> Bool
$c< :: SPClauseType -> SPClauseType -> Bool
compare :: SPClauseType -> SPClauseType -> Ordering
$ccompare :: SPClauseType -> SPClauseType -> Ordering
$cp1Ord :: Eq SPClauseType
Ord, Typeable, Typeable SPClauseType
Constr
DataType
Typeable SPClauseType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPClauseType -> c SPClauseType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPClauseType)
-> (SPClauseType -> Constr)
-> (SPClauseType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPClauseType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPClauseType))
-> ((forall b. Data b => b -> b) -> SPClauseType -> SPClauseType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPClauseType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPClauseType -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPClauseType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPClauseType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType)
-> Data SPClauseType
SPClauseType -> Constr
SPClauseType -> DataType
(forall b. Data b => b -> b) -> SPClauseType -> SPClauseType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseType -> c SPClauseType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPClauseType -> u
forall u. (forall d. Data d => d -> u) -> SPClauseType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseType -> c SPClauseType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPClauseType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPClauseType)
$cSPDNF :: Constr
$cSPCNF :: Constr
$tSPClauseType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
gmapMp :: (forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
gmapM :: (forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPClauseType -> m SPClauseType
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPClauseType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPClauseType -> u
gmapQ :: (forall d. Data d => d -> u) -> SPClauseType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPClauseType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPClauseType -> r
gmapT :: (forall b. Data b => b -> b) -> SPClauseType -> SPClauseType
$cgmapT :: (forall b. Data b => b -> b) -> SPClauseType -> SPClauseType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPClauseType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPClauseType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPClauseType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPClauseType)
dataTypeOf :: SPClauseType -> DataType
$cdataTypeOf :: SPClauseType -> DataType
toConstr :: SPClauseType -> Constr
$ctoConstr :: SPClauseType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPClauseType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseType -> c SPClauseType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPClauseType -> c SPClauseType
$cp1Data :: Typeable SPClauseType
Data)

type SPClause = Named NSPClause

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

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

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

{- |
  A SPASS Term.
-}
data SPTerm =
        SPQuantTerm { SPTerm -> SPQuantSym
quantSym :: SPQuantSym,
                      SPTerm -> [SPTerm]
variableList :: [SPTerm],
                      SPTerm -> SPTerm
qFormula :: SPTerm }
      | SPComplexTerm { SPTerm -> SPSymbol
symbol :: SPSymbol,
                        SPTerm -> [SPTerm]
arguments :: [SPTerm]}
      deriving (Int -> SPTerm -> ShowS
[SPTerm] -> ShowS
SPTerm -> String
(Int -> SPTerm -> ShowS)
-> (SPTerm -> String) -> ([SPTerm] -> ShowS) -> Show SPTerm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPTerm] -> ShowS
$cshowList :: [SPTerm] -> ShowS
show :: SPTerm -> String
$cshow :: SPTerm -> String
showsPrec :: Int -> SPTerm -> ShowS
$cshowsPrec :: Int -> SPTerm -> ShowS
Show, SPTerm -> SPTerm -> Bool
(SPTerm -> SPTerm -> Bool)
-> (SPTerm -> SPTerm -> Bool) -> Eq SPTerm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPTerm -> SPTerm -> Bool
$c/= :: SPTerm -> SPTerm -> Bool
== :: SPTerm -> SPTerm -> Bool
$c== :: SPTerm -> SPTerm -> Bool
Eq, Eq SPTerm
Eq SPTerm =>
(SPTerm -> SPTerm -> Ordering)
-> (SPTerm -> SPTerm -> Bool)
-> (SPTerm -> SPTerm -> Bool)
-> (SPTerm -> SPTerm -> Bool)
-> (SPTerm -> SPTerm -> Bool)
-> (SPTerm -> SPTerm -> SPTerm)
-> (SPTerm -> SPTerm -> SPTerm)
-> Ord SPTerm
SPTerm -> SPTerm -> Bool
SPTerm -> SPTerm -> Ordering
SPTerm -> SPTerm -> SPTerm
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPTerm -> SPTerm -> SPTerm
$cmin :: SPTerm -> SPTerm -> SPTerm
max :: SPTerm -> SPTerm -> SPTerm
$cmax :: SPTerm -> SPTerm -> SPTerm
>= :: SPTerm -> SPTerm -> Bool
$c>= :: SPTerm -> SPTerm -> Bool
> :: SPTerm -> SPTerm -> Bool
$c> :: SPTerm -> SPTerm -> Bool
<= :: SPTerm -> SPTerm -> Bool
$c<= :: SPTerm -> SPTerm -> Bool
< :: SPTerm -> SPTerm -> Bool
$c< :: SPTerm -> SPTerm -> Bool
compare :: SPTerm -> SPTerm -> Ordering
$ccompare :: SPTerm -> SPTerm -> Ordering
$cp1Ord :: Eq SPTerm
Ord, Typeable, Typeable SPTerm
Constr
DataType
Typeable SPTerm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPTerm -> c SPTerm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPTerm)
-> (SPTerm -> Constr)
-> (SPTerm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPTerm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPTerm))
-> ((forall b. Data b => b -> b) -> SPTerm -> SPTerm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPTerm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPTerm -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPTerm -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SPTerm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPTerm -> m SPTerm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPTerm -> m SPTerm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPTerm -> m SPTerm)
-> Data SPTerm
SPTerm -> Constr
SPTerm -> DataType
(forall b. Data b => b -> b) -> SPTerm -> SPTerm
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPTerm -> c SPTerm
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPTerm
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPTerm -> u
forall u. (forall d. Data d => d -> u) -> SPTerm -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SPTerm -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SPTerm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPTerm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPTerm -> c SPTerm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPTerm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPTerm)
$cSPComplexTerm :: Constr
$cSPQuantTerm :: Constr
$tSPTerm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
gmapMp :: (forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
gmapM :: (forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPTerm -> m SPTerm
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPTerm -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPTerm -> u
gmapQ :: (forall d. Data d => d -> u) -> SPTerm -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPTerm -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SPTerm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SPTerm -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SPTerm -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SPTerm -> r
gmapT :: (forall b. Data b => b -> b) -> SPTerm -> SPTerm
$cgmapT :: (forall b. Data b => b -> b) -> SPTerm -> SPTerm
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPTerm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPTerm)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPTerm)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPTerm)
dataTypeOf :: SPTerm -> DataType
$cdataTypeOf :: SPTerm -> DataType
toConstr :: SPTerm -> Constr
$ctoConstr :: SPTerm -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPTerm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPTerm
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPTerm -> c SPTerm
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPTerm -> c SPTerm
$cp1Data :: Typeable SPTerm
Data)

instance GetRange SPTerm

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

data FormKind = FofKind | CnfKind | FotKind deriving (Typeable, Typeable FormKind
Constr
DataType
Typeable FormKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FormKind -> c FormKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FormKind)
-> (FormKind -> Constr)
-> (FormKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FormKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FormKind))
-> ((forall b. Data b => b -> b) -> FormKind -> FormKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FormKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FormKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> FormKind -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FormKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FormKind -> m FormKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormKind -> m FormKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FormKind -> m FormKind)
-> Data FormKind
FormKind -> Constr
FormKind -> DataType
(forall b. Data b => b -> b) -> FormKind -> FormKind
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormKind -> c FormKind
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormKind
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FormKind -> u
forall u. (forall d. Data d => d -> u) -> FormKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormKind -> m FormKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormKind -> m FormKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormKind -> c FormKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FormKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FormKind)
$cFotKind :: Constr
$cCnfKind :: Constr
$cFofKind :: Constr
$tFormKind :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FormKind -> m FormKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormKind -> m FormKind
gmapMp :: (forall d. Data d => d -> m d) -> FormKind -> m FormKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormKind -> m FormKind
gmapM :: (forall d. Data d => d -> m d) -> FormKind -> m FormKind
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormKind -> m FormKind
gmapQi :: Int -> (forall d. Data d => d -> u) -> FormKind -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FormKind -> u
gmapQ :: (forall d. Data d => d -> u) -> FormKind -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FormKind -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormKind -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormKind -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormKind -> r
gmapT :: (forall b. Data b => b -> b) -> FormKind -> FormKind
$cgmapT :: (forall b. Data b => b -> b) -> FormKind -> FormKind
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FormKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FormKind)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FormKind)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FormKind)
dataTypeOf :: FormKind -> DataType
$cdataTypeOf :: FormKind -> DataType
toConstr :: FormKind -> Constr
$ctoConstr :: FormKind -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormKind
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormKind -> c FormKind
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormKind -> c FormKind
$cp1Data :: Typeable FormKind
Data)

instance Show FormKind where
    show :: FormKind -> String
show k :: FormKind
k = case FormKind
k of
        FofKind -> "fof"
        CnfKind -> "cnf"
        FotKind -> "fot"

data Role =
    Axiom
  | Hypothesis
  | Definition
  | Assumption
  | Lemma
  | Theorem
  | Conjecture
  | Negated_conjecture
  | Plain
  | Fi_domain
  | Fi_functors
  | Fi_predicates
  | Type
  | Unknown
    deriving (Int -> Role -> ShowS
[Role] -> ShowS
Role -> String
(Int -> Role -> ShowS)
-> (Role -> String) -> ([Role] -> ShowS) -> Show Role
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Role] -> ShowS
$cshowList :: [Role] -> ShowS
show :: Role -> String
$cshow :: Role -> String
showsPrec :: Int -> Role -> ShowS
$cshowsPrec :: Int -> Role -> ShowS
Show, Typeable, Typeable Role
Constr
DataType
Typeable Role =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Role -> c Role)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Role)
-> (Role -> Constr)
-> (Role -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Role))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role))
-> ((forall b. Data b => b -> b) -> Role -> Role)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r)
-> (forall u. (forall d. Data d => d -> u) -> Role -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Role -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Role -> m Role)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role -> m Role)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Role -> m Role)
-> Data Role
Role -> Constr
Role -> DataType
(forall b. Data b => b -> b) -> Role -> Role
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c 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) -> Role -> u
forall u. (forall d. Data d => d -> u) -> Role -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Role -> m Role
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Role)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
$cUnknown :: Constr
$cType :: Constr
$cFi_predicates :: Constr
$cFi_functors :: Constr
$cFi_domain :: Constr
$cPlain :: Constr
$cNegated_conjecture :: Constr
$cConjecture :: Constr
$cTheorem :: Constr
$cLemma :: Constr
$cAssumption :: Constr
$cDefinition :: Constr
$cHypothesis :: Constr
$cAxiom :: Constr
$tRole :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Role -> m Role
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role
gmapMp :: (forall d. Data d => d -> m d) -> Role -> m Role
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Role -> m Role
gmapM :: (forall d. Data d => d -> m d) -> Role -> m Role
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Role -> m Role
gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Role -> u
gmapQ :: (forall d. Data d => d -> u) -> Role -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Role -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r
gmapT :: (forall b. Data b => b -> b) -> Role -> Role
$cgmapT :: (forall b. Data b => b -> b) -> Role -> Role
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Role)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Role)
dataTypeOf :: Role -> DataType
$cdataTypeOf :: Role -> DataType
toConstr :: Role -> Constr
$ctoConstr :: Role -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Role
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Role -> c Role
$cp1Data :: Typeable Role
Data)

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

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

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

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

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

data GenData =
    GenData AWord [GenTerm]
  | OtherGenData String  -- variable, number, distinct_object
  | GenFormData FormData
    deriving (Int -> GenData -> ShowS
[GenData] -> ShowS
GenData -> String
(Int -> GenData -> ShowS)
-> (GenData -> String) -> ([GenData] -> ShowS) -> Show GenData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GenData] -> ShowS
$cshowList :: [GenData] -> ShowS
show :: GenData -> String
$cshow :: GenData -> String
showsPrec :: Int -> GenData -> ShowS
$cshowsPrec :: Int -> GenData -> ShowS
Show, Typeable, Typeable GenData
Constr
DataType
Typeable GenData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GenData -> c GenData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GenData)
-> (GenData -> Constr)
-> (GenData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GenData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GenData))
-> ((forall b. Data b => b -> b) -> GenData -> GenData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenData -> r)
-> (forall u. (forall d. Data d => d -> u) -> GenData -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> GenData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GenData -> m GenData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GenData -> m GenData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GenData -> m GenData)
-> Data GenData
GenData -> Constr
GenData -> DataType
(forall b. Data b => b -> b) -> GenData -> GenData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenData -> c GenData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GenData
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GenData -> u
forall u. (forall d. Data d => d -> u) -> GenData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GenData -> m GenData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GenData -> m GenData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GenData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenData -> c GenData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GenData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GenData)
$cGenFormData :: Constr
$cOtherGenData :: Constr
$cGenData :: Constr
$tGenData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> GenData -> m GenData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GenData -> m GenData
gmapMp :: (forall d. Data d => d -> m d) -> GenData -> m GenData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GenData -> m GenData
gmapM :: (forall d. Data d => d -> m d) -> GenData -> m GenData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GenData -> m GenData
gmapQi :: Int -> (forall d. Data d => d -> u) -> GenData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GenData -> u
gmapQ :: (forall d. Data d => d -> u) -> GenData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GenData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenData -> r
gmapT :: (forall b. Data b => b -> b) -> GenData -> GenData
$cgmapT :: (forall b. Data b => b -> b) -> GenData -> GenData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GenData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GenData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c GenData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GenData)
dataTypeOf :: GenData -> DataType
$cdataTypeOf :: GenData -> DataType
toConstr :: GenData -> Constr
$ctoConstr :: GenData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GenData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GenData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenData -> c GenData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenData -> c GenData
$cp1Data :: Typeable GenData
Data)

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

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

data TPTP =
    FormAnno FormKind Name Role SPTerm (Maybe Annos)
  | Include FileName [Name]
  | CommentLine String  -- collect top-level comment lines
  | EmptyLine -- and blank lines
    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, Typeable, 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)
$cEmptyLine :: Constr
$cCommentLine :: Constr
$cInclude :: Constr
$cFormAnno :: 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)

instance GetRange TPTP

-- | Literals for SPASS CNF and DNF (the boolean indicates a negated literal).
data SPLiteral = SPLiteral Bool SPSymbol
  deriving (Int -> SPLiteral -> ShowS
[SPLiteral] -> ShowS
SPLiteral -> String
(Int -> SPLiteral -> ShowS)
-> (SPLiteral -> String)
-> ([SPLiteral] -> ShowS)
-> Show SPLiteral
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPLiteral] -> ShowS
$cshowList :: [SPLiteral] -> ShowS
show :: SPLiteral -> String
$cshow :: SPLiteral -> String
showsPrec :: Int -> SPLiteral -> ShowS
$cshowsPrec :: Int -> SPLiteral -> ShowS
Show, SPLiteral -> SPLiteral -> Bool
(SPLiteral -> SPLiteral -> Bool)
-> (SPLiteral -> SPLiteral -> Bool) -> Eq SPLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPLiteral -> SPLiteral -> Bool
$c/= :: SPLiteral -> SPLiteral -> Bool
== :: SPLiteral -> SPLiteral -> Bool
$c== :: SPLiteral -> SPLiteral -> Bool
Eq, Eq SPLiteral
Eq SPLiteral =>
(SPLiteral -> SPLiteral -> Ordering)
-> (SPLiteral -> SPLiteral -> Bool)
-> (SPLiteral -> SPLiteral -> Bool)
-> (SPLiteral -> SPLiteral -> Bool)
-> (SPLiteral -> SPLiteral -> Bool)
-> (SPLiteral -> SPLiteral -> SPLiteral)
-> (SPLiteral -> SPLiteral -> SPLiteral)
-> Ord SPLiteral
SPLiteral -> SPLiteral -> Bool
SPLiteral -> SPLiteral -> Ordering
SPLiteral -> SPLiteral -> SPLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPLiteral -> SPLiteral -> SPLiteral
$cmin :: SPLiteral -> SPLiteral -> SPLiteral
max :: SPLiteral -> SPLiteral -> SPLiteral
$cmax :: SPLiteral -> SPLiteral -> SPLiteral
>= :: SPLiteral -> SPLiteral -> Bool
$c>= :: SPLiteral -> SPLiteral -> Bool
> :: SPLiteral -> SPLiteral -> Bool
$c> :: SPLiteral -> SPLiteral -> Bool
<= :: SPLiteral -> SPLiteral -> Bool
$c<= :: SPLiteral -> SPLiteral -> Bool
< :: SPLiteral -> SPLiteral -> Bool
$c< :: SPLiteral -> SPLiteral -> Bool
compare :: SPLiteral -> SPLiteral -> Ordering
$ccompare :: SPLiteral -> SPLiteral -> Ordering
$cp1Ord :: Eq SPLiteral
Ord, Typeable, Typeable SPLiteral
Constr
DataType
Typeable SPLiteral =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPLiteral -> c SPLiteral)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPLiteral)
-> (SPLiteral -> Constr)
-> (SPLiteral -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPLiteral))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPLiteral))
-> ((forall b. Data b => b -> b) -> SPLiteral -> SPLiteral)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPLiteral -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPLiteral -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPLiteral -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPLiteral -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral)
-> Data SPLiteral
SPLiteral -> Constr
SPLiteral -> DataType
(forall b. Data b => b -> b) -> SPLiteral -> SPLiteral
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLiteral -> c SPLiteral
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLiteral
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPLiteral -> u
forall u. (forall d. Data d => d -> u) -> SPLiteral -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLiteral -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLiteral -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLiteral
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLiteral -> c SPLiteral
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPLiteral)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPLiteral)
$cSPLiteral :: Constr
$tSPLiteral :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
gmapMp :: (forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
gmapM :: (forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPLiteral -> m SPLiteral
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPLiteral -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPLiteral -> u
gmapQ :: (forall d. Data d => d -> u) -> SPLiteral -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPLiteral -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLiteral -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLiteral -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLiteral -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLiteral -> r
gmapT :: (forall b. Data b => b -> b) -> SPLiteral -> SPLiteral
$cgmapT :: (forall b. Data b => b -> b) -> SPLiteral -> SPLiteral
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPLiteral)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPLiteral)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPLiteral)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPLiteral)
dataTypeOf :: SPLiteral -> DataType
$cdataTypeOf :: SPLiteral -> DataType
toConstr :: SPLiteral -> Constr
$ctoConstr :: SPLiteral -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLiteral
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLiteral
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLiteral -> c SPLiteral
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLiteral -> c SPLiteral
$cp1Data :: Typeable SPLiteral
Data)

toLiteral :: (Fail.MonadFail m) => SPTerm -> m SPLiteral
toLiteral :: SPTerm -> m SPLiteral
toLiteral t :: SPTerm
t = case SPTerm
t of
      SPComplexTerm SPNot [SPComplexTerm arg :: SPSymbol
arg []] ->
          SPLiteral -> m SPLiteral
forall (m :: * -> *) a. Monad m => a -> m a
return (SPLiteral -> m SPLiteral) -> SPLiteral -> m SPLiteral
forall a b. (a -> b) -> a -> b
$ Bool -> SPSymbol -> SPLiteral
SPLiteral Bool
False SPSymbol
arg
      SPComplexTerm arg :: SPSymbol
arg [] -> SPLiteral -> m SPLiteral
forall (m :: * -> *) a. Monad m => a -> m a
return (SPLiteral -> m SPLiteral) -> SPLiteral -> m SPLiteral
forall a b. (a -> b) -> a -> b
$ Bool -> SPSymbol -> SPLiteral
SPLiteral Bool
True SPSymbol
arg
      _ -> String -> m SPLiteral
forall (m :: * -> *) a. MonadFail m => String -> m a
Fail.fail "expected literal"

{- |
  SPASS Quantifier Symbols.
-}
data SPQuantSym =
        SPForall
      | SPExists
      | SPCustomQuantSym SPIdentifier
      deriving (Int -> SPQuantSym -> ShowS
[SPQuantSym] -> ShowS
SPQuantSym -> String
(Int -> SPQuantSym -> ShowS)
-> (SPQuantSym -> String)
-> ([SPQuantSym] -> ShowS)
-> Show SPQuantSym
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPQuantSym] -> ShowS
$cshowList :: [SPQuantSym] -> ShowS
show :: SPQuantSym -> String
$cshow :: SPQuantSym -> String
showsPrec :: Int -> SPQuantSym -> ShowS
$cshowsPrec :: Int -> SPQuantSym -> ShowS
Show, SPQuantSym -> SPQuantSym -> Bool
(SPQuantSym -> SPQuantSym -> Bool)
-> (SPQuantSym -> SPQuantSym -> Bool) -> Eq SPQuantSym
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPQuantSym -> SPQuantSym -> Bool
$c/= :: SPQuantSym -> SPQuantSym -> Bool
== :: SPQuantSym -> SPQuantSym -> Bool
$c== :: SPQuantSym -> SPQuantSym -> Bool
Eq, Eq SPQuantSym
Eq SPQuantSym =>
(SPQuantSym -> SPQuantSym -> Ordering)
-> (SPQuantSym -> SPQuantSym -> Bool)
-> (SPQuantSym -> SPQuantSym -> Bool)
-> (SPQuantSym -> SPQuantSym -> Bool)
-> (SPQuantSym -> SPQuantSym -> Bool)
-> (SPQuantSym -> SPQuantSym -> SPQuantSym)
-> (SPQuantSym -> SPQuantSym -> SPQuantSym)
-> Ord SPQuantSym
SPQuantSym -> SPQuantSym -> Bool
SPQuantSym -> SPQuantSym -> Ordering
SPQuantSym -> SPQuantSym -> SPQuantSym
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPQuantSym -> SPQuantSym -> SPQuantSym
$cmin :: SPQuantSym -> SPQuantSym -> SPQuantSym
max :: SPQuantSym -> SPQuantSym -> SPQuantSym
$cmax :: SPQuantSym -> SPQuantSym -> SPQuantSym
>= :: SPQuantSym -> SPQuantSym -> Bool
$c>= :: SPQuantSym -> SPQuantSym -> Bool
> :: SPQuantSym -> SPQuantSym -> Bool
$c> :: SPQuantSym -> SPQuantSym -> Bool
<= :: SPQuantSym -> SPQuantSym -> Bool
$c<= :: SPQuantSym -> SPQuantSym -> Bool
< :: SPQuantSym -> SPQuantSym -> Bool
$c< :: SPQuantSym -> SPQuantSym -> Bool
compare :: SPQuantSym -> SPQuantSym -> Ordering
$ccompare :: SPQuantSym -> SPQuantSym -> Ordering
$cp1Ord :: Eq SPQuantSym
Ord, Typeable, Typeable SPQuantSym
Constr
DataType
Typeable SPQuantSym =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPQuantSym -> c SPQuantSym)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPQuantSym)
-> (SPQuantSym -> Constr)
-> (SPQuantSym -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPQuantSym))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPQuantSym))
-> ((forall b. Data b => b -> b) -> SPQuantSym -> SPQuantSym)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPQuantSym -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPQuantSym -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym)
-> Data SPQuantSym
SPQuantSym -> Constr
SPQuantSym -> DataType
(forall b. Data b => b -> b) -> SPQuantSym -> SPQuantSym
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPQuantSym -> c SPQuantSym
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPQuantSym
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPQuantSym -> u
forall u. (forall d. Data d => d -> u) -> SPQuantSym -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPQuantSym
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPQuantSym -> c SPQuantSym
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPQuantSym)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPQuantSym)
$cSPCustomQuantSym :: Constr
$cSPExists :: Constr
$cSPForall :: Constr
$tSPQuantSym :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
gmapMp :: (forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
gmapM :: (forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPQuantSym -> m SPQuantSym
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPQuantSym -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPQuantSym -> u
gmapQ :: (forall d. Data d => d -> u) -> SPQuantSym -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPQuantSym -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPQuantSym -> r
gmapT :: (forall b. Data b => b -> b) -> SPQuantSym -> SPQuantSym
$cgmapT :: (forall b. Data b => b -> b) -> SPQuantSym -> SPQuantSym
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPQuantSym)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPQuantSym)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPQuantSym)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPQuantSym)
dataTypeOf :: SPQuantSym -> DataType
$cdataTypeOf :: SPQuantSym -> DataType
toConstr :: SPQuantSym -> Constr
$ctoConstr :: SPQuantSym -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPQuantSym
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPQuantSym
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPQuantSym -> c SPQuantSym
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPQuantSym -> c SPQuantSym
$cp1Data :: Typeable SPQuantSym
Data)

{- |
  SPASS Symbols.
-}
data SPSymbol =
        SPEqual
      | SPTrue
      | SPFalse
      | SPOr
      | SPAnd
      | SPNot
      | SPImplies
      | SPImplied
      | SPEquiv
      | SPID
      | SPDiv
      | SPComp
      | SPSum
      | SPConv
      | SPCustomSymbol SPIdentifier
      deriving (Int -> SPSymbol -> ShowS
[SPSymbol] -> ShowS
SPSymbol -> String
(Int -> SPSymbol -> ShowS)
-> (SPSymbol -> String) -> ([SPSymbol] -> ShowS) -> Show SPSymbol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPSymbol] -> ShowS
$cshowList :: [SPSymbol] -> ShowS
show :: SPSymbol -> String
$cshow :: SPSymbol -> String
showsPrec :: Int -> SPSymbol -> ShowS
$cshowsPrec :: Int -> SPSymbol -> ShowS
Show, SPSymbol -> SPSymbol -> Bool
(SPSymbol -> SPSymbol -> Bool)
-> (SPSymbol -> SPSymbol -> Bool) -> Eq SPSymbol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPSymbol -> SPSymbol -> Bool
$c/= :: SPSymbol -> SPSymbol -> Bool
== :: SPSymbol -> SPSymbol -> Bool
$c== :: SPSymbol -> SPSymbol -> Bool
Eq, Eq SPSymbol
Eq SPSymbol =>
(SPSymbol -> SPSymbol -> Ordering)
-> (SPSymbol -> SPSymbol -> Bool)
-> (SPSymbol -> SPSymbol -> Bool)
-> (SPSymbol -> SPSymbol -> Bool)
-> (SPSymbol -> SPSymbol -> Bool)
-> (SPSymbol -> SPSymbol -> SPSymbol)
-> (SPSymbol -> SPSymbol -> SPSymbol)
-> Ord SPSymbol
SPSymbol -> SPSymbol -> Bool
SPSymbol -> SPSymbol -> Ordering
SPSymbol -> SPSymbol -> SPSymbol
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPSymbol -> SPSymbol -> SPSymbol
$cmin :: SPSymbol -> SPSymbol -> SPSymbol
max :: SPSymbol -> SPSymbol -> SPSymbol
$cmax :: SPSymbol -> SPSymbol -> SPSymbol
>= :: SPSymbol -> SPSymbol -> Bool
$c>= :: SPSymbol -> SPSymbol -> Bool
> :: SPSymbol -> SPSymbol -> Bool
$c> :: SPSymbol -> SPSymbol -> Bool
<= :: SPSymbol -> SPSymbol -> Bool
$c<= :: SPSymbol -> SPSymbol -> Bool
< :: SPSymbol -> SPSymbol -> Bool
$c< :: SPSymbol -> SPSymbol -> Bool
compare :: SPSymbol -> SPSymbol -> Ordering
$ccompare :: SPSymbol -> SPSymbol -> Ordering
$cp1Ord :: Eq SPSymbol
Ord, Typeable, Typeable SPSymbol
Constr
DataType
Typeable SPSymbol =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPSymbol -> c SPSymbol)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPSymbol)
-> (SPSymbol -> Constr)
-> (SPSymbol -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPSymbol))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSymbol))
-> ((forall b. Data b => b -> b) -> SPSymbol -> SPSymbol)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSymbol -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSymbol -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPSymbol -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SPSymbol -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol)
-> Data SPSymbol
SPSymbol -> Constr
SPSymbol -> DataType
(forall b. Data b => b -> b) -> SPSymbol -> SPSymbol
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbol -> c SPSymbol
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbol
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPSymbol -> u
forall u. (forall d. Data d => d -> u) -> SPSymbol -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbol -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbol -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbol
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbol -> c SPSymbol
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSymbol)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSymbol)
$cSPCustomSymbol :: Constr
$cSPConv :: Constr
$cSPSum :: Constr
$cSPComp :: Constr
$cSPDiv :: Constr
$cSPID :: Constr
$cSPEquiv :: Constr
$cSPImplied :: Constr
$cSPImplies :: Constr
$cSPNot :: Constr
$cSPAnd :: Constr
$cSPOr :: Constr
$cSPFalse :: Constr
$cSPTrue :: Constr
$cSPEqual :: Constr
$tSPSymbol :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
gmapMp :: (forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
gmapM :: (forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSymbol -> m SPSymbol
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPSymbol -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPSymbol -> u
gmapQ :: (forall d. Data d => d -> u) -> SPSymbol -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPSymbol -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbol -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbol -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbol -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSymbol -> r
gmapT :: (forall b. Data b => b -> b) -> SPSymbol -> SPSymbol
$cgmapT :: (forall b. Data b => b -> b) -> SPSymbol -> SPSymbol
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSymbol)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSymbol)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPSymbol)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSymbol)
dataTypeOf :: SPSymbol -> DataType
$cdataTypeOf :: SPSymbol -> DataType
toConstr :: SPSymbol -> Constr
$ctoConstr :: SPSymbol -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbol
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSymbol
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbol -> c SPSymbol
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSymbol -> c SPSymbol
$cp1Data :: Typeable SPSymbol
Data)

mkSPCustomSymbol :: String -> SPSymbol
mkSPCustomSymbol :: String -> SPSymbol
mkSPCustomSymbol = SPIdentifier -> SPSymbol
SPCustomSymbol (SPIdentifier -> SPSymbol)
-> (String -> SPIdentifier) -> String -> SPSymbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SPIdentifier
mkSimpleId

showSPSymbol :: SPSymbol -> String
showSPSymbol :: SPSymbol -> String
showSPSymbol s :: SPSymbol
s = case SPSymbol
s of
        SPCustomSymbol cst :: SPIdentifier
cst -> SPIdentifier -> String
tokStr SPIdentifier
cst
        _ -> (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Int -> ShowS
forall a. Int -> [a] -> [a]
drop 2 ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ SPSymbol -> String
forall a. Show a => a -> String
show SPSymbol
s

-- *** Proof List

-- | SPASS Proof List
data SPProofList =
        SPProofList {SPProofList -> Maybe SPIdentifier
proofType :: Maybe SPProofType,
                     SPProofList -> SPAssocList
plAssocList :: SPAssocList,
                     SPProofList -> [SPProofStep]
step :: [SPProofStep]}
        deriving (Int -> SPProofList -> ShowS
[SPProofList] -> ShowS
SPProofList -> String
(Int -> SPProofList -> ShowS)
-> (SPProofList -> String)
-> ([SPProofList] -> ShowS)
-> Show SPProofList
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPProofList] -> ShowS
$cshowList :: [SPProofList] -> ShowS
show :: SPProofList -> String
$cshow :: SPProofList -> String
showsPrec :: Int -> SPProofList -> ShowS
$cshowsPrec :: Int -> SPProofList -> ShowS
Show, SPProofList -> SPProofList -> Bool
(SPProofList -> SPProofList -> Bool)
-> (SPProofList -> SPProofList -> Bool) -> Eq SPProofList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPProofList -> SPProofList -> Bool
$c/= :: SPProofList -> SPProofList -> Bool
== :: SPProofList -> SPProofList -> Bool
$c== :: SPProofList -> SPProofList -> Bool
Eq, Eq SPProofList
Eq SPProofList =>
(SPProofList -> SPProofList -> Ordering)
-> (SPProofList -> SPProofList -> Bool)
-> (SPProofList -> SPProofList -> Bool)
-> (SPProofList -> SPProofList -> Bool)
-> (SPProofList -> SPProofList -> Bool)
-> (SPProofList -> SPProofList -> SPProofList)
-> (SPProofList -> SPProofList -> SPProofList)
-> Ord SPProofList
SPProofList -> SPProofList -> Bool
SPProofList -> SPProofList -> Ordering
SPProofList -> SPProofList -> SPProofList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPProofList -> SPProofList -> SPProofList
$cmin :: SPProofList -> SPProofList -> SPProofList
max :: SPProofList -> SPProofList -> SPProofList
$cmax :: SPProofList -> SPProofList -> SPProofList
>= :: SPProofList -> SPProofList -> Bool
$c>= :: SPProofList -> SPProofList -> Bool
> :: SPProofList -> SPProofList -> Bool
$c> :: SPProofList -> SPProofList -> Bool
<= :: SPProofList -> SPProofList -> Bool
$c<= :: SPProofList -> SPProofList -> Bool
< :: SPProofList -> SPProofList -> Bool
$c< :: SPProofList -> SPProofList -> Bool
compare :: SPProofList -> SPProofList -> Ordering
$ccompare :: SPProofList -> SPProofList -> Ordering
$cp1Ord :: Eq SPProofList
Ord, Typeable, Typeable SPProofList
Constr
DataType
Typeable SPProofList =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPProofList -> c SPProofList)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPProofList)
-> (SPProofList -> Constr)
-> (SPProofList -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPProofList))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPProofList))
-> ((forall b. Data b => b -> b) -> SPProofList -> SPProofList)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPProofList -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPProofList -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPProofList -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPProofList -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPProofList -> m SPProofList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPProofList -> m SPProofList)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPProofList -> m SPProofList)
-> Data SPProofList
SPProofList -> Constr
SPProofList -> DataType
(forall b. Data b => b -> b) -> SPProofList -> SPProofList
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofList -> c SPProofList
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofList
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPProofList -> u
forall u. (forall d. Data d => d -> u) -> SPProofList -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofList -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofList -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofList
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofList -> c SPProofList
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPProofList)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPProofList)
$cSPProofList :: Constr
$tSPProofList :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
gmapMp :: (forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
gmapM :: (forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPProofList -> m SPProofList
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPProofList -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPProofList -> u
gmapQ :: (forall d. Data d => d -> u) -> SPProofList -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPProofList -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofList -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofList -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofList -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofList -> r
gmapT :: (forall b. Data b => b -> b) -> SPProofList -> SPProofList
$cgmapT :: (forall b. Data b => b -> b) -> SPProofList -> SPProofList
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPProofList)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPProofList)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPProofList)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPProofList)
dataTypeOf :: SPProofList -> DataType
$cdataTypeOf :: SPProofList -> DataType
toConstr :: SPProofList -> Constr
$ctoConstr :: SPProofList -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofList
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofList
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofList -> c SPProofList
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofList -> c SPProofList
$cp1Data :: Typeable SPProofList
Data)

type SPProofType = SPIdentifier

data SPProofStep = SPProofStep { SPProofStep -> SPReference
reference :: SPReference,
                                 SPProofStep -> SPResult
result :: SPResult,
                                 SPProofStep -> SPRuleAppl
ruleAppl :: SPRuleAppl,
                                 SPProofStep -> [SPParent]
parentList :: [SPParent],
                                 SPProofStep -> SPAssocList
stepAssocList :: SPAssocList}
                   deriving (Int -> SPProofStep -> ShowS
[SPProofStep] -> ShowS
SPProofStep -> String
(Int -> SPProofStep -> ShowS)
-> (SPProofStep -> String)
-> ([SPProofStep] -> ShowS)
-> Show SPProofStep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPProofStep] -> ShowS
$cshowList :: [SPProofStep] -> ShowS
show :: SPProofStep -> String
$cshow :: SPProofStep -> String
showsPrec :: Int -> SPProofStep -> ShowS
$cshowsPrec :: Int -> SPProofStep -> ShowS
Show, SPProofStep -> SPProofStep -> Bool
(SPProofStep -> SPProofStep -> Bool)
-> (SPProofStep -> SPProofStep -> Bool) -> Eq SPProofStep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPProofStep -> SPProofStep -> Bool
$c/= :: SPProofStep -> SPProofStep -> Bool
== :: SPProofStep -> SPProofStep -> Bool
$c== :: SPProofStep -> SPProofStep -> Bool
Eq, Eq SPProofStep
Eq SPProofStep =>
(SPProofStep -> SPProofStep -> Ordering)
-> (SPProofStep -> SPProofStep -> Bool)
-> (SPProofStep -> SPProofStep -> Bool)
-> (SPProofStep -> SPProofStep -> Bool)
-> (SPProofStep -> SPProofStep -> Bool)
-> (SPProofStep -> SPProofStep -> SPProofStep)
-> (SPProofStep -> SPProofStep -> SPProofStep)
-> Ord SPProofStep
SPProofStep -> SPProofStep -> Bool
SPProofStep -> SPProofStep -> Ordering
SPProofStep -> SPProofStep -> SPProofStep
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPProofStep -> SPProofStep -> SPProofStep
$cmin :: SPProofStep -> SPProofStep -> SPProofStep
max :: SPProofStep -> SPProofStep -> SPProofStep
$cmax :: SPProofStep -> SPProofStep -> SPProofStep
>= :: SPProofStep -> SPProofStep -> Bool
$c>= :: SPProofStep -> SPProofStep -> Bool
> :: SPProofStep -> SPProofStep -> Bool
$c> :: SPProofStep -> SPProofStep -> Bool
<= :: SPProofStep -> SPProofStep -> Bool
$c<= :: SPProofStep -> SPProofStep -> Bool
< :: SPProofStep -> SPProofStep -> Bool
$c< :: SPProofStep -> SPProofStep -> Bool
compare :: SPProofStep -> SPProofStep -> Ordering
$ccompare :: SPProofStep -> SPProofStep -> Ordering
$cp1Ord :: Eq SPProofStep
Ord, Typeable, Typeable SPProofStep
Constr
DataType
Typeable SPProofStep =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPProofStep -> c SPProofStep)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPProofStep)
-> (SPProofStep -> Constr)
-> (SPProofStep -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPProofStep))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPProofStep))
-> ((forall b. Data b => b -> b) -> SPProofStep -> SPProofStep)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPProofStep -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPProofStep -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPProofStep -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPProofStep -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep)
-> Data SPProofStep
SPProofStep -> Constr
SPProofStep -> DataType
(forall b. Data b => b -> b) -> SPProofStep -> SPProofStep
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofStep -> c SPProofStep
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofStep
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPProofStep -> u
forall u. (forall d. Data d => d -> u) -> SPProofStep -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofStep -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofStep -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofStep
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofStep -> c SPProofStep
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPProofStep)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPProofStep)
$cSPProofStep :: Constr
$tSPProofStep :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
gmapMp :: (forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
gmapM :: (forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPProofStep -> m SPProofStep
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPProofStep -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPProofStep -> u
gmapQ :: (forall d. Data d => d -> u) -> SPProofStep -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPProofStep -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofStep -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofStep -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofStep -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPProofStep -> r
gmapT :: (forall b. Data b => b -> b) -> SPProofStep -> SPProofStep
$cgmapT :: (forall b. Data b => b -> b) -> SPProofStep -> SPProofStep
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPProofStep)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPProofStep)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPProofStep)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPProofStep)
dataTypeOf :: SPProofStep -> DataType
$cdataTypeOf :: SPProofStep -> DataType
toConstr :: SPProofStep -> Constr
$ctoConstr :: SPProofStep -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofStep
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPProofStep
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofStep -> c SPProofStep
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPProofStep -> c SPProofStep
$cp1Data :: Typeable SPProofStep
Data)

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

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

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

data SPUserRuleAppl = GeR | SpL | SpR | EqF | Rew | Obv | EmS | SoR | EqR
                    | Mpm | SPm | OPm | SHy | OHy | URR | Fac | Spt | Inp
                    | Con | RRE | SSi | ClR | UnC | Ter
                      deriving (Int -> SPUserRuleAppl -> ShowS
[SPUserRuleAppl] -> ShowS
SPUserRuleAppl -> String
(Int -> SPUserRuleAppl -> ShowS)
-> (SPUserRuleAppl -> String)
-> ([SPUserRuleAppl] -> ShowS)
-> Show SPUserRuleAppl
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPUserRuleAppl] -> ShowS
$cshowList :: [SPUserRuleAppl] -> ShowS
show :: SPUserRuleAppl -> String
$cshow :: SPUserRuleAppl -> String
showsPrec :: Int -> SPUserRuleAppl -> ShowS
$cshowsPrec :: Int -> SPUserRuleAppl -> ShowS
Show, SPUserRuleAppl -> SPUserRuleAppl -> Bool
(SPUserRuleAppl -> SPUserRuleAppl -> Bool)
-> (SPUserRuleAppl -> SPUserRuleAppl -> Bool) -> Eq SPUserRuleAppl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
$c/= :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
== :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
$c== :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
Eq, Eq SPUserRuleAppl
Eq SPUserRuleAppl =>
(SPUserRuleAppl -> SPUserRuleAppl -> Ordering)
-> (SPUserRuleAppl -> SPUserRuleAppl -> Bool)
-> (SPUserRuleAppl -> SPUserRuleAppl -> Bool)
-> (SPUserRuleAppl -> SPUserRuleAppl -> Bool)
-> (SPUserRuleAppl -> SPUserRuleAppl -> Bool)
-> (SPUserRuleAppl -> SPUserRuleAppl -> SPUserRuleAppl)
-> (SPUserRuleAppl -> SPUserRuleAppl -> SPUserRuleAppl)
-> Ord SPUserRuleAppl
SPUserRuleAppl -> SPUserRuleAppl -> Bool
SPUserRuleAppl -> SPUserRuleAppl -> Ordering
SPUserRuleAppl -> SPUserRuleAppl -> SPUserRuleAppl
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPUserRuleAppl -> SPUserRuleAppl -> SPUserRuleAppl
$cmin :: SPUserRuleAppl -> SPUserRuleAppl -> SPUserRuleAppl
max :: SPUserRuleAppl -> SPUserRuleAppl -> SPUserRuleAppl
$cmax :: SPUserRuleAppl -> SPUserRuleAppl -> SPUserRuleAppl
>= :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
$c>= :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
> :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
$c> :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
<= :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
$c<= :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
< :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
$c< :: SPUserRuleAppl -> SPUserRuleAppl -> Bool
compare :: SPUserRuleAppl -> SPUserRuleAppl -> Ordering
$ccompare :: SPUserRuleAppl -> SPUserRuleAppl -> Ordering
$cp1Ord :: Eq SPUserRuleAppl
Ord, Typeable, Typeable SPUserRuleAppl
Constr
DataType
Typeable SPUserRuleAppl =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPUserRuleAppl -> c SPUserRuleAppl)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPUserRuleAppl)
-> (SPUserRuleAppl -> Constr)
-> (SPUserRuleAppl -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPUserRuleAppl))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPUserRuleAppl))
-> ((forall b. Data b => b -> b)
    -> SPUserRuleAppl -> SPUserRuleAppl)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SPUserRuleAppl -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPUserRuleAppl -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SPUserRuleAppl -> m SPUserRuleAppl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SPUserRuleAppl -> m SPUserRuleAppl)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SPUserRuleAppl -> m SPUserRuleAppl)
-> Data SPUserRuleAppl
SPUserRuleAppl -> Constr
SPUserRuleAppl -> DataType
(forall b. Data b => b -> b) -> SPUserRuleAppl -> SPUserRuleAppl
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPUserRuleAppl -> c SPUserRuleAppl
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPUserRuleAppl
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SPUserRuleAppl -> u
forall u. (forall d. Data d => d -> u) -> SPUserRuleAppl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPUserRuleAppl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPUserRuleAppl -> c SPUserRuleAppl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPUserRuleAppl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPUserRuleAppl)
$cTer :: Constr
$cUnC :: Constr
$cClR :: Constr
$cSSi :: Constr
$cRRE :: Constr
$cCon :: Constr
$cInp :: Constr
$cSpt :: Constr
$cFac :: Constr
$cURR :: Constr
$cOHy :: Constr
$cSHy :: Constr
$cOPm :: Constr
$cSPm :: Constr
$cMpm :: Constr
$cEqR :: Constr
$cSoR :: Constr
$cEmS :: Constr
$cObv :: Constr
$cRew :: Constr
$cEqF :: Constr
$cSpR :: Constr
$cSpL :: Constr
$cGeR :: Constr
$tSPUserRuleAppl :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
gmapMp :: (forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
gmapM :: (forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SPUserRuleAppl -> m SPUserRuleAppl
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPUserRuleAppl -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SPUserRuleAppl -> u
gmapQ :: (forall d. Data d => d -> u) -> SPUserRuleAppl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPUserRuleAppl -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPUserRuleAppl -> r
gmapT :: (forall b. Data b => b -> b) -> SPUserRuleAppl -> SPUserRuleAppl
$cgmapT :: (forall b. Data b => b -> b) -> SPUserRuleAppl -> SPUserRuleAppl
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPUserRuleAppl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPUserRuleAppl)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPUserRuleAppl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPUserRuleAppl)
dataTypeOf :: SPUserRuleAppl -> DataType
$cdataTypeOf :: SPUserRuleAppl -> DataType
toConstr :: SPUserRuleAppl -> Constr
$ctoConstr :: SPUserRuleAppl -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPUserRuleAppl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPUserRuleAppl
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPUserRuleAppl -> c SPUserRuleAppl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPUserRuleAppl -> c SPUserRuleAppl
$cp1Data :: Typeable SPUserRuleAppl
Data)

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

type SPAssocList = Map.Map SPKey SPValue

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

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

-- *** Formulae And Terms

{- |
  A SPASS Formula is modelled as a Named SPTerm for now. This doesn't reflect
  the fact that the SPASS syntax lists both term and label as optional.
-}
type SPFormula = Named SPTerm

-- ** helpers for generating SoftFOL formulas

typedVarTerm :: SPIdentifier -- ^ Variable symbol: v
             -> SPIdentifier -- ^ Sort symbol: s
             -> SPTerm -- ^ Term: s(v)
typedVarTerm :: SPIdentifier -> SPIdentifier -> SPTerm
typedVarTerm spVar :: SPIdentifier
spVar spSort :: SPIdentifier
spSort = SPSymbol -> [SPTerm] -> SPTerm
compTerm (SPIdentifier -> SPSymbol
spSym SPIdentifier
spSort) [SPSymbol -> SPTerm
simpTerm (SPIdentifier -> SPSymbol
spSym SPIdentifier
spVar)]

spTerms :: [SPIdentifier] -> [SPTerm]
spTerms :: [SPIdentifier] -> [SPTerm]
spTerms = (SPIdentifier -> SPTerm) -> [SPIdentifier] -> [SPTerm]
forall a b. (a -> b) -> [a] -> [b]
map (SPSymbol -> SPTerm
simpTerm (SPSymbol -> SPTerm)
-> (SPIdentifier -> SPSymbol) -> SPIdentifier -> SPTerm
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SPIdentifier -> SPSymbol
spSym)

spSym :: SPIdentifier -> SPSymbol
spSym :: SPIdentifier -> SPSymbol
spSym = SPIdentifier -> SPSymbol
SPCustomSymbol

compTerm :: SPSymbol -> [SPTerm] -> SPTerm
compTerm :: SPSymbol -> [SPTerm] -> SPTerm
compTerm = SPSymbol -> [SPTerm] -> SPTerm
SPComplexTerm

simpTerm :: SPSymbol -> SPTerm
simpTerm :: SPSymbol -> SPTerm
simpTerm s :: SPSymbol
s = SPSymbol -> [SPTerm] -> SPTerm
compTerm SPSymbol
s []

mkConj :: SPTerm -> SPTerm -> SPTerm
mkConj :: SPTerm -> SPTerm -> SPTerm
mkConj t1 :: SPTerm
t1 t2 :: SPTerm
t2 = SPSymbol -> [SPTerm] -> SPTerm
compTerm SPSymbol
SPAnd [SPTerm
t1, SPTerm
t2]

mkDisj :: SPTerm -> SPTerm -> SPTerm
mkDisj :: SPTerm -> SPTerm -> SPTerm
mkDisj t1 :: SPTerm
t1 t2 :: SPTerm
t2 = SPSymbol -> [SPTerm] -> SPTerm
compTerm SPSymbol
SPOr [SPTerm
t1, SPTerm
t2]

mkEq :: SPTerm -> SPTerm -> SPTerm
mkEq :: SPTerm -> SPTerm -> SPTerm
mkEq t1 :: SPTerm
t1 t2 :: SPTerm
t2 = SPSymbol -> [SPTerm] -> SPTerm
compTerm SPSymbol
SPEqual [SPTerm
t1, SPTerm
t2]

-- ** SPASS Desciptions

{- | A description is mandatory for a SPASS problem. It has to specify
  at least a 'name', the name of the 'author', the 'status' (see also
  'SPLogState' below), and a (verbose) description. -}
data SPDescription =
        SPDescription { SPDescription -> String
name :: String,
                        SPDescription -> String
author :: String,
                        SPDescription -> Maybe String
version :: Maybe String,
                        SPDescription -> Maybe String
logic :: Maybe String,
                        SPDescription -> SPLogState
status :: SPLogState,
                        SPDescription -> String
desc :: String,
                        SPDescription -> Maybe String
date :: Maybe String}
      deriving (Int -> SPDescription -> ShowS
[SPDescription] -> ShowS
SPDescription -> String
(Int -> SPDescription -> ShowS)
-> (SPDescription -> String)
-> ([SPDescription] -> ShowS)
-> Show SPDescription
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPDescription] -> ShowS
$cshowList :: [SPDescription] -> ShowS
show :: SPDescription -> String
$cshow :: SPDescription -> String
showsPrec :: Int -> SPDescription -> ShowS
$cshowsPrec :: Int -> SPDescription -> ShowS
Show, SPDescription -> SPDescription -> Bool
(SPDescription -> SPDescription -> Bool)
-> (SPDescription -> SPDescription -> Bool) -> Eq SPDescription
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPDescription -> SPDescription -> Bool
$c/= :: SPDescription -> SPDescription -> Bool
== :: SPDescription -> SPDescription -> Bool
$c== :: SPDescription -> SPDescription -> Bool
Eq, Eq SPDescription
Eq SPDescription =>
(SPDescription -> SPDescription -> Ordering)
-> (SPDescription -> SPDescription -> Bool)
-> (SPDescription -> SPDescription -> Bool)
-> (SPDescription -> SPDescription -> Bool)
-> (SPDescription -> SPDescription -> Bool)
-> (SPDescription -> SPDescription -> SPDescription)
-> (SPDescription -> SPDescription -> SPDescription)
-> Ord SPDescription
SPDescription -> SPDescription -> Bool
SPDescription -> SPDescription -> Ordering
SPDescription -> SPDescription -> SPDescription
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPDescription -> SPDescription -> SPDescription
$cmin :: SPDescription -> SPDescription -> SPDescription
max :: SPDescription -> SPDescription -> SPDescription
$cmax :: SPDescription -> SPDescription -> SPDescription
>= :: SPDescription -> SPDescription -> Bool
$c>= :: SPDescription -> SPDescription -> Bool
> :: SPDescription -> SPDescription -> Bool
$c> :: SPDescription -> SPDescription -> Bool
<= :: SPDescription -> SPDescription -> Bool
$c<= :: SPDescription -> SPDescription -> Bool
< :: SPDescription -> SPDescription -> Bool
$c< :: SPDescription -> SPDescription -> Bool
compare :: SPDescription -> SPDescription -> Ordering
$ccompare :: SPDescription -> SPDescription -> Ordering
$cp1Ord :: Eq SPDescription
Ord, Typeable, Typeable SPDescription
Constr
DataType
Typeable SPDescription =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPDescription -> c SPDescription)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPDescription)
-> (SPDescription -> Constr)
-> (SPDescription -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPDescription))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPDescription))
-> ((forall b. Data b => b -> b) -> SPDescription -> SPDescription)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPDescription -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPDescription -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPDescription -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPDescription -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPDescription -> m SPDescription)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPDescription -> m SPDescription)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPDescription -> m SPDescription)
-> Data SPDescription
SPDescription -> Constr
SPDescription -> DataType
(forall b. Data b => b -> b) -> SPDescription -> SPDescription
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDescription -> c SPDescription
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDescription
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPDescription -> u
forall u. (forall d. Data d => d -> u) -> SPDescription -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPDescription -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPDescription -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDescription
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDescription -> c SPDescription
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPDescription)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPDescription)
$cSPDescription :: Constr
$tSPDescription :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
gmapMp :: (forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
gmapM :: (forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPDescription -> m SPDescription
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPDescription -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPDescription -> u
gmapQ :: (forall d. Data d => d -> u) -> SPDescription -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPDescription -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPDescription -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPDescription -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPDescription -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPDescription -> r
gmapT :: (forall b. Data b => b -> b) -> SPDescription -> SPDescription
$cgmapT :: (forall b. Data b => b -> b) -> SPDescription -> SPDescription
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPDescription)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPDescription)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPDescription)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPDescription)
dataTypeOf :: SPDescription -> DataType
$cdataTypeOf :: SPDescription -> DataType
toConstr :: SPDescription -> Constr
$ctoConstr :: SPDescription -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDescription
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPDescription
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDescription -> c SPDescription
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPDescription -> c SPDescription
$cp1Data :: Typeable SPDescription
Data)

{- |
  The state of a SPASS problem can be satisfiable, unsatisfiable, or unknown.
-}
data SPLogState =
        SPStateSatisfiable
      | SPStateUnsatisfiable
      | SPStateUnknown
      deriving (Int -> SPLogState -> ShowS
[SPLogState] -> ShowS
SPLogState -> String
(Int -> SPLogState -> ShowS)
-> (SPLogState -> String)
-> ([SPLogState] -> ShowS)
-> Show SPLogState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPLogState] -> ShowS
$cshowList :: [SPLogState] -> ShowS
show :: SPLogState -> String
$cshow :: SPLogState -> String
showsPrec :: Int -> SPLogState -> ShowS
$cshowsPrec :: Int -> SPLogState -> ShowS
Show, SPLogState -> SPLogState -> Bool
(SPLogState -> SPLogState -> Bool)
-> (SPLogState -> SPLogState -> Bool) -> Eq SPLogState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPLogState -> SPLogState -> Bool
$c/= :: SPLogState -> SPLogState -> Bool
== :: SPLogState -> SPLogState -> Bool
$c== :: SPLogState -> SPLogState -> Bool
Eq, Eq SPLogState
Eq SPLogState =>
(SPLogState -> SPLogState -> Ordering)
-> (SPLogState -> SPLogState -> Bool)
-> (SPLogState -> SPLogState -> Bool)
-> (SPLogState -> SPLogState -> Bool)
-> (SPLogState -> SPLogState -> Bool)
-> (SPLogState -> SPLogState -> SPLogState)
-> (SPLogState -> SPLogState -> SPLogState)
-> Ord SPLogState
SPLogState -> SPLogState -> Bool
SPLogState -> SPLogState -> Ordering
SPLogState -> SPLogState -> SPLogState
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPLogState -> SPLogState -> SPLogState
$cmin :: SPLogState -> SPLogState -> SPLogState
max :: SPLogState -> SPLogState -> SPLogState
$cmax :: SPLogState -> SPLogState -> SPLogState
>= :: SPLogState -> SPLogState -> Bool
$c>= :: SPLogState -> SPLogState -> Bool
> :: SPLogState -> SPLogState -> Bool
$c> :: SPLogState -> SPLogState -> Bool
<= :: SPLogState -> SPLogState -> Bool
$c<= :: SPLogState -> SPLogState -> Bool
< :: SPLogState -> SPLogState -> Bool
$c< :: SPLogState -> SPLogState -> Bool
compare :: SPLogState -> SPLogState -> Ordering
$ccompare :: SPLogState -> SPLogState -> Ordering
$cp1Ord :: Eq SPLogState
Ord, Typeable, Typeable SPLogState
Constr
DataType
Typeable SPLogState =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPLogState -> c SPLogState)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPLogState)
-> (SPLogState -> Constr)
-> (SPLogState -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPLogState))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPLogState))
-> ((forall b. Data b => b -> b) -> SPLogState -> SPLogState)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPLogState -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPLogState -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPLogState -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPLogState -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPLogState -> m SPLogState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPLogState -> m SPLogState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPLogState -> m SPLogState)
-> Data SPLogState
SPLogState -> Constr
SPLogState -> DataType
(forall b. Data b => b -> b) -> SPLogState -> SPLogState
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogState -> c SPLogState
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogState
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPLogState -> u
forall u. (forall d. Data d => d -> u) -> SPLogState -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogState -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogState -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogState
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogState -> c SPLogState
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPLogState)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPLogState)
$cSPStateUnknown :: Constr
$cSPStateUnsatisfiable :: Constr
$cSPStateSatisfiable :: Constr
$tSPLogState :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
gmapMp :: (forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
gmapM :: (forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPLogState -> m SPLogState
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPLogState -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPLogState -> u
gmapQ :: (forall d. Data d => d -> u) -> SPLogState -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPLogState -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogState -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogState -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogState -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPLogState -> r
gmapT :: (forall b. Data b => b -> b) -> SPLogState -> SPLogState
$cgmapT :: (forall b. Data b => b -> b) -> SPLogState -> SPLogState
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPLogState)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPLogState)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPLogState)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPLogState)
dataTypeOf :: SPLogState -> DataType
$cdataTypeOf :: SPLogState -> DataType
toConstr :: SPLogState -> Constr
$ctoConstr :: SPLogState -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogState
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPLogState
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogState -> c SPLogState
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPLogState -> c SPLogState
$cp1Data :: Typeable SPLogState
Data)

-- ** SPASS Settings

{- |
   New impelmentation of Settings. See spass input syntax Version 1.5.
-}
data SPSetting = SPGeneralSettings {SPSetting -> [SPHypothesis]
entries :: [SPHypothesis]}
               | SPSettings {SPSetting -> SPSettingLabel
settingName :: SPSettingLabel,
                             SPSetting -> [SPSettingBody]
settingBody :: [SPSettingBody]}
                 deriving (Int -> SPSetting -> ShowS
[SPSetting] -> ShowS
SPSetting -> String
(Int -> SPSetting -> ShowS)
-> (SPSetting -> String)
-> ([SPSetting] -> ShowS)
-> Show SPSetting
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPSetting] -> ShowS
$cshowList :: [SPSetting] -> ShowS
show :: SPSetting -> String
$cshow :: SPSetting -> String
showsPrec :: Int -> SPSetting -> ShowS
$cshowsPrec :: Int -> SPSetting -> ShowS
Show, SPSetting -> SPSetting -> Bool
(SPSetting -> SPSetting -> Bool)
-> (SPSetting -> SPSetting -> Bool) -> Eq SPSetting
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPSetting -> SPSetting -> Bool
$c/= :: SPSetting -> SPSetting -> Bool
== :: SPSetting -> SPSetting -> Bool
$c== :: SPSetting -> SPSetting -> Bool
Eq, Eq SPSetting
Eq SPSetting =>
(SPSetting -> SPSetting -> Ordering)
-> (SPSetting -> SPSetting -> Bool)
-> (SPSetting -> SPSetting -> Bool)
-> (SPSetting -> SPSetting -> Bool)
-> (SPSetting -> SPSetting -> Bool)
-> (SPSetting -> SPSetting -> SPSetting)
-> (SPSetting -> SPSetting -> SPSetting)
-> Ord SPSetting
SPSetting -> SPSetting -> Bool
SPSetting -> SPSetting -> Ordering
SPSetting -> SPSetting -> SPSetting
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPSetting -> SPSetting -> SPSetting
$cmin :: SPSetting -> SPSetting -> SPSetting
max :: SPSetting -> SPSetting -> SPSetting
$cmax :: SPSetting -> SPSetting -> SPSetting
>= :: SPSetting -> SPSetting -> Bool
$c>= :: SPSetting -> SPSetting -> Bool
> :: SPSetting -> SPSetting -> Bool
$c> :: SPSetting -> SPSetting -> Bool
<= :: SPSetting -> SPSetting -> Bool
$c<= :: SPSetting -> SPSetting -> Bool
< :: SPSetting -> SPSetting -> Bool
$c< :: SPSetting -> SPSetting -> Bool
compare :: SPSetting -> SPSetting -> Ordering
$ccompare :: SPSetting -> SPSetting -> Ordering
$cp1Ord :: Eq SPSetting
Ord, Typeable, Typeable SPSetting
Constr
DataType
Typeable SPSetting =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPSetting -> c SPSetting)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPSetting)
-> (SPSetting -> Constr)
-> (SPSetting -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPSetting))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSetting))
-> ((forall b. Data b => b -> b) -> SPSetting -> SPSetting)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSetting -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSetting -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPSetting -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPSetting -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPSetting -> m SPSetting)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSetting -> m SPSetting)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPSetting -> m SPSetting)
-> Data SPSetting
SPSetting -> Constr
SPSetting -> DataType
(forall b. Data b => b -> b) -> SPSetting -> SPSetting
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSetting -> c SPSetting
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSetting
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPSetting -> u
forall u. (forall d. Data d => d -> u) -> SPSetting -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSetting -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSetting -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSetting
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSetting -> c SPSetting
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSetting)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSetting)
$cSPSettings :: Constr
$cSPGeneralSettings :: Constr
$tSPSetting :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
gmapMp :: (forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
gmapM :: (forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPSetting -> m SPSetting
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPSetting -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPSetting -> u
gmapQ :: (forall d. Data d => d -> u) -> SPSetting -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPSetting -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSetting -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSetting -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSetting -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSetting -> r
gmapT :: (forall b. Data b => b -> b) -> SPSetting -> SPSetting
$cgmapT :: (forall b. Data b => b -> b) -> SPSetting -> SPSetting
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSetting)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPSetting)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPSetting)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSetting)
dataTypeOf :: SPSetting -> DataType
$cdataTypeOf :: SPSetting -> DataType
toConstr :: SPSetting -> Constr
$ctoConstr :: SPSetting -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSetting
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSetting
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSetting -> c SPSetting
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSetting -> c SPSetting
$cp1Data :: Typeable SPSetting
Data)

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

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

data SPSettingLabel = KIV | LEM | OTTER | PROTEIN | SATURATE
                    | ThreeTAP | SETHEO | SPASS
                      deriving (Int -> SPSettingLabel -> ShowS
[SPSettingLabel] -> ShowS
SPSettingLabel -> String
(Int -> SPSettingLabel -> ShowS)
-> (SPSettingLabel -> String)
-> ([SPSettingLabel] -> ShowS)
-> Show SPSettingLabel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPSettingLabel] -> ShowS
$cshowList :: [SPSettingLabel] -> ShowS
show :: SPSettingLabel -> String
$cshow :: SPSettingLabel -> String
showsPrec :: Int -> SPSettingLabel -> ShowS
$cshowsPrec :: Int -> SPSettingLabel -> ShowS
Show, SPSettingLabel -> SPSettingLabel -> Bool
(SPSettingLabel -> SPSettingLabel -> Bool)
-> (SPSettingLabel -> SPSettingLabel -> Bool) -> Eq SPSettingLabel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPSettingLabel -> SPSettingLabel -> Bool
$c/= :: SPSettingLabel -> SPSettingLabel -> Bool
== :: SPSettingLabel -> SPSettingLabel -> Bool
$c== :: SPSettingLabel -> SPSettingLabel -> Bool
Eq, Eq SPSettingLabel
Eq SPSettingLabel =>
(SPSettingLabel -> SPSettingLabel -> Ordering)
-> (SPSettingLabel -> SPSettingLabel -> Bool)
-> (SPSettingLabel -> SPSettingLabel -> Bool)
-> (SPSettingLabel -> SPSettingLabel -> Bool)
-> (SPSettingLabel -> SPSettingLabel -> Bool)
-> (SPSettingLabel -> SPSettingLabel -> SPSettingLabel)
-> (SPSettingLabel -> SPSettingLabel -> SPSettingLabel)
-> Ord SPSettingLabel
SPSettingLabel -> SPSettingLabel -> Bool
SPSettingLabel -> SPSettingLabel -> Ordering
SPSettingLabel -> SPSettingLabel -> SPSettingLabel
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPSettingLabel -> SPSettingLabel -> SPSettingLabel
$cmin :: SPSettingLabel -> SPSettingLabel -> SPSettingLabel
max :: SPSettingLabel -> SPSettingLabel -> SPSettingLabel
$cmax :: SPSettingLabel -> SPSettingLabel -> SPSettingLabel
>= :: SPSettingLabel -> SPSettingLabel -> Bool
$c>= :: SPSettingLabel -> SPSettingLabel -> Bool
> :: SPSettingLabel -> SPSettingLabel -> Bool
$c> :: SPSettingLabel -> SPSettingLabel -> Bool
<= :: SPSettingLabel -> SPSettingLabel -> Bool
$c<= :: SPSettingLabel -> SPSettingLabel -> Bool
< :: SPSettingLabel -> SPSettingLabel -> Bool
$c< :: SPSettingLabel -> SPSettingLabel -> Bool
compare :: SPSettingLabel -> SPSettingLabel -> Ordering
$ccompare :: SPSettingLabel -> SPSettingLabel -> Ordering
$cp1Ord :: Eq SPSettingLabel
Ord, Typeable, Typeable SPSettingLabel
Constr
DataType
Typeable SPSettingLabel =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPSettingLabel -> c SPSettingLabel)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPSettingLabel)
-> (SPSettingLabel -> Constr)
-> (SPSettingLabel -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPSettingLabel))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SPSettingLabel))
-> ((forall b. Data b => b -> b)
    -> SPSettingLabel -> SPSettingLabel)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SPSettingLabel -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SPSettingLabel -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SPSettingLabel -> m SPSettingLabel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SPSettingLabel -> m SPSettingLabel)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SPSettingLabel -> m SPSettingLabel)
-> Data SPSettingLabel
SPSettingLabel -> Constr
SPSettingLabel -> DataType
(forall b. Data b => b -> b) -> SPSettingLabel -> SPSettingLabel
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSettingLabel -> c SPSettingLabel
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSettingLabel
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SPSettingLabel -> u
forall u. (forall d. Data d => d -> u) -> SPSettingLabel -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSettingLabel
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSettingLabel -> c SPSettingLabel
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSettingLabel)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPSettingLabel)
$cSPASS :: Constr
$cSETHEO :: Constr
$cThreeTAP :: Constr
$cSATURATE :: Constr
$cPROTEIN :: Constr
$cOTTER :: Constr
$cLEM :: Constr
$cKIV :: Constr
$tSPSettingLabel :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
gmapMp :: (forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
gmapM :: (forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SPSettingLabel -> m SPSettingLabel
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPSettingLabel -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SPSettingLabel -> u
gmapQ :: (forall d. Data d => d -> u) -> SPSettingLabel -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPSettingLabel -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPSettingLabel -> r
gmapT :: (forall b. Data b => b -> b) -> SPSettingLabel -> SPSettingLabel
$cgmapT :: (forall b. Data b => b -> b) -> SPSettingLabel -> SPSettingLabel
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPSettingLabel)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SPSettingLabel)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPSettingLabel)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPSettingLabel)
dataTypeOf :: SPSettingLabel -> DataType
$cdataTypeOf :: SPSettingLabel -> DataType
toConstr :: SPSettingLabel -> Constr
$ctoConstr :: SPSettingLabel -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSettingLabel
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPSettingLabel
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSettingLabel -> c SPSettingLabel
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPSettingLabel -> c SPSettingLabel
$cp1Data :: Typeable SPSettingLabel
Data)

showSettingLabel :: SPSettingLabel -> String
showSettingLabel :: SPSettingLabel -> String
showSettingLabel l :: SPSettingLabel
l = case SPSettingLabel
l of
    ThreeTAP -> "3TAP"
    _ -> SPSettingLabel -> String
forall a. Show a => a -> String
show SPSettingLabel
l

{- |
  A Tupel of the Clause Relation
-}
data SPCRBIND = SPCRBIND {SPCRBIND -> String
clauseSPR :: String, SPCRBIND -> String
formulaSPR :: String}
                deriving (Int -> SPCRBIND -> ShowS
[SPCRBIND] -> ShowS
SPCRBIND -> String
(Int -> SPCRBIND -> ShowS)
-> (SPCRBIND -> String) -> ([SPCRBIND] -> ShowS) -> Show SPCRBIND
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SPCRBIND] -> ShowS
$cshowList :: [SPCRBIND] -> ShowS
show :: SPCRBIND -> String
$cshow :: SPCRBIND -> String
showsPrec :: Int -> SPCRBIND -> ShowS
$cshowsPrec :: Int -> SPCRBIND -> ShowS
Show, SPCRBIND -> SPCRBIND -> Bool
(SPCRBIND -> SPCRBIND -> Bool)
-> (SPCRBIND -> SPCRBIND -> Bool) -> Eq SPCRBIND
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SPCRBIND -> SPCRBIND -> Bool
$c/= :: SPCRBIND -> SPCRBIND -> Bool
== :: SPCRBIND -> SPCRBIND -> Bool
$c== :: SPCRBIND -> SPCRBIND -> Bool
Eq, Eq SPCRBIND
Eq SPCRBIND =>
(SPCRBIND -> SPCRBIND -> Ordering)
-> (SPCRBIND -> SPCRBIND -> Bool)
-> (SPCRBIND -> SPCRBIND -> Bool)
-> (SPCRBIND -> SPCRBIND -> Bool)
-> (SPCRBIND -> SPCRBIND -> Bool)
-> (SPCRBIND -> SPCRBIND -> SPCRBIND)
-> (SPCRBIND -> SPCRBIND -> SPCRBIND)
-> Ord SPCRBIND
SPCRBIND -> SPCRBIND -> Bool
SPCRBIND -> SPCRBIND -> Ordering
SPCRBIND -> SPCRBIND -> SPCRBIND
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SPCRBIND -> SPCRBIND -> SPCRBIND
$cmin :: SPCRBIND -> SPCRBIND -> SPCRBIND
max :: SPCRBIND -> SPCRBIND -> SPCRBIND
$cmax :: SPCRBIND -> SPCRBIND -> SPCRBIND
>= :: SPCRBIND -> SPCRBIND -> Bool
$c>= :: SPCRBIND -> SPCRBIND -> Bool
> :: SPCRBIND -> SPCRBIND -> Bool
$c> :: SPCRBIND -> SPCRBIND -> Bool
<= :: SPCRBIND -> SPCRBIND -> Bool
$c<= :: SPCRBIND -> SPCRBIND -> Bool
< :: SPCRBIND -> SPCRBIND -> Bool
$c< :: SPCRBIND -> SPCRBIND -> Bool
compare :: SPCRBIND -> SPCRBIND -> Ordering
$ccompare :: SPCRBIND -> SPCRBIND -> Ordering
$cp1Ord :: Eq SPCRBIND
Ord, Typeable, Typeable SPCRBIND
Constr
DataType
Typeable SPCRBIND =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SPCRBIND -> c SPCRBIND)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SPCRBIND)
-> (SPCRBIND -> Constr)
-> (SPCRBIND -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SPCRBIND))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPCRBIND))
-> ((forall b. Data b => b -> b) -> SPCRBIND -> SPCRBIND)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r)
-> (forall u. (forall d. Data d => d -> u) -> SPCRBIND -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SPCRBIND -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND)
-> Data SPCRBIND
SPCRBIND -> Constr
SPCRBIND -> DataType
(forall b. Data b => b -> b) -> SPCRBIND -> SPCRBIND
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPCRBIND -> c SPCRBIND
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPCRBIND
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SPCRBIND -> u
forall u. (forall d. Data d => d -> u) -> SPCRBIND -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPCRBIND
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPCRBIND -> c SPCRBIND
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPCRBIND)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPCRBIND)
$cSPCRBIND :: Constr
$tSPCRBIND :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
gmapMp :: (forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
gmapM :: (forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SPCRBIND -> m SPCRBIND
gmapQi :: Int -> (forall d. Data d => d -> u) -> SPCRBIND -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SPCRBIND -> u
gmapQ :: (forall d. Data d => d -> u) -> SPCRBIND -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SPCRBIND -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SPCRBIND -> r
gmapT :: (forall b. Data b => b -> b) -> SPCRBIND -> SPCRBIND
$cgmapT :: (forall b. Data b => b -> b) -> SPCRBIND -> SPCRBIND
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPCRBIND)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SPCRBIND)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SPCRBIND)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SPCRBIND)
dataTypeOf :: SPCRBIND -> DataType
$cdataTypeOf :: SPCRBIND -> DataType
toConstr :: SPCRBIND -> Constr
$ctoConstr :: SPCRBIND -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPCRBIND
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SPCRBIND
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPCRBIND -> c SPCRBIND
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SPCRBIND -> c SPCRBIND
$cp1Data :: Typeable SPCRBIND
Data)


-- | negate a sentence
negateSentence :: SPTerm -> Maybe SPTerm
negateSentence :: SPTerm -> Maybe SPTerm
negateSentence x :: SPTerm
x =
  SPTerm -> Maybe SPTerm
forall a. a -> Maybe a
Just (SPTerm -> Maybe SPTerm) -> SPTerm -> Maybe SPTerm
forall a b. (a -> b) -> a -> b
$ SPSymbol -> [SPTerm] -> SPTerm
SPComplexTerm SPSymbol
SPNot [SPTerm
x]