{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./CASL/AS_Basic_CASL.der.hs
Description :  Abstract syntax of CASL basic specifications
Copyright   :  (c) Klaus Luettich, Christian Maeder, Uni Bremen 2002-2006
License     :  GPLv2 or higher, see LICENSE.txt

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

Abstract Syntax of CASL Basic_specs, Symb_items and Symb_map_items.

   Follows Sect. II:2.2 of the CASL Reference Manual.
-}

module CASL.AS_Basic_CASL where

import Common.Id
import Common.AS_Annotation

import Data.Data
import Data.Function
import Data.List
import qualified Data.Set as Set

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

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

data BASIC_ITEMS b s f = Sig_items (SIG_ITEMS s f)
                   {- the Annotation following the keyword is dropped
                   but preceding the keyword is now an Annotation allowed -}
                 | Free_datatype SortsKind [Annoted DATATYPE_DECL] Range
                   -- pos: free, type, semi colons
                 | Sort_gen [Annoted (SIG_ITEMS s f)] Range
                   -- pos: generated, opt. braces
                 | Var_items [VAR_DECL] Range
                   -- pos: var, semi colons
                 | Local_var_axioms [VAR_DECL] [Annoted (FORMULA f)] Range
                   -- pos: forall, semi colons, dots
                 | Axiom_items [Annoted (FORMULA f)] Range
                   -- pos: dots
                 | Ext_BASIC_ITEMS b
                   deriving (Int -> BASIC_ITEMS b s f -> ShowS
[BASIC_ITEMS b s f] -> ShowS
BASIC_ITEMS b s f -> String
(Int -> BASIC_ITEMS b s f -> ShowS)
-> (BASIC_ITEMS b s f -> String)
-> ([BASIC_ITEMS b s f] -> ShowS)
-> Show (BASIC_ITEMS b s f)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall b s f.
(Show s, Show f, Show b) =>
Int -> BASIC_ITEMS b s f -> ShowS
forall b s f.
(Show s, Show f, Show b) =>
[BASIC_ITEMS b s f] -> ShowS
forall b s f.
(Show s, Show f, Show b) =>
BASIC_ITEMS b s f -> String
showList :: [BASIC_ITEMS b s f] -> ShowS
$cshowList :: forall b s f.
(Show s, Show f, Show b) =>
[BASIC_ITEMS b s f] -> ShowS
show :: BASIC_ITEMS b s f -> String
$cshow :: forall b s f.
(Show s, Show f, Show b) =>
BASIC_ITEMS b s f -> String
showsPrec :: Int -> BASIC_ITEMS b s f -> ShowS
$cshowsPrec :: forall b s f.
(Show s, Show f, Show b) =>
Int -> BASIC_ITEMS b s f -> ShowS
Show, Typeable, Typeable (BASIC_ITEMS b s f)
Constr
DataType
Typeable (BASIC_ITEMS b s f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> BASIC_ITEMS b s f
 -> c (BASIC_ITEMS b s f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BASIC_ITEMS b s f))
-> (BASIC_ITEMS b s f -> Constr)
-> (BASIC_ITEMS b s f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BASIC_ITEMS b s f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BASIC_ITEMS b s f)))
-> ((forall b. Data b => b -> b)
    -> BASIC_ITEMS b s f -> BASIC_ITEMS b s f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f))
-> Data (BASIC_ITEMS b s f)
BASIC_ITEMS b s f -> Constr
BASIC_ITEMS b s f -> DataType
(forall b. Data b => b -> b)
-> BASIC_ITEMS b s f -> BASIC_ITEMS b s f
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> BASIC_ITEMS b s f
-> c (BASIC_ITEMS b s f)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BASIC_ITEMS b s f)
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> u
forall u. (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
forall b s f.
(Data b, Data s, Data f) =>
Typeable (BASIC_ITEMS b s f)
forall b s f.
(Data b, Data s, Data f) =>
BASIC_ITEMS b s f -> Constr
forall b s f.
(Data b, Data s, Data f) =>
BASIC_ITEMS b s f -> DataType
forall b s f.
(Data b, Data s, Data f) =>
(forall b. Data b => b -> b)
-> BASIC_ITEMS b s f -> BASIC_ITEMS b s f
forall b s f u.
(Data b, Data s, Data f) =>
Int -> (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> u
forall b s f u.
(Data b, Data s, Data f) =>
(forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> [u]
forall b s f r r'.
(Data b, Data s, Data f) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
forall b s f r r'.
(Data b, Data s, Data f) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
forall b s f (m :: * -> *).
(Data b, Data s, Data f, Monad m) =>
(forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
forall b s f (m :: * -> *).
(Data b, Data s, Data f, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
forall b s f (c :: * -> *).
(Data b, Data s, Data f) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BASIC_ITEMS b s f)
forall b s f (c :: * -> *).
(Data b, Data s, Data f) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> BASIC_ITEMS b s f
-> c (BASIC_ITEMS b s f)
forall b s f (t :: * -> *) (c :: * -> *).
(Data b, Data s, Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BASIC_ITEMS b s f))
forall b s f (t :: * -> * -> *) (c :: * -> *).
(Data b, Data s, Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BASIC_ITEMS b s f))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BASIC_ITEMS b s f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> BASIC_ITEMS b s f
-> c (BASIC_ITEMS b s f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BASIC_ITEMS b s f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BASIC_ITEMS b s f))
$cExt_BASIC_ITEMS :: Constr
$cAxiom_items :: Constr
$cLocal_var_axioms :: Constr
$cVar_items :: Constr
$cSort_gen :: Constr
$cFree_datatype :: Constr
$cSig_items :: Constr
$tBASIC_ITEMS :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
$cgmapMo :: forall b s f (m :: * -> *).
(Data b, Data s, Data f, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
gmapMp :: (forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
$cgmapMp :: forall b s f (m :: * -> *).
(Data b, Data s, Data f, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
gmapM :: (forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
$cgmapM :: forall b s f (m :: * -> *).
(Data b, Data s, Data f, Monad m) =>
(forall d. Data d => d -> m d)
-> BASIC_ITEMS b s f -> m (BASIC_ITEMS b s f)
gmapQi :: Int -> (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> u
$cgmapQi :: forall b s f u.
(Data b, Data s, Data f) =>
Int -> (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> u
gmapQ :: (forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> [u]
$cgmapQ :: forall b s f u.
(Data b, Data s, Data f) =>
(forall d. Data d => d -> u) -> BASIC_ITEMS b s f -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
$cgmapQr :: forall b s f r r'.
(Data b, Data s, Data f) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
$cgmapQl :: forall b s f r r'.
(Data b, Data s, Data f) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEMS b s f -> r
gmapT :: (forall b. Data b => b -> b)
-> BASIC_ITEMS b s f -> BASIC_ITEMS b s f
$cgmapT :: forall b s f.
(Data b, Data s, Data f) =>
(forall b. Data b => b -> b)
-> BASIC_ITEMS b s f -> BASIC_ITEMS b s f
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BASIC_ITEMS b s f))
$cdataCast2 :: forall b s f (t :: * -> * -> *) (c :: * -> *).
(Data b, Data s, Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BASIC_ITEMS b s f))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (BASIC_ITEMS b s f))
$cdataCast1 :: forall b s f (t :: * -> *) (c :: * -> *).
(Data b, Data s, Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BASIC_ITEMS b s f))
dataTypeOf :: BASIC_ITEMS b s f -> DataType
$cdataTypeOf :: forall b s f.
(Data b, Data s, Data f) =>
BASIC_ITEMS b s f -> DataType
toConstr :: BASIC_ITEMS b s f -> Constr
$ctoConstr :: forall b s f.
(Data b, Data s, Data f) =>
BASIC_ITEMS b s f -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BASIC_ITEMS b s f)
$cgunfold :: forall b s f (c :: * -> *).
(Data b, Data s, Data f) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BASIC_ITEMS b s f)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> BASIC_ITEMS b s f
-> c (BASIC_ITEMS b s f)
$cgfoldl :: forall b s f (c :: * -> *).
(Data b, Data s, Data f) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> BASIC_ITEMS b s f
-> c (BASIC_ITEMS b s f)
$cp1Data :: forall b s f.
(Data b, Data s, Data f) =>
Typeable (BASIC_ITEMS b s f)
Data)

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

data SIG_ITEMS s f = Sort_items SortsKind [Annoted (SORT_ITEM f)] Range
                 -- pos: sort, semi colons
               | Op_items [Annoted (OP_ITEM f)] Range
                 -- pos: op, semi colons
               | Pred_items [Annoted (PRED_ITEM f)] Range
                 -- pos: pred, semi colons
               | Datatype_items SortsKind [Annoted DATATYPE_DECL] Range
                 -- type, semi colons
               | Ext_SIG_ITEMS s
                 deriving (Int -> SIG_ITEMS s f -> ShowS
[SIG_ITEMS s f] -> ShowS
SIG_ITEMS s f -> String
(Int -> SIG_ITEMS s f -> ShowS)
-> (SIG_ITEMS s f -> String)
-> ([SIG_ITEMS s f] -> ShowS)
-> Show (SIG_ITEMS s f)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall s f. (Show f, Show s) => Int -> SIG_ITEMS s f -> ShowS
forall s f. (Show f, Show s) => [SIG_ITEMS s f] -> ShowS
forall s f. (Show f, Show s) => SIG_ITEMS s f -> String
showList :: [SIG_ITEMS s f] -> ShowS
$cshowList :: forall s f. (Show f, Show s) => [SIG_ITEMS s f] -> ShowS
show :: SIG_ITEMS s f -> String
$cshow :: forall s f. (Show f, Show s) => SIG_ITEMS s f -> String
showsPrec :: Int -> SIG_ITEMS s f -> ShowS
$cshowsPrec :: forall s f. (Show f, Show s) => Int -> SIG_ITEMS s f -> ShowS
Show, Typeable, Typeable (SIG_ITEMS s f)
Constr
DataType
Typeable (SIG_ITEMS s f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SIG_ITEMS s f -> c (SIG_ITEMS s f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SIG_ITEMS s f))
-> (SIG_ITEMS s f -> Constr)
-> (SIG_ITEMS s f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SIG_ITEMS s f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SIG_ITEMS s f)))
-> ((forall b. Data b => b -> b) -> SIG_ITEMS s f -> SIG_ITEMS s f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r)
-> (forall u. (forall d. Data d => d -> u) -> SIG_ITEMS s f -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SIG_ITEMS s f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SIG_ITEMS s f -> m (SIG_ITEMS s f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SIG_ITEMS s f -> m (SIG_ITEMS s f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SIG_ITEMS s f -> m (SIG_ITEMS s f))
-> Data (SIG_ITEMS s f)
SIG_ITEMS s f -> Constr
SIG_ITEMS s f -> DataType
(forall b. Data b => b -> b) -> SIG_ITEMS s f -> SIG_ITEMS s f
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SIG_ITEMS s f -> c (SIG_ITEMS s f)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SIG_ITEMS s f)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SIG_ITEMS s f))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SIG_ITEMS s f -> u
forall u. (forall d. Data d => d -> u) -> SIG_ITEMS s f -> [u]
forall s f. (Data s, Data f) => Typeable (SIG_ITEMS s f)
forall s f. (Data s, Data f) => SIG_ITEMS s f -> Constr
forall s f. (Data s, Data f) => SIG_ITEMS s f -> DataType
forall s f.
(Data s, Data f) =>
(forall b. Data b => b -> b) -> SIG_ITEMS s f -> SIG_ITEMS s f
forall s f u.
(Data s, Data f) =>
Int -> (forall d. Data d => d -> u) -> SIG_ITEMS s f -> u
forall s f u.
(Data s, Data f) =>
(forall d. Data d => d -> u) -> SIG_ITEMS s f -> [u]
forall s f r r'.
(Data s, Data f) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
forall s f r r'.
(Data s, Data f) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
forall s f (m :: * -> *).
(Data s, Data f, Monad m) =>
(forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
forall s f (m :: * -> *).
(Data s, Data f, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
forall s f (c :: * -> *).
(Data s, Data f) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SIG_ITEMS s f)
forall s f (c :: * -> *).
(Data s, Data f) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SIG_ITEMS s f -> c (SIG_ITEMS s f)
forall s f (t :: * -> *) (c :: * -> *).
(Data s, Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SIG_ITEMS s f))
forall s f (t :: * -> * -> *) (c :: * -> *).
(Data s, Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SIG_ITEMS s f))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SIG_ITEMS s f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SIG_ITEMS s f -> c (SIG_ITEMS s f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SIG_ITEMS s f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SIG_ITEMS s f))
$cExt_SIG_ITEMS :: Constr
$cDatatype_items :: Constr
$cPred_items :: Constr
$cOp_items :: Constr
$cSort_items :: Constr
$tSIG_ITEMS :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
$cgmapMo :: forall s f (m :: * -> *).
(Data s, Data f, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
gmapMp :: (forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
$cgmapMp :: forall s f (m :: * -> *).
(Data s, Data f, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
gmapM :: (forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
$cgmapM :: forall s f (m :: * -> *).
(Data s, Data f, Monad m) =>
(forall d. Data d => d -> m d)
-> SIG_ITEMS s f -> m (SIG_ITEMS s f)
gmapQi :: Int -> (forall d. Data d => d -> u) -> SIG_ITEMS s f -> u
$cgmapQi :: forall s f u.
(Data s, Data f) =>
Int -> (forall d. Data d => d -> u) -> SIG_ITEMS s f -> u
gmapQ :: (forall d. Data d => d -> u) -> SIG_ITEMS s f -> [u]
$cgmapQ :: forall s f u.
(Data s, Data f) =>
(forall d. Data d => d -> u) -> SIG_ITEMS s f -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
$cgmapQr :: forall s f r r'.
(Data s, Data f) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
$cgmapQl :: forall s f r r'.
(Data s, Data f) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SIG_ITEMS s f -> r
gmapT :: (forall b. Data b => b -> b) -> SIG_ITEMS s f -> SIG_ITEMS s f
$cgmapT :: forall s f.
(Data s, Data f) =>
(forall b. Data b => b -> b) -> SIG_ITEMS s f -> SIG_ITEMS s f
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SIG_ITEMS s f))
$cdataCast2 :: forall s f (t :: * -> * -> *) (c :: * -> *).
(Data s, Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SIG_ITEMS s f))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (SIG_ITEMS s f))
$cdataCast1 :: forall s f (t :: * -> *) (c :: * -> *).
(Data s, Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SIG_ITEMS s f))
dataTypeOf :: SIG_ITEMS s f -> DataType
$cdataTypeOf :: forall s f. (Data s, Data f) => SIG_ITEMS s f -> DataType
toConstr :: SIG_ITEMS s f -> Constr
$ctoConstr :: forall s f. (Data s, Data f) => SIG_ITEMS s f -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SIG_ITEMS s f)
$cgunfold :: forall s f (c :: * -> *).
(Data s, Data f) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SIG_ITEMS s f)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SIG_ITEMS s f -> c (SIG_ITEMS s f)
$cgfoldl :: forall s f (c :: * -> *).
(Data s, Data f) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SIG_ITEMS s f -> c (SIG_ITEMS s f)
$cp1Data :: forall s f. (Data s, Data f) => Typeable (SIG_ITEMS s f)
Data)

data SORT_ITEM f = Sort_decl [SORT] Range
                 -- pos: commas
               | Subsort_decl [SORT] SORT Range
                 -- pos: commas, <
               | Subsort_defn SORT VAR SORT (Annoted (FORMULA f)) Range
                 {- pos: "=", "{", ":", ".", "}"
                 the left anno list stored in Annoted Formula is
                 parsed after the equal sign -}
               | Iso_decl [SORT] Range
                 -- pos: "="s
                 deriving (Int -> SORT_ITEM f -> ShowS
[SORT_ITEM f] -> ShowS
SORT_ITEM f -> String
(Int -> SORT_ITEM f -> ShowS)
-> (SORT_ITEM f -> String)
-> ([SORT_ITEM f] -> ShowS)
-> Show (SORT_ITEM f)
forall f. Show f => Int -> SORT_ITEM f -> ShowS
forall f. Show f => [SORT_ITEM f] -> ShowS
forall f. Show f => SORT_ITEM f -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SORT_ITEM f] -> ShowS
$cshowList :: forall f. Show f => [SORT_ITEM f] -> ShowS
show :: SORT_ITEM f -> String
$cshow :: forall f. Show f => SORT_ITEM f -> String
showsPrec :: Int -> SORT_ITEM f -> ShowS
$cshowsPrec :: forall f. Show f => Int -> SORT_ITEM f -> ShowS
Show, Typeable, Typeable (SORT_ITEM f)
Constr
DataType
Typeable (SORT_ITEM f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SORT_ITEM f -> c (SORT_ITEM f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SORT_ITEM f))
-> (SORT_ITEM f -> Constr)
-> (SORT_ITEM f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SORT_ITEM f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SORT_ITEM f)))
-> ((forall b. Data b => b -> b) -> SORT_ITEM f -> SORT_ITEM f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r)
-> (forall u. (forall d. Data d => d -> u) -> SORT_ITEM f -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SORT_ITEM f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f))
-> Data (SORT_ITEM f)
SORT_ITEM f -> Constr
SORT_ITEM f -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (SORT_ITEM f))
(forall b. Data b => b -> b) -> SORT_ITEM f -> SORT_ITEM f
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SORT_ITEM f -> c (SORT_ITEM f)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SORT_ITEM f)
forall f. Data f => Typeable (SORT_ITEM f)
forall f. Data f => SORT_ITEM f -> Constr
forall f. Data f => SORT_ITEM f -> DataType
forall f.
Data f =>
(forall b. Data b => b -> b) -> SORT_ITEM f -> SORT_ITEM f
forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> SORT_ITEM f -> u
forall f u.
Data f =>
(forall d. Data d => d -> u) -> SORT_ITEM f -> [u]
forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SORT_ITEM f)
forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SORT_ITEM f -> c (SORT_ITEM f)
forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SORT_ITEM f))
forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SORT_ITEM f))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SORT_ITEM f -> u
forall u. (forall d. Data d => d -> u) -> SORT_ITEM f -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SORT_ITEM f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SORT_ITEM f -> c (SORT_ITEM f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SORT_ITEM f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SORT_ITEM f))
$cIso_decl :: Constr
$cSubsort_defn :: Constr
$cSubsort_decl :: Constr
$cSort_decl :: Constr
$tSORT_ITEM :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
$cgmapMo :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
gmapMp :: (forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
$cgmapMp :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
gmapM :: (forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
$cgmapM :: forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> SORT_ITEM f -> m (SORT_ITEM f)
gmapQi :: Int -> (forall d. Data d => d -> u) -> SORT_ITEM f -> u
$cgmapQi :: forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> SORT_ITEM f -> u
gmapQ :: (forall d. Data d => d -> u) -> SORT_ITEM f -> [u]
$cgmapQ :: forall f u.
Data f =>
(forall d. Data d => d -> u) -> SORT_ITEM f -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
$cgmapQr :: forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
$cgmapQl :: forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SORT_ITEM f -> r
gmapT :: (forall b. Data b => b -> b) -> SORT_ITEM f -> SORT_ITEM f
$cgmapT :: forall f.
Data f =>
(forall b. Data b => b -> b) -> SORT_ITEM f -> SORT_ITEM f
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SORT_ITEM f))
$cdataCast2 :: forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SORT_ITEM f))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (SORT_ITEM f))
$cdataCast1 :: forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SORT_ITEM f))
dataTypeOf :: SORT_ITEM f -> DataType
$cdataTypeOf :: forall f. Data f => SORT_ITEM f -> DataType
toConstr :: SORT_ITEM f -> Constr
$ctoConstr :: forall f. Data f => SORT_ITEM f -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SORT_ITEM f)
$cgunfold :: forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SORT_ITEM f)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SORT_ITEM f -> c (SORT_ITEM f)
$cgfoldl :: forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SORT_ITEM f -> c (SORT_ITEM f)
$cp1Data :: forall f. Data f => Typeable (SORT_ITEM f)
Data)

data OP_ITEM f = Op_decl [OP_NAME] OP_TYPE [OP_ATTR f] Range
               -- pos: commas, colon, OP_ATTR sep. by commas
             | Op_defn OP_NAME OP_HEAD (Annoted (TERM f)) Range
               -- pos: "="
               deriving (Int -> OP_ITEM f -> ShowS
[OP_ITEM f] -> ShowS
OP_ITEM f -> String
(Int -> OP_ITEM f -> ShowS)
-> (OP_ITEM f -> String)
-> ([OP_ITEM f] -> ShowS)
-> Show (OP_ITEM f)
forall f. Show f => Int -> OP_ITEM f -> ShowS
forall f. Show f => [OP_ITEM f] -> ShowS
forall f. Show f => OP_ITEM f -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OP_ITEM f] -> ShowS
$cshowList :: forall f. Show f => [OP_ITEM f] -> ShowS
show :: OP_ITEM f -> String
$cshow :: forall f. Show f => OP_ITEM f -> String
showsPrec :: Int -> OP_ITEM f -> ShowS
$cshowsPrec :: forall f. Show f => Int -> OP_ITEM f -> ShowS
Show, Typeable, Typeable (OP_ITEM f)
Constr
DataType
Typeable (OP_ITEM f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OP_ITEM f -> c (OP_ITEM f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (OP_ITEM f))
-> (OP_ITEM f -> Constr)
-> (OP_ITEM f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (OP_ITEM f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (OP_ITEM f)))
-> ((forall b. Data b => b -> b) -> OP_ITEM f -> OP_ITEM f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r)
-> (forall u. (forall d. Data d => d -> u) -> OP_ITEM f -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OP_ITEM f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f))
-> Data (OP_ITEM f)
OP_ITEM f -> Constr
OP_ITEM f -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (OP_ITEM f))
(forall b. Data b => b -> b) -> OP_ITEM f -> OP_ITEM f
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OP_ITEM f -> c (OP_ITEM f)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (OP_ITEM f)
forall f. Data f => Typeable (OP_ITEM f)
forall f. Data f => OP_ITEM f -> Constr
forall f. Data f => OP_ITEM f -> DataType
forall f.
Data f =>
(forall b. Data b => b -> b) -> OP_ITEM f -> OP_ITEM f
forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> OP_ITEM f -> u
forall f u.
Data f =>
(forall d. Data d => d -> u) -> OP_ITEM f -> [u]
forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (OP_ITEM f)
forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OP_ITEM f -> c (OP_ITEM f)
forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (OP_ITEM f))
forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (OP_ITEM f))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OP_ITEM f -> u
forall u. (forall d. Data d => d -> u) -> OP_ITEM f -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (OP_ITEM f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OP_ITEM f -> c (OP_ITEM f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (OP_ITEM f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (OP_ITEM f))
$cOp_defn :: Constr
$cOp_decl :: Constr
$tOP_ITEM :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
$cgmapMo :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
gmapMp :: (forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
$cgmapMp :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
gmapM :: (forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
$cgmapM :: forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> OP_ITEM f -> m (OP_ITEM f)
gmapQi :: Int -> (forall d. Data d => d -> u) -> OP_ITEM f -> u
$cgmapQi :: forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> OP_ITEM f -> u
gmapQ :: (forall d. Data d => d -> u) -> OP_ITEM f -> [u]
$cgmapQ :: forall f u.
Data f =>
(forall d. Data d => d -> u) -> OP_ITEM f -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
$cgmapQr :: forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
$cgmapQl :: forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OP_ITEM f -> r
gmapT :: (forall b. Data b => b -> b) -> OP_ITEM f -> OP_ITEM f
$cgmapT :: forall f.
Data f =>
(forall b. Data b => b -> b) -> OP_ITEM f -> OP_ITEM f
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (OP_ITEM f))
$cdataCast2 :: forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (OP_ITEM f))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (OP_ITEM f))
$cdataCast1 :: forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (OP_ITEM f))
dataTypeOf :: OP_ITEM f -> DataType
$cdataTypeOf :: forall f. Data f => OP_ITEM f -> DataType
toConstr :: OP_ITEM f -> Constr
$ctoConstr :: forall f. Data f => OP_ITEM f -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (OP_ITEM f)
$cgunfold :: forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (OP_ITEM f)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OP_ITEM f -> c (OP_ITEM f)
$cgfoldl :: forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OP_ITEM f -> c (OP_ITEM f)
$cp1Data :: forall f. Data f => Typeable (OP_ITEM f)
Data)

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

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

args_OP_TYPE :: OP_TYPE -> [SORT]
args_OP_TYPE :: OP_TYPE -> [SORT]
args_OP_TYPE (Op_type _ args :: [SORT]
args _ _) = [SORT]
args

res_OP_TYPE :: OP_TYPE -> SORT
res_OP_TYPE :: OP_TYPE -> SORT
res_OP_TYPE (Op_type _ _ res :: SORT
res _) = SORT
res

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

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

data PRED_ITEM f = Pred_decl [PRED_NAME] PRED_TYPE Range
                 -- pos: commas, colon
               | Pred_defn PRED_NAME PRED_HEAD (Annoted (FORMULA f)) Range
                 -- pos: "<=>"
                 deriving (Int -> PRED_ITEM f -> ShowS
[PRED_ITEM f] -> ShowS
PRED_ITEM f -> String
(Int -> PRED_ITEM f -> ShowS)
-> (PRED_ITEM f -> String)
-> ([PRED_ITEM f] -> ShowS)
-> Show (PRED_ITEM f)
forall f. Show f => Int -> PRED_ITEM f -> ShowS
forall f. Show f => [PRED_ITEM f] -> ShowS
forall f. Show f => PRED_ITEM f -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PRED_ITEM f] -> ShowS
$cshowList :: forall f. Show f => [PRED_ITEM f] -> ShowS
show :: PRED_ITEM f -> String
$cshow :: forall f. Show f => PRED_ITEM f -> String
showsPrec :: Int -> PRED_ITEM f -> ShowS
$cshowsPrec :: forall f. Show f => Int -> PRED_ITEM f -> ShowS
Show, Typeable, Typeable (PRED_ITEM f)
Constr
DataType
Typeable (PRED_ITEM f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PRED_ITEM f -> c (PRED_ITEM f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PRED_ITEM f))
-> (PRED_ITEM f -> Constr)
-> (PRED_ITEM f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PRED_ITEM f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PRED_ITEM f)))
-> ((forall b. Data b => b -> b) -> PRED_ITEM f -> PRED_ITEM f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r)
-> (forall u. (forall d. Data d => d -> u) -> PRED_ITEM f -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PRED_ITEM f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f))
-> Data (PRED_ITEM f)
PRED_ITEM f -> Constr
PRED_ITEM f -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (PRED_ITEM f))
(forall b. Data b => b -> b) -> PRED_ITEM f -> PRED_ITEM f
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PRED_ITEM f -> c (PRED_ITEM f)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PRED_ITEM f)
forall f. Data f => Typeable (PRED_ITEM f)
forall f. Data f => PRED_ITEM f -> Constr
forall f. Data f => PRED_ITEM f -> DataType
forall f.
Data f =>
(forall b. Data b => b -> b) -> PRED_ITEM f -> PRED_ITEM f
forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> PRED_ITEM f -> u
forall f u.
Data f =>
(forall d. Data d => d -> u) -> PRED_ITEM f -> [u]
forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PRED_ITEM f)
forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PRED_ITEM f -> c (PRED_ITEM f)
forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PRED_ITEM f))
forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PRED_ITEM f))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PRED_ITEM f -> u
forall u. (forall d. Data d => d -> u) -> PRED_ITEM f -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PRED_ITEM f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PRED_ITEM f -> c (PRED_ITEM f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PRED_ITEM f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PRED_ITEM f))
$cPred_defn :: Constr
$cPred_decl :: Constr
$tPRED_ITEM :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
$cgmapMo :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
gmapMp :: (forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
$cgmapMp :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
gmapM :: (forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
$cgmapM :: forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> PRED_ITEM f -> m (PRED_ITEM f)
gmapQi :: Int -> (forall d. Data d => d -> u) -> PRED_ITEM f -> u
$cgmapQi :: forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> PRED_ITEM f -> u
gmapQ :: (forall d. Data d => d -> u) -> PRED_ITEM f -> [u]
$cgmapQ :: forall f u.
Data f =>
(forall d. Data d => d -> u) -> PRED_ITEM f -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
$cgmapQr :: forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
$cgmapQl :: forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PRED_ITEM f -> r
gmapT :: (forall b. Data b => b -> b) -> PRED_ITEM f -> PRED_ITEM f
$cgmapT :: forall f.
Data f =>
(forall b. Data b => b -> b) -> PRED_ITEM f -> PRED_ITEM f
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PRED_ITEM f))
$cdataCast2 :: forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PRED_ITEM f))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (PRED_ITEM f))
$cdataCast1 :: forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PRED_ITEM f))
dataTypeOf :: PRED_ITEM f -> DataType
$cdataTypeOf :: forall f. Data f => PRED_ITEM f -> DataType
toConstr :: PRED_ITEM f -> Constr
$ctoConstr :: forall f. Data f => PRED_ITEM f -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PRED_ITEM f)
$cgunfold :: forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PRED_ITEM f)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PRED_ITEM f -> c (PRED_ITEM f)
$cgfoldl :: forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PRED_ITEM f -> c (PRED_ITEM f)
$cp1Data :: forall f. Data f => Typeable (PRED_ITEM f)
Data)

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

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

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

data ALTERNATIVE = Alt_construct OpKind OP_NAME [COMPONENTS] Range
                   -- pos: "(", semi colons, ")" optional "?"
                 | Subsorts [SORT] Range
                   -- pos: sort, commas
                   deriving (Int -> ALTERNATIVE -> ShowS
[ALTERNATIVE] -> ShowS
ALTERNATIVE -> String
(Int -> ALTERNATIVE -> ShowS)
-> (ALTERNATIVE -> String)
-> ([ALTERNATIVE] -> ShowS)
-> Show ALTERNATIVE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ALTERNATIVE] -> ShowS
$cshowList :: [ALTERNATIVE] -> ShowS
show :: ALTERNATIVE -> String
$cshow :: ALTERNATIVE -> String
showsPrec :: Int -> ALTERNATIVE -> ShowS
$cshowsPrec :: Int -> ALTERNATIVE -> ShowS
Show, Typeable, Typeable ALTERNATIVE
Constr
DataType
Typeable ALTERNATIVE =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ALTERNATIVE -> c ALTERNATIVE)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ALTERNATIVE)
-> (ALTERNATIVE -> Constr)
-> (ALTERNATIVE -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ALTERNATIVE))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ALTERNATIVE))
-> ((forall b. Data b => b -> b) -> ALTERNATIVE -> ALTERNATIVE)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r)
-> (forall u. (forall d. Data d => d -> u) -> ALTERNATIVE -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ALTERNATIVE -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE)
-> Data ALTERNATIVE
ALTERNATIVE -> Constr
ALTERNATIVE -> DataType
(forall b. Data b => b -> b) -> ALTERNATIVE -> ALTERNATIVE
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ALTERNATIVE -> c ALTERNATIVE
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ALTERNATIVE
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ALTERNATIVE -> u
forall u. (forall d. Data d => d -> u) -> ALTERNATIVE -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ALTERNATIVE
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ALTERNATIVE -> c ALTERNATIVE
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ALTERNATIVE)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ALTERNATIVE)
$cSubsorts :: Constr
$cAlt_construct :: Constr
$tALTERNATIVE :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
gmapMp :: (forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
gmapM :: (forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ALTERNATIVE -> m ALTERNATIVE
gmapQi :: Int -> (forall d. Data d => d -> u) -> ALTERNATIVE -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ALTERNATIVE -> u
gmapQ :: (forall d. Data d => d -> u) -> ALTERNATIVE -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ALTERNATIVE -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ALTERNATIVE -> r
gmapT :: (forall b. Data b => b -> b) -> ALTERNATIVE -> ALTERNATIVE
$cgmapT :: (forall b. Data b => b -> b) -> ALTERNATIVE -> ALTERNATIVE
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ALTERNATIVE)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ALTERNATIVE)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ALTERNATIVE)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ALTERNATIVE)
dataTypeOf :: ALTERNATIVE -> DataType
$cdataTypeOf :: ALTERNATIVE -> DataType
toConstr :: ALTERNATIVE -> Constr
$ctoConstr :: ALTERNATIVE -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ALTERNATIVE
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ALTERNATIVE
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ALTERNATIVE -> c ALTERNATIVE
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ALTERNATIVE -> c ALTERNATIVE
$cp1Data :: Typeable ALTERNATIVE
Data)

data COMPONENTS = Cons_select OpKind [OP_NAME] SORT Range
                  -- pos: commas, colon or ":?"
                | Sort SORT
                  deriving (Int -> COMPONENTS -> ShowS
[COMPONENTS] -> ShowS
COMPONENTS -> String
(Int -> COMPONENTS -> ShowS)
-> (COMPONENTS -> String)
-> ([COMPONENTS] -> ShowS)
-> Show COMPONENTS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [COMPONENTS] -> ShowS
$cshowList :: [COMPONENTS] -> ShowS
show :: COMPONENTS -> String
$cshow :: COMPONENTS -> String
showsPrec :: Int -> COMPONENTS -> ShowS
$cshowsPrec :: Int -> COMPONENTS -> ShowS
Show, Typeable, Typeable COMPONENTS
Constr
DataType
Typeable COMPONENTS =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> COMPONENTS -> c COMPONENTS)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c COMPONENTS)
-> (COMPONENTS -> Constr)
-> (COMPONENTS -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c COMPONENTS))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c COMPONENTS))
-> ((forall b. Data b => b -> b) -> COMPONENTS -> COMPONENTS)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r)
-> (forall u. (forall d. Data d => d -> u) -> COMPONENTS -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> COMPONENTS -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS)
-> Data COMPONENTS
COMPONENTS -> Constr
COMPONENTS -> DataType
(forall b. Data b => b -> b) -> COMPONENTS -> COMPONENTS
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> COMPONENTS -> c COMPONENTS
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c COMPONENTS
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> COMPONENTS -> u
forall u. (forall d. Data d => d -> u) -> COMPONENTS -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c COMPONENTS
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> COMPONENTS -> c COMPONENTS
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c COMPONENTS)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c COMPONENTS)
$cSort :: Constr
$cCons_select :: Constr
$tCOMPONENTS :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
gmapMp :: (forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
gmapM :: (forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> COMPONENTS -> m COMPONENTS
gmapQi :: Int -> (forall d. Data d => d -> u) -> COMPONENTS -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> COMPONENTS -> u
gmapQ :: (forall d. Data d => d -> u) -> COMPONENTS -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> COMPONENTS -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> COMPONENTS -> r
gmapT :: (forall b. Data b => b -> b) -> COMPONENTS -> COMPONENTS
$cgmapT :: (forall b. Data b => b -> b) -> COMPONENTS -> COMPONENTS
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c COMPONENTS)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c COMPONENTS)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c COMPONENTS)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c COMPONENTS)
dataTypeOf :: COMPONENTS -> DataType
$cdataTypeOf :: COMPONENTS -> DataType
toConstr :: COMPONENTS -> Constr
$ctoConstr :: COMPONENTS -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c COMPONENTS
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c COMPONENTS
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> COMPONENTS -> c COMPONENTS
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> COMPONENTS -> c COMPONENTS
$cp1Data :: Typeable COMPONENTS
Data)

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

varDeclRange :: VAR_DECL -> [Pos]
varDeclRange :: VAR_DECL -> [Pos]
varDeclRange (Var_decl vs :: [VAR]
vs s :: SORT
s _) = case [VAR]
vs of
  [] -> []
  v :: VAR
v : _ -> [[Pos]] -> [Pos]
joinRanges [VAR -> [Pos]
tokenRange VAR
v, SORT -> [Pos]
idRange SORT
s]

{- Position definition for FORMULA:
   Information on parens are also encoded in Range.  If there
   are more Pos than necessary there is a pair of Pos enclosing the
   other Pos informations which encode the brackets of every kind
-}

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

dualJunctor :: Junctor -> Junctor
dualJunctor :: Junctor -> Junctor
dualJunctor Con = Junctor
Dis
dualJunctor Dis = Junctor
Con

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

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

data FORMULA f = Quantification QUANTIFIER [VAR_DECL] (FORMULA f) Range
               -- pos: QUANTIFIER, semi colons, dot
             | Junction Junctor [FORMULA f] Range
               -- pos: "/\"s or "\/"s
             | Relation (FORMULA f) Relation (FORMULA f) Range
               {- pos: "<=>", "=>" or "if"
               Note: The first formula is the premise also for "if"!
               Explicitly: During parsing, "f2 if f1" is saved as
               "Relation f1 RevImpl f2 _" -}
             | Negation (FORMULA f) Range
               -- pos: not
             | Atom Bool Range
               -- pos: true or false
             | Predication PRED_SYMB [TERM f] Range
               -- pos: opt. "(",commas,")"
             | Definedness (TERM f) Range
               -- pos: def
             | Equation (TERM f) Equality (TERM f) Range
               -- pos: =e= or =
             | Membership (TERM f) SORT Range
               -- pos: in
             | Mixfix_formula (TERM f)
               {- Mixfix_ Term/Token/(..)/[..]/{..}
               a formula left original for mixfix analysis -}
             | Unparsed_formula String Range
               -- pos: first Char in String
             | Sort_gen_ax [Constraint] Bool -- flag: belongs to a free type?
             | QuantOp OP_NAME OP_TYPE (FORMULA f) -- second order quantifiers
             | QuantPred PRED_NAME PRED_TYPE (FORMULA f)
             | ExtFORMULA f
             -- needed for CASL extensions
               deriving (Int -> FORMULA f -> ShowS
[FORMULA f] -> ShowS
FORMULA f -> String
(Int -> FORMULA f -> ShowS)
-> (FORMULA f -> String)
-> ([FORMULA f] -> ShowS)
-> Show (FORMULA f)
forall f. Show f => Int -> FORMULA f -> ShowS
forall f. Show f => [FORMULA f] -> ShowS
forall f. Show f => FORMULA f -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FORMULA f] -> ShowS
$cshowList :: forall f. Show f => [FORMULA f] -> ShowS
show :: FORMULA f -> String
$cshow :: forall f. Show f => FORMULA f -> String
showsPrec :: Int -> FORMULA f -> ShowS
$cshowsPrec :: forall f. Show f => Int -> FORMULA f -> ShowS
Show, FORMULA f -> FORMULA f -> Bool
(FORMULA f -> FORMULA f -> Bool)
-> (FORMULA f -> FORMULA f -> Bool) -> Eq (FORMULA f)
forall f. Eq f => FORMULA f -> FORMULA f -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FORMULA f -> FORMULA f -> Bool
$c/= :: forall f. Eq f => FORMULA f -> FORMULA f -> Bool
== :: FORMULA f -> FORMULA f -> Bool
$c== :: forall f. Eq f => FORMULA f -> FORMULA f -> Bool
Eq, Eq (FORMULA f)
Eq (FORMULA f) =>
(FORMULA f -> FORMULA f -> Ordering)
-> (FORMULA f -> FORMULA f -> Bool)
-> (FORMULA f -> FORMULA f -> Bool)
-> (FORMULA f -> FORMULA f -> Bool)
-> (FORMULA f -> FORMULA f -> Bool)
-> (FORMULA f -> FORMULA f -> FORMULA f)
-> (FORMULA f -> FORMULA f -> FORMULA f)
-> Ord (FORMULA f)
FORMULA f -> FORMULA f -> Bool
FORMULA f -> FORMULA f -> Ordering
FORMULA f -> FORMULA f -> FORMULA f
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall f. Ord f => Eq (FORMULA f)
forall f. Ord f => FORMULA f -> FORMULA f -> Bool
forall f. Ord f => FORMULA f -> FORMULA f -> Ordering
forall f. Ord f => FORMULA f -> FORMULA f -> FORMULA f
min :: FORMULA f -> FORMULA f -> FORMULA f
$cmin :: forall f. Ord f => FORMULA f -> FORMULA f -> FORMULA f
max :: FORMULA f -> FORMULA f -> FORMULA f
$cmax :: forall f. Ord f => FORMULA f -> FORMULA f -> FORMULA f
>= :: FORMULA f -> FORMULA f -> Bool
$c>= :: forall f. Ord f => FORMULA f -> FORMULA f -> Bool
> :: FORMULA f -> FORMULA f -> Bool
$c> :: forall f. Ord f => FORMULA f -> FORMULA f -> Bool
<= :: FORMULA f -> FORMULA f -> Bool
$c<= :: forall f. Ord f => FORMULA f -> FORMULA f -> Bool
< :: FORMULA f -> FORMULA f -> Bool
$c< :: forall f. Ord f => FORMULA f -> FORMULA f -> Bool
compare :: FORMULA f -> FORMULA f -> Ordering
$ccompare :: forall f. Ord f => FORMULA f -> FORMULA f -> Ordering
$cp1Ord :: forall f. Ord f => Eq (FORMULA f)
Ord, Typeable, Typeable (FORMULA f)
Constr
DataType
Typeable (FORMULA f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FORMULA f -> c (FORMULA f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FORMULA f))
-> (FORMULA f -> Constr)
-> (FORMULA f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FORMULA f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FORMULA f)))
-> ((forall b. Data b => b -> b) -> FORMULA f -> FORMULA f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FORMULA f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FORMULA f -> r)
-> (forall u. (forall d. Data d => d -> u) -> FORMULA f -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FORMULA f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f))
-> Data (FORMULA f)
FORMULA f -> Constr
FORMULA f -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (FORMULA f))
(forall b. Data b => b -> b) -> FORMULA f -> FORMULA f
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FORMULA f -> c (FORMULA f)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FORMULA f)
forall f. Data f => Typeable (FORMULA f)
forall f. Data f => FORMULA f -> Constr
forall f. Data f => FORMULA f -> DataType
forall f.
Data f =>
(forall b. Data b => b -> b) -> FORMULA f -> FORMULA f
forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> FORMULA f -> u
forall f u.
Data f =>
(forall d. Data d => d -> u) -> FORMULA f -> [u]
forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FORMULA f)
forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FORMULA f -> c (FORMULA f)
forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FORMULA f))
forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FORMULA f))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FORMULA f -> u
forall u. (forall d. Data d => d -> u) -> FORMULA f -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FORMULA f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FORMULA f -> c (FORMULA f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FORMULA f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FORMULA f))
$cExtFORMULA :: Constr
$cQuantPred :: Constr
$cQuantOp :: Constr
$cSort_gen_ax :: Constr
$cUnparsed_formula :: Constr
$cMixfix_formula :: Constr
$cMembership :: Constr
$cEquation :: Constr
$cDefinedness :: Constr
$cPredication :: Constr
$cAtom :: Constr
$cNegation :: Constr
$cRelation :: Constr
$cJunction :: Constr
$cQuantification :: Constr
$tFORMULA :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
$cgmapMo :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
gmapMp :: (forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
$cgmapMp :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
gmapM :: (forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
$cgmapM :: forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> FORMULA f -> m (FORMULA f)
gmapQi :: Int -> (forall d. Data d => d -> u) -> FORMULA f -> u
$cgmapQi :: forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> FORMULA f -> u
gmapQ :: (forall d. Data d => d -> u) -> FORMULA f -> [u]
$cgmapQ :: forall f u.
Data f =>
(forall d. Data d => d -> u) -> FORMULA f -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
$cgmapQr :: forall f r r'.
Data f =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
$cgmapQl :: forall f r r'.
Data f =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FORMULA f -> r
gmapT :: (forall b. Data b => b -> b) -> FORMULA f -> FORMULA f
$cgmapT :: forall f.
Data f =>
(forall b. Data b => b -> b) -> FORMULA f -> FORMULA f
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FORMULA f))
$cdataCast2 :: forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (FORMULA f))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (FORMULA f))
$cdataCast1 :: forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FORMULA f))
dataTypeOf :: FORMULA f -> DataType
$cdataTypeOf :: forall f. Data f => FORMULA f -> DataType
toConstr :: FORMULA f -> Constr
$ctoConstr :: forall f. Data f => FORMULA f -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FORMULA f)
$cgunfold :: forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FORMULA f)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FORMULA f -> c (FORMULA f)
$cgfoldl :: forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FORMULA f -> c (FORMULA f)
$cp1Data :: forall f. Data f => Typeable (FORMULA f)
Data)

mkSort_gen_ax :: [Constraint] -> Bool -> FORMULA f
mkSort_gen_ax :: [Constraint] -> Bool -> FORMULA f
mkSort_gen_ax = [Constraint] -> Bool -> FORMULA f
forall f. [Constraint] -> Bool -> FORMULA f
Sort_gen_ax ([Constraint] -> Bool -> FORMULA f)
-> ([Constraint] -> [Constraint])
-> [Constraint]
-> Bool
-> FORMULA f
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Constraint] -> [Constraint]
sortConstraints

is_True_atom :: FORMULA f -> Bool
is_True_atom :: FORMULA f -> Bool
is_True_atom f :: FORMULA f
f = case FORMULA f
f of
  Atom b :: Bool
b _ -> Bool
b
  _ -> Bool
False

is_False_atom :: FORMULA f -> Bool
is_False_atom :: FORMULA f -> Bool
is_False_atom f :: FORMULA f
f = case FORMULA f
f of
  Atom b :: Bool
b _ -> Bool -> Bool
not Bool
b
  _ -> Bool
False

boolForm :: Bool -> FORMULA f
boolForm :: Bool -> FORMULA f
boolForm b :: Bool
b = Bool -> Range -> FORMULA f
forall f. Bool -> Range -> FORMULA f
Atom Bool
b Range
nullRange

trueForm :: FORMULA f
trueForm :: FORMULA f
trueForm = Bool -> FORMULA f
forall f. Bool -> FORMULA f
boolForm Bool
True

falseForm :: FORMULA f
falseForm :: FORMULA f
falseForm = Bool -> FORMULA f
forall f. Bool -> FORMULA f
boolForm Bool
False

{- In the CASL institution, sort generation constraints have an
additional signature morphism component (Sect. III:2.1.3, p.134 of the
CASL Reference Manual).  The extra signature morphism component is
needed because the naive translation of sort generation constraints
along signature morphisms may violate the satisfaction condition,
namely when sorts are identified by the translation, with the effect
that new terms can be formed. We avoid this extra component here and
instead use natural numbers to decorate sorts, in this way retaining
their identity w.r.t. the original signature. The newSort in a
Constraint is implicitly decorated with its index in the list of
Constraints. The opSymbs component collects all the operation symbols
with newSort (with that index!) as a result sort. The argument sorts
of an operation symbol are decorated explicitly via a list [Int] of
integers. The origSort in a Constraint is the original sort
corresponding to the index.  A negative index indicates a sort outside
the constraint (i.e. a "parameter sort"). Note that this representation of
sort generation constraints is efficiently tailored towards both the use in
the proof calculus (Chap. IV:2, p. 282 of the CASL Reference Manual)
and the coding into second order logic (p. 429 of Theoret. Comp. Sci. 286).
-}

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

instance Ord Constraint where
  compare :: Constraint -> Constraint -> Ordering
compare (Constraint s1 :: SORT
s1 cs1 :: [(OP_SYMB, [Int])]
cs1 _) (Constraint s2 :: SORT
s2 cs2 :: [(OP_SYMB, [Int])]
cs2 _) =
      (SORT, [OP_SYMB]) -> (SORT, [OP_SYMB]) -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (SORT
s1, ((OP_SYMB, [Int]) -> OP_SYMB) -> [(OP_SYMB, [Int])] -> [OP_SYMB]
forall a b. (a -> b) -> [a] -> [b]
map (OP_SYMB, [Int]) -> OP_SYMB
forall a b. (a, b) -> a
fst [(OP_SYMB, [Int])]
cs1) (SORT
s2, ((OP_SYMB, [Int]) -> OP_SYMB) -> [(OP_SYMB, [Int])] -> [OP_SYMB]
forall a b. (a -> b) -> [a] -> [b]
map (OP_SYMB, [Int]) -> OP_SYMB
forall a b. (a, b) -> a
fst [(OP_SYMB, [Int])]
cs2)

instance Eq Constraint where
  a :: Constraint
a == :: Constraint -> Constraint -> Bool
== b :: Constraint
b = Constraint -> Constraint -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Constraint
a Constraint
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ

sortConstraints :: [Constraint] -> [Constraint]
sortConstraints :: [Constraint] -> [Constraint]
sortConstraints cs :: [Constraint]
cs = let
  nCs :: [Constraint]
nCs = [Constraint] -> [Constraint]
forall a. Ord a => [a] -> [a]
sort [Constraint]
cs
  iS :: [Int]
iS = (Constraint -> Int) -> [Constraint] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map(\ c :: Constraint
c -> let
               Just j :: Int
j = (Constraint -> Bool) -> [Constraint] -> Maybe Int
forall a. (a -> Bool) -> [a] -> Maybe Int
findIndex ((Constraint -> SORT
origSort Constraint
c SORT -> SORT -> Bool
forall a. Eq a => a -> a -> Bool
==) (SORT -> Bool) -> (Constraint -> SORT) -> Constraint -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Constraint -> SORT
origSort) [Constraint]
nCs in Int
j) [Constraint]
cs
  updInd :: Int -> Int
updInd i :: Int
i = if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 then Int
i else [Int]
iS [Int] -> Int -> Int
forall a. [a] -> Int -> a
!! Int
i
  in
  (Constraint -> Constraint) -> [Constraint] -> [Constraint]
forall a b. (a -> b) -> [a] -> [b]
map (\ (Constraint s :: SORT
s os :: [(OP_SYMB, [Int])]
os o :: SORT
o) ->
    SORT -> [(OP_SYMB, [Int])] -> SORT -> Constraint
Constraint SORT
s (((OP_SYMB, [Int]) -> (OP_SYMB, [Int]) -> Ordering)
-> [(OP_SYMB, [Int])] -> [(OP_SYMB, [Int])]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy ((OP_SYMB -> OP_SYMB -> Ordering)
-> ((OP_SYMB, [Int]) -> OP_SYMB)
-> (OP_SYMB, [Int])
-> (OP_SYMB, [Int])
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on OP_SYMB -> OP_SYMB -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (OP_SYMB, [Int]) -> OP_SYMB
forall a b. (a, b) -> a
fst)
                 ([(OP_SYMB, [Int])] -> [(OP_SYMB, [Int])])
-> [(OP_SYMB, [Int])] -> [(OP_SYMB, [Int])]
forall a b. (a -> b) -> a -> b
$ ((OP_SYMB, [Int]) -> (OP_SYMB, [Int]))
-> [(OP_SYMB, [Int])] -> [(OP_SYMB, [Int])]
forall a b. (a -> b) -> [a] -> [b]
map (\ (c :: OP_SYMB
c, is :: [Int]
is) -> (OP_SYMB
c, (Int -> Int) -> [Int] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Int
updInd [Int]
is)) [(OP_SYMB, [Int])]
os) SORT
o) [Constraint]
nCs

-- | no duplicate sorts, i.e. injective sort map?
isInjectiveList :: Ord a => [a] -> Bool
isInjectiveList :: [a] -> Bool
isInjectiveList l :: [a]
l = Set a -> Int
forall a. Set a -> Int
Set.size ([a] -> Set a
forall a. Ord a => [a] -> Set a
Set.fromList [a]
l) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
l

{- | from a Sort_gex_ax, recover:
a traditional sort generation constraint plus a sort mapping -}
recover_Sort_gen_ax :: [Constraint] ->
                        ([SORT], [OP_SYMB], [(SORT, SORT)])
recover_Sort_gen_ax :: [Constraint] -> ([SORT], [OP_SYMB], [(SORT, SORT)])
recover_Sort_gen_ax constrs :: [Constraint]
constrs =
  if [SORT] -> Bool
forall a. Ord a => [a] -> Bool
isInjectiveList [SORT]
sorts
     -- we can ignore indices
  then ([SORT]
sorts, ((OP_SYMB, [Int]) -> OP_SYMB) -> [(OP_SYMB, [Int])] -> [OP_SYMB]
forall a b. (a -> b) -> [a] -> [b]
map (OP_SYMB, [Int]) -> OP_SYMB
forall a b. (a, b) -> a
fst ((Constraint -> [(OP_SYMB, [Int])])
-> [Constraint] -> [(OP_SYMB, [Int])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Constraint -> [(OP_SYMB, [Int])]
opSymbs [Constraint]
constrs), [])
     {- otherwise, we have to introduce new sorts for the indices
     and afterwards rename them into the sorts they denote -}
  else ([SORT]
origSorts, [OP_SYMB]
indOps, [SORT] -> [SORT] -> [(SORT, SORT)]
forall a b. [a] -> [b] -> [(a, b)]
zip [SORT]
origSorts [SORT]
sorts)
  where
  sorts :: [SORT]
sorts = (Constraint -> SORT) -> [Constraint] -> [SORT]
forall a b. (a -> b) -> [a] -> [b]
map Constraint -> SORT
newSort [Constraint]
constrs
  origSorts :: [SORT]
origSorts = (Constraint -> SORT) -> [Constraint] -> [SORT]
forall a b. (a -> b) -> [a] -> [b]
map Constraint -> SORT
origSort [Constraint]
constrs
  indSort :: SORT -> Int -> SORT
indSort s :: SORT
s i :: Int
i = if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 then SORT
s else [SORT]
origSorts [SORT] -> Int -> SORT
forall a. [a] -> Int -> a
!! Int
i
  indOps :: [OP_SYMB]
indOps = (Constraint -> [OP_SYMB]) -> [Constraint] -> [OP_SYMB]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\ c :: Constraint
c -> ((OP_SYMB, [Int]) -> OP_SYMB) -> [(OP_SYMB, [Int])] -> [OP_SYMB]
forall a b. (a -> b) -> [a] -> [b]
map (SORT -> (OP_SYMB, [Int]) -> OP_SYMB
indOp (SORT -> (OP_SYMB, [Int]) -> OP_SYMB)
-> SORT -> (OP_SYMB, [Int]) -> OP_SYMB
forall a b. (a -> b) -> a -> b
$ Constraint -> SORT
origSort Constraint
c) ([(OP_SYMB, [Int])] -> [OP_SYMB])
-> [(OP_SYMB, [Int])] -> [OP_SYMB]
forall a b. (a -> b) -> a -> b
$ Constraint -> [(OP_SYMB, [Int])]
opSymbs Constraint
c) [Constraint]
constrs
  indOp :: SORT -> (OP_SYMB, [Int]) -> OP_SYMB
indOp res :: SORT
res (Qual_op_name opn :: SORT
opn (Op_type k :: OpKind
k args1 :: [SORT]
args1 _ pos1 :: Range
pos1) pos :: Range
pos, args :: [Int]
args) =
     SORT -> OP_TYPE -> Range -> OP_SYMB
Qual_op_name SORT
opn
         (OpKind -> [SORT] -> SORT -> Range -> OP_TYPE
Op_type OpKind
k ((SORT -> Int -> SORT) -> [SORT] -> [Int] -> [SORT]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith SORT -> Int -> SORT
indSort [SORT]
args1 [Int]
args) SORT
res Range
pos1) Range
pos
  indOp _ _ = String -> OP_SYMB
forall a. HasCallStack => String -> a
error
      "CASL/AS_Basic_CASL: Internal error: Unqualified OP_SYMB in Sort_gen_ax"

{- | from a Sort_gen_ax, recover:
the sorts, each paired with the constructors -}
recoverSortGen :: [Constraint] -> [(SORT, [OP_SYMB])]
recoverSortGen :: [Constraint] -> [(SORT, [OP_SYMB])]
recoverSortGen = (Constraint -> (SORT, [OP_SYMB]))
-> [Constraint] -> [(SORT, [OP_SYMB])]
forall a b. (a -> b) -> [a] -> [b]
map ((Constraint -> (SORT, [OP_SYMB]))
 -> [Constraint] -> [(SORT, [OP_SYMB])])
-> (Constraint -> (SORT, [OP_SYMB]))
-> [Constraint]
-> [(SORT, [OP_SYMB])]
forall a b. (a -> b) -> a -> b
$ \ c :: Constraint
c -> (Constraint -> SORT
newSort Constraint
c, ((OP_SYMB, [Int]) -> OP_SYMB) -> [(OP_SYMB, [Int])] -> [OP_SYMB]
forall a b. (a -> b) -> [a] -> [b]
map (OP_SYMB, [Int]) -> OP_SYMB
forall a b. (a, b) -> a
fst ([(OP_SYMB, [Int])] -> [OP_SYMB])
-> [(OP_SYMB, [Int])] -> [OP_SYMB]
forall a b. (a -> b) -> a -> b
$ Constraint -> [(OP_SYMB, [Int])]
opSymbs Constraint
c)

{- | from a free Sort_gen_ax, recover:
the sorts, each paired with the constructors
fails (i.e. delivers Nothing) if the sort map is not injective -}
recover_free_Sort_gen_ax :: [Constraint] -> Maybe [(SORT, [OP_SYMB])]
recover_free_Sort_gen_ax :: [Constraint] -> Maybe [(SORT, [OP_SYMB])]
recover_free_Sort_gen_ax constrs :: [Constraint]
constrs =
  if [SORT] -> Bool
forall a. Ord a => [a] -> Bool
isInjectiveList ([SORT] -> Bool) -> [SORT] -> Bool
forall a b. (a -> b) -> a -> b
$ (Constraint -> SORT) -> [Constraint] -> [SORT]
forall a b. (a -> b) -> [a] -> [b]
map Constraint -> SORT
newSort [Constraint]
constrs
     then [(SORT, [OP_SYMB])] -> Maybe [(SORT, [OP_SYMB])]
forall a. a -> Maybe a
Just ([(SORT, [OP_SYMB])] -> Maybe [(SORT, [OP_SYMB])])
-> [(SORT, [OP_SYMB])] -> Maybe [(SORT, [OP_SYMB])]
forall a b. (a -> b) -> a -> b
$ [Constraint] -> [(SORT, [OP_SYMB])]
recoverSortGen [Constraint]
constrs
     else Maybe [(SORT, [OP_SYMB])]
forall a. Maybe a
Nothing

-- | determine whether a formula is a sort generation constraint
isSortGen :: FORMULA f -> Bool
isSortGen :: FORMULA f -> Bool
isSortGen f :: FORMULA f
f = case FORMULA f
f of
  Sort_gen_ax _ _ -> Bool
True
  _ -> Bool
False

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

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

predSymbName :: PRED_SYMB -> PRED_NAME
predSymbName :: PRED_SYMB -> SORT
predSymbName p :: PRED_SYMB
p = case PRED_SYMB
p of
  Pred_name n :: SORT
n -> SORT
n
  Qual_pred_name n :: SORT
n _ _ -> SORT
n

data TERM f = Qual_var VAR SORT Range -- pos: "(", var, colon, ")"
          | Application OP_SYMB [TERM f] Range
            -- pos: parens around TERM f if any and seperating commas
          | Sorted_term (TERM f) SORT Range
            -- pos: colon
          | Cast (TERM f) SORT Range
            -- pos: "as"
          | Conditional (TERM f) (FORMULA f) (TERM f) Range
            -- pos: "when", "else"
          | Unparsed_term String Range        -- SML-CATS

          -- A new intermediate state
          | Mixfix_qual_pred PRED_SYMB -- as part of a mixfix formula
          | Mixfix_term [TERM f]  -- not starting with Mixfix_sorted_term/cast
          | Mixfix_token Token   -- NO-BRACKET-TOKEN, LITERAL, PLACE
          | Mixfix_sorted_term SORT Range
            -- pos: colon
          | Mixfix_cast SORT Range
            -- pos: "as"
          | Mixfix_parenthesized [TERM f] Range
            {- non-emtpy term list
            pos: "(", commas, ")" -}
          | Mixfix_bracketed [TERM f] Range
            -- pos: "[", commas, "]"
          | Mixfix_braced [TERM f] Range
            {- also for list-notation
            pos: "{", "}" -}
          | ExtTERM f
            deriving (Int -> TERM f -> ShowS
[TERM f] -> ShowS
TERM f -> String
(Int -> TERM f -> ShowS)
-> (TERM f -> String) -> ([TERM f] -> ShowS) -> Show (TERM f)
forall f. Show f => Int -> TERM f -> ShowS
forall f. Show f => [TERM f] -> ShowS
forall f. Show f => TERM f -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TERM f] -> ShowS
$cshowList :: forall f. Show f => [TERM f] -> ShowS
show :: TERM f -> String
$cshow :: forall f. Show f => TERM f -> String
showsPrec :: Int -> TERM f -> ShowS
$cshowsPrec :: forall f. Show f => Int -> TERM f -> ShowS
Show, TERM f -> TERM f -> Bool
(TERM f -> TERM f -> Bool)
-> (TERM f -> TERM f -> Bool) -> Eq (TERM f)
forall f. Eq f => TERM f -> TERM f -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TERM f -> TERM f -> Bool
$c/= :: forall f. Eq f => TERM f -> TERM f -> Bool
== :: TERM f -> TERM f -> Bool
$c== :: forall f. Eq f => TERM f -> TERM f -> Bool
Eq, Eq (TERM f)
Eq (TERM f) =>
(TERM f -> TERM f -> Ordering)
-> (TERM f -> TERM f -> Bool)
-> (TERM f -> TERM f -> Bool)
-> (TERM f -> TERM f -> Bool)
-> (TERM f -> TERM f -> Bool)
-> (TERM f -> TERM f -> TERM f)
-> (TERM f -> TERM f -> TERM f)
-> Ord (TERM f)
TERM f -> TERM f -> Bool
TERM f -> TERM f -> Ordering
TERM f -> TERM f -> TERM f
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall f. Ord f => Eq (TERM f)
forall f. Ord f => TERM f -> TERM f -> Bool
forall f. Ord f => TERM f -> TERM f -> Ordering
forall f. Ord f => TERM f -> TERM f -> TERM f
min :: TERM f -> TERM f -> TERM f
$cmin :: forall f. Ord f => TERM f -> TERM f -> TERM f
max :: TERM f -> TERM f -> TERM f
$cmax :: forall f. Ord f => TERM f -> TERM f -> TERM f
>= :: TERM f -> TERM f -> Bool
$c>= :: forall f. Ord f => TERM f -> TERM f -> Bool
> :: TERM f -> TERM f -> Bool
$c> :: forall f. Ord f => TERM f -> TERM f -> Bool
<= :: TERM f -> TERM f -> Bool
$c<= :: forall f. Ord f => TERM f -> TERM f -> Bool
< :: TERM f -> TERM f -> Bool
$c< :: forall f. Ord f => TERM f -> TERM f -> Bool
compare :: TERM f -> TERM f -> Ordering
$ccompare :: forall f. Ord f => TERM f -> TERM f -> Ordering
$cp1Ord :: forall f. Ord f => Eq (TERM f)
Ord, Typeable, Typeable (TERM f)
Constr
DataType
Typeable (TERM f) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TERM f -> c (TERM f))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TERM f))
-> (TERM f -> Constr)
-> (TERM f -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TERM f)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TERM f)))
-> ((forall b. Data b => b -> b) -> TERM f -> TERM f)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TERM f -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TERM f -> r)
-> (forall u. (forall d. Data d => d -> u) -> TERM f -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TERM f -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TERM f -> m (TERM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TERM f -> m (TERM f))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TERM f -> m (TERM f))
-> Data (TERM f)
TERM f -> Constr
TERM f -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (TERM f))
(forall b. Data b => b -> b) -> TERM f -> TERM f
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TERM f -> c (TERM f)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TERM f)
forall f. Data f => Typeable (TERM f)
forall f. Data f => TERM f -> Constr
forall f. Data f => TERM f -> DataType
forall f.
Data f =>
(forall b. Data b => b -> b) -> TERM f -> TERM f
forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> TERM f -> u
forall f u. Data f => (forall d. Data d => d -> u) -> TERM f -> [u]
forall f r r'.
Data f =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
forall f r r'.
Data f =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TERM f)
forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TERM f -> c (TERM f)
forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TERM f))
forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TERM f))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TERM f -> u
forall u. (forall d. Data d => d -> u) -> TERM f -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TERM f)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TERM f -> c (TERM f)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TERM f))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TERM f))
$cExtTERM :: Constr
$cMixfix_braced :: Constr
$cMixfix_bracketed :: Constr
$cMixfix_parenthesized :: Constr
$cMixfix_cast :: Constr
$cMixfix_sorted_term :: Constr
$cMixfix_token :: Constr
$cMixfix_term :: Constr
$cMixfix_qual_pred :: Constr
$cUnparsed_term :: Constr
$cConditional :: Constr
$cCast :: Constr
$cSorted_term :: Constr
$cApplication :: Constr
$cQual_var :: Constr
$tTERM :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
$cgmapMo :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
gmapMp :: (forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
$cgmapMp :: forall f (m :: * -> *).
(Data f, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
gmapM :: (forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
$cgmapM :: forall f (m :: * -> *).
(Data f, Monad m) =>
(forall d. Data d => d -> m d) -> TERM f -> m (TERM f)
gmapQi :: Int -> (forall d. Data d => d -> u) -> TERM f -> u
$cgmapQi :: forall f u.
Data f =>
Int -> (forall d. Data d => d -> u) -> TERM f -> u
gmapQ :: (forall d. Data d => d -> u) -> TERM f -> [u]
$cgmapQ :: forall f u. Data f => (forall d. Data d => d -> u) -> TERM f -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
$cgmapQr :: forall f r r'.
Data f =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
$cgmapQl :: forall f r r'.
Data f =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TERM f -> r
gmapT :: (forall b. Data b => b -> b) -> TERM f -> TERM f
$cgmapT :: forall f.
Data f =>
(forall b. Data b => b -> b) -> TERM f -> TERM f
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TERM f))
$cdataCast2 :: forall f (t :: * -> * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TERM f))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (TERM f))
$cdataCast1 :: forall f (t :: * -> *) (c :: * -> *).
(Data f, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TERM f))
dataTypeOf :: TERM f -> DataType
$cdataTypeOf :: forall f. Data f => TERM f -> DataType
toConstr :: TERM f -> Constr
$ctoConstr :: forall f. Data f => TERM f -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TERM f)
$cgunfold :: forall f (c :: * -> *).
Data f =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TERM f)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TERM f -> c (TERM f)
$cgfoldl :: forall f (c :: * -> *).
Data f =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TERM f -> c (TERM f)
$cp1Data :: forall f. Data f => Typeable (TERM f)
Data)

-- | state after mixfix- but before overload resolution
varOrConst :: Token -> TERM f
varOrConst :: VAR -> TERM f
varOrConst t :: VAR
t = OP_SYMB -> [TERM f] -> Range -> TERM f
forall f. OP_SYMB -> [TERM f] -> Range -> TERM f
Application (SORT -> OP_SYMB
Op_name (SORT -> OP_SYMB) -> SORT -> OP_SYMB
forall a b. (a -> b) -> a -> b
$ VAR -> SORT
simpleIdToId VAR
t) [] (Range -> TERM f) -> Range -> TERM f
forall a b. (a -> b) -> a -> b
$ VAR -> Range
tokPos VAR
t

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

opSymbName :: OP_SYMB -> OP_NAME
opSymbName :: OP_SYMB -> SORT
opSymbName o :: OP_SYMB
o = case OP_SYMB
o of
  Op_name n :: SORT
n -> SORT
n
  Qual_op_name n :: SORT
n _ _ -> SORT
n

-- * short cuts for terms and formulas

-- | create binding if variables are non-null
mkForallRange :: [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
mkForallRange :: [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
mkForallRange vl :: [VAR_DECL]
vl f :: FORMULA f
f ps :: Range
ps =
  if [VAR_DECL] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [VAR_DECL]
vl then FORMULA f
f else QUANTIFIER -> [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
forall f.
QUANTIFIER -> [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
Quantification QUANTIFIER
Universal [VAR_DECL]
vl FORMULA f
f Range
ps

mkForall :: [VAR_DECL] -> FORMULA f -> FORMULA f
mkForall :: [VAR_DECL] -> FORMULA f -> FORMULA f
mkForall vl :: [VAR_DECL]
vl f :: FORMULA f
f = [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
forall f. [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
mkForallRange [VAR_DECL]
vl FORMULA f
f Range
nullRange

-- | create an existential binding
mkExist :: [VAR_DECL] -> FORMULA f -> FORMULA f
mkExist :: [VAR_DECL] -> FORMULA f -> FORMULA f
mkExist vs :: [VAR_DECL]
vs f :: FORMULA f
f = QUANTIFIER -> [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
forall f.
QUANTIFIER -> [VAR_DECL] -> FORMULA f -> Range -> FORMULA f
Quantification QUANTIFIER
Existential [VAR_DECL]
vs FORMULA f
f Range
nullRange

-- | convert a singleton variable declaration into a qualified variable
toQualVar :: VAR_DECL -> TERM f
toQualVar :: VAR_DECL -> TERM f
toQualVar (Var_decl v :: [VAR]
v s :: SORT
s ps :: Range
ps) =
    if [VAR] -> Bool
forall a. [a] -> Bool
isSingle [VAR]
v then VAR -> SORT -> Range -> TERM f
forall f. VAR -> SORT -> Range -> TERM f
Qual_var ([VAR] -> VAR
forall a. [a] -> a
head [VAR]
v) SORT
s Range
ps else String -> TERM f
forall a. HasCallStack => String -> a
error "toQualVar"

mkRel :: Relation -> FORMULA f -> FORMULA f -> FORMULA f
mkRel :: Relation -> FORMULA f -> FORMULA f -> FORMULA f
mkRel r :: Relation
r f :: FORMULA f
f f' :: FORMULA f
f' = FORMULA f -> Relation -> FORMULA f -> Range -> FORMULA f
forall f. FORMULA f -> Relation -> FORMULA f -> Range -> FORMULA f
Relation FORMULA f
f Relation
r FORMULA f
f' Range
nullRange

mkImpl :: FORMULA f -> FORMULA f -> FORMULA f
mkImpl :: FORMULA f -> FORMULA f -> FORMULA f
mkImpl = Relation -> FORMULA f -> FORMULA f -> FORMULA f
forall f. Relation -> FORMULA f -> FORMULA f -> FORMULA f
mkRel Relation
Implication

mkAnyEq :: Equality -> TERM f -> TERM f -> FORMULA f
mkAnyEq :: Equality -> TERM f -> TERM f -> FORMULA f
mkAnyEq e :: Equality
e f :: TERM f
f f' :: TERM f
f' = TERM f -> Equality -> TERM f -> Range -> FORMULA f
forall f. TERM f -> Equality -> TERM f -> Range -> FORMULA f
Equation TERM f
f Equality
e TERM f
f' Range
nullRange

mkExEq :: TERM f -> TERM f -> FORMULA f
mkExEq :: TERM f -> TERM f -> FORMULA f
mkExEq = Equality -> TERM f -> TERM f -> FORMULA f
forall f. Equality -> TERM f -> TERM f -> FORMULA f
mkAnyEq Equality
Existl

mkStEq :: TERM f -> TERM f -> FORMULA f
mkStEq :: TERM f -> TERM f -> FORMULA f
mkStEq = Equality -> TERM f -> TERM f -> FORMULA f
forall f. Equality -> TERM f -> TERM f -> FORMULA f
mkAnyEq Equality
Strong

mkEqv :: FORMULA f -> FORMULA f -> FORMULA f
mkEqv :: FORMULA f -> FORMULA f -> FORMULA f
mkEqv = Relation -> FORMULA f -> FORMULA f -> FORMULA f
forall f. Relation -> FORMULA f -> FORMULA f -> FORMULA f
mkRel Relation
Equivalence

mkAppl :: OP_SYMB -> [TERM f] -> TERM f
mkAppl :: OP_SYMB -> [TERM f] -> TERM f
mkAppl op_symb :: OP_SYMB
op_symb fs :: [TERM f]
fs = OP_SYMB -> [TERM f] -> Range -> TERM f
forall f. OP_SYMB -> [TERM f] -> Range -> TERM f
Application OP_SYMB
op_symb [TERM f]
fs Range
nullRange

mkPredication :: PRED_SYMB -> [TERM f] -> FORMULA f
mkPredication :: PRED_SYMB -> [TERM f] -> FORMULA f
mkPredication symb :: PRED_SYMB
symb fs :: [TERM f]
fs = PRED_SYMB -> [TERM f] -> Range -> FORMULA f
forall f. PRED_SYMB -> [TERM f] -> Range -> FORMULA f
Predication PRED_SYMB
symb [TERM f]
fs Range
nullRange

-- | turn sorted variable into variable delcaration
mkVarDecl :: VAR -> SORT -> VAR_DECL
mkVarDecl :: VAR -> SORT -> VAR_DECL
mkVarDecl v :: VAR
v s :: SORT
s = [VAR] -> SORT -> Range -> VAR_DECL
Var_decl [VAR
v] SORT
s Range
nullRange

-- | turn sorted variable into term
mkVarTerm :: VAR -> SORT -> TERM f
mkVarTerm :: VAR -> SORT -> TERM f
mkVarTerm v :: VAR
v = VAR_DECL -> TERM f
forall f. VAR_DECL -> TERM f
toQualVar (VAR_DECL -> TERM f) -> (SORT -> VAR_DECL) -> SORT -> TERM f
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VAR -> SORT -> VAR_DECL
mkVarDecl VAR
v

-- | optimized conjunction
conjunctRange :: [FORMULA f] -> Range -> FORMULA f
conjunctRange :: [FORMULA f] -> Range -> FORMULA f
conjunctRange fs :: [FORMULA f]
fs ps :: Range
ps = case [FORMULA f]
fs of
  [] -> Bool -> Range -> FORMULA f
forall f. Bool -> Range -> FORMULA f
Atom Bool
True Range
ps
  [phi :: FORMULA f
phi] -> FORMULA f
phi
  _ -> Junctor -> [FORMULA f] -> Range -> FORMULA f
forall f. Junctor -> [FORMULA f] -> Range -> FORMULA f
Junction Junctor
Con [FORMULA f]
fs Range
ps

conjunct :: [FORMULA f] -> FORMULA f
conjunct :: [FORMULA f] -> FORMULA f
conjunct fs :: [FORMULA f]
fs = [FORMULA f] -> Range -> FORMULA f
forall f. [FORMULA f] -> Range -> FORMULA f
conjunctRange [FORMULA f]
fs Range
nullRange

disjunctRange :: [FORMULA f] -> Range -> FORMULA f
disjunctRange :: [FORMULA f] -> Range -> FORMULA f
disjunctRange fs :: [FORMULA f]
fs ps :: Range
ps = case [FORMULA f]
fs of
  [] -> Bool -> Range -> FORMULA f
forall f. Bool -> Range -> FORMULA f
Atom Bool
False Range
ps
  [phi :: FORMULA f
phi] -> FORMULA f
phi
  _ -> Junctor -> [FORMULA f] -> Range -> FORMULA f
forall f. Junctor -> [FORMULA f] -> Range -> FORMULA f
Junction Junctor
Dis [FORMULA f]
fs Range
ps

disjunct :: [FORMULA f] -> FORMULA f
disjunct :: [FORMULA f] -> FORMULA f
disjunct fs :: [FORMULA f]
fs = [FORMULA f] -> Range -> FORMULA f
forall f. [FORMULA f] -> Range -> FORMULA f
disjunctRange [FORMULA f]
fs Range
nullRange

mkQualOp :: OP_NAME -> OP_TYPE -> OP_SYMB
mkQualOp :: SORT -> OP_TYPE -> OP_SYMB
mkQualOp f :: SORT
f ty :: OP_TYPE
ty = SORT -> OP_TYPE -> Range -> OP_SYMB
Qual_op_name SORT
f OP_TYPE
ty Range
nullRange

mkQualPred :: PRED_NAME -> PRED_TYPE -> PRED_SYMB
mkQualPred :: SORT -> PRED_TYPE -> PRED_SYMB
mkQualPred f :: SORT
f ty :: PRED_TYPE
ty = SORT -> PRED_TYPE -> Range -> PRED_SYMB
Qual_pred_name SORT
f PRED_TYPE
ty Range
nullRange

negateForm :: FORMULA f -> Range -> FORMULA f
negateForm :: FORMULA f -> Range -> FORMULA f
negateForm f :: FORMULA f
f r :: Range
r = case FORMULA f
f of
  Atom b :: Bool
b ps :: Range
ps -> Bool -> Range -> FORMULA f
forall f. Bool -> Range -> FORMULA f
Atom (Bool -> Bool
not Bool
b) Range
ps
  Negation nf :: FORMULA f
nf _ -> FORMULA f
nf
  _ -> FORMULA f -> Range -> FORMULA f
forall f. FORMULA f -> Range -> FORMULA f
Negation FORMULA f
f Range
r

mkNeg :: FORMULA f -> FORMULA f
mkNeg :: FORMULA f -> FORMULA f
mkNeg f :: FORMULA f
f = FORMULA f -> Range -> FORMULA f
forall f. FORMULA f -> Range -> FORMULA f
negateForm FORMULA f
f Range
nullRange

mkVarDeclStr :: String -> SORT -> VAR_DECL
mkVarDeclStr :: String -> SORT -> VAR_DECL
mkVarDeclStr = VAR -> SORT -> VAR_DECL
mkVarDecl (VAR -> SORT -> VAR_DECL)
-> (String -> VAR) -> String -> SORT -> VAR_DECL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VAR
mkSimpleId

-- * type synonyms

type CASLFORMULA = FORMULA ()
type CASLTERM = TERM ()

type OP_NAME = Id
type PRED_NAME = Id
type SORT = Id
type VAR = Token

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

symbItemsName :: SYMB_ITEMS -> [String]
symbItemsName :: SYMB_ITEMS -> [String]
symbItemsName (Symb_items _ syms :: [SYMB]
syms _ ) =
 (SYMB -> String) -> [SYMB] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (\x :: SYMB
x -> case SYMB
x of 
                    Symb_id i :: SORT
i -> SORT -> String
forall a. Show a => a -> String
show SORT
i
                    Qual_id i :: SORT
i _ _ -> SORT -> String
forall a. Show a => a -> String
show SORT
i) [SYMB]
syms 

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

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

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

data TYPE = O_type OP_TYPE
          | P_type PRED_TYPE
          | A_type SORT -- ambiguous pred or (constant total) op
            deriving (Int -> TYPE -> ShowS
[TYPE] -> ShowS
TYPE -> String
(Int -> TYPE -> ShowS)
-> (TYPE -> String) -> ([TYPE] -> ShowS) -> Show TYPE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TYPE] -> ShowS
$cshowList :: [TYPE] -> ShowS
show :: TYPE -> String
$cshow :: TYPE -> String
showsPrec :: Int -> TYPE -> ShowS
$cshowsPrec :: Int -> TYPE -> ShowS
Show, TYPE -> TYPE -> Bool
(TYPE -> TYPE -> Bool) -> (TYPE -> TYPE -> Bool) -> Eq TYPE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TYPE -> TYPE -> Bool
$c/= :: TYPE -> TYPE -> Bool
== :: TYPE -> TYPE -> Bool
$c== :: TYPE -> TYPE -> Bool
Eq, Eq TYPE
Eq TYPE =>
(TYPE -> TYPE -> Ordering)
-> (TYPE -> TYPE -> Bool)
-> (TYPE -> TYPE -> Bool)
-> (TYPE -> TYPE -> Bool)
-> (TYPE -> TYPE -> Bool)
-> (TYPE -> TYPE -> TYPE)
-> (TYPE -> TYPE -> TYPE)
-> Ord TYPE
TYPE -> TYPE -> Bool
TYPE -> TYPE -> Ordering
TYPE -> TYPE -> TYPE
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TYPE -> TYPE -> TYPE
$cmin :: TYPE -> TYPE -> TYPE
max :: TYPE -> TYPE -> TYPE
$cmax :: TYPE -> TYPE -> TYPE
>= :: TYPE -> TYPE -> Bool
$c>= :: TYPE -> TYPE -> Bool
> :: TYPE -> TYPE -> Bool
$c> :: TYPE -> TYPE -> Bool
<= :: TYPE -> TYPE -> Bool
$c<= :: TYPE -> TYPE -> Bool
< :: TYPE -> TYPE -> Bool
$c< :: TYPE -> TYPE -> Bool
compare :: TYPE -> TYPE -> Ordering
$ccompare :: TYPE -> TYPE -> Ordering
$cp1Ord :: Eq TYPE
Ord, Typeable, Typeable TYPE
Constr
DataType
Typeable TYPE =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TYPE -> c TYPE)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TYPE)
-> (TYPE -> Constr)
-> (TYPE -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TYPE))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TYPE))
-> ((forall b. Data b => b -> b) -> TYPE -> TYPE)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r)
-> (forall u. (forall d. Data d => d -> u) -> TYPE -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TYPE -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TYPE -> m TYPE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TYPE -> m TYPE)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TYPE -> m TYPE)
-> Data TYPE
TYPE -> Constr
TYPE -> DataType
(forall b. Data b => b -> b) -> TYPE -> TYPE
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TYPE -> c TYPE
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TYPE
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TYPE -> u
forall u. (forall d. Data d => d -> u) -> TYPE -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TYPE -> m TYPE
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TYPE -> m TYPE
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TYPE
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TYPE -> c TYPE
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TYPE)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TYPE)
$cA_type :: Constr
$cP_type :: Constr
$cO_type :: Constr
$tTYPE :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TYPE -> m TYPE
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TYPE -> m TYPE
gmapMp :: (forall d. Data d => d -> m d) -> TYPE -> m TYPE
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TYPE -> m TYPE
gmapM :: (forall d. Data d => d -> m d) -> TYPE -> m TYPE
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TYPE -> m TYPE
gmapQi :: Int -> (forall d. Data d => d -> u) -> TYPE -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TYPE -> u
gmapQ :: (forall d. Data d => d -> u) -> TYPE -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TYPE -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TYPE -> r
gmapT :: (forall b. Data b => b -> b) -> TYPE -> TYPE
$cgmapT :: (forall b. Data b => b -> b) -> TYPE -> TYPE
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TYPE)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TYPE)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TYPE)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TYPE)
dataTypeOf :: TYPE -> DataType
$cdataTypeOf :: TYPE -> DataType
toConstr :: TYPE -> Constr
$ctoConstr :: TYPE -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TYPE
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TYPE
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TYPE -> c TYPE
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TYPE -> c TYPE
$cp1Data :: Typeable TYPE
Data)

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

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

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

instance (GetRange b, GetRange s,
          GetRange f) => GetRange (BASIC_ITEMS b s f) where
  getRange :: BASIC_ITEMS b s f -> Range
getRange x :: BASIC_ITEMS b s f
x = case BASIC_ITEMS b s f
x of
    Sig_items _ -> Range
nullRange
    Free_datatype _ _ p :: Range
p -> Range
p
    Sort_gen _ p :: Range
p -> Range
p
    Var_items _ p :: Range
p -> Range
p
    Local_var_axioms _ _ p :: Range
p -> Range
p
    Axiom_items _ p :: Range
p -> Range
p
    Ext_BASIC_ITEMS _ -> Range
nullRange
  rangeSpan :: BASIC_ITEMS b s f -> [Pos]
rangeSpan x :: BASIC_ITEMS b s f
x = case BASIC_ITEMS b s f
x of
    Sig_items a :: SIG_ITEMS s f
a -> [[Pos]] -> [Pos]
joinRanges [SIG_ITEMS s f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SIG_ITEMS s f
a]
    Free_datatype a :: SortsKind
a b :: [Annoted DATATYPE_DECL]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SortsKind -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SortsKind
a, [Annoted DATATYPE_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted DATATYPE_DECL]
b,
                                       Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Sort_gen a :: [Annoted (SIG_ITEMS s f)]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[Annoted (SIG_ITEMS s f)] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted (SIG_ITEMS s f)]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Var_items a :: [VAR_DECL]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[VAR_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [VAR_DECL]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Local_var_axioms a :: [VAR_DECL]
a b :: [Annoted (FORMULA f)]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [[VAR_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [VAR_DECL]
a, [Annoted (FORMULA f)] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted (FORMULA f)]
b,
                                          Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Axiom_items a :: [Annoted (FORMULA f)]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[Annoted (FORMULA f)] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted (FORMULA f)]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Ext_BASIC_ITEMS a :: b
a -> [[Pos]] -> [Pos]
joinRanges [b -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan b
a]

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

instance (GetRange s, GetRange f) => GetRange (SIG_ITEMS s f) where
  getRange :: SIG_ITEMS s f -> Range
getRange x :: SIG_ITEMS s f
x = case SIG_ITEMS s f
x of
    Sort_items _ _ p :: Range
p -> Range
p
    Op_items _ p :: Range
p -> Range
p
    Pred_items _ p :: Range
p -> Range
p
    Datatype_items _ _ p :: Range
p -> Range
p
    Ext_SIG_ITEMS _ -> Range
nullRange
  rangeSpan :: SIG_ITEMS s f -> [Pos]
rangeSpan x :: SIG_ITEMS s f
x = case SIG_ITEMS s f
x of
    Sort_items a :: SortsKind
a b :: [Annoted (SORT_ITEM f)]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SortsKind -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SortsKind
a, [Annoted (SORT_ITEM f)] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted (SORT_ITEM f)]
b,
                                    Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Op_items a :: [Annoted (OP_ITEM f)]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[Annoted (OP_ITEM f)] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted (OP_ITEM f)]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Pred_items a :: [Annoted (PRED_ITEM f)]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[Annoted (PRED_ITEM f)] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted (PRED_ITEM f)]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Datatype_items a :: SortsKind
a b :: [Annoted DATATYPE_DECL]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SortsKind -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SortsKind
a, [Annoted DATATYPE_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted DATATYPE_DECL]
b,
                                        Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Ext_SIG_ITEMS a :: s
a -> [[Pos]] -> [Pos]
joinRanges [s -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan s
a]

instance GetRange f => GetRange (SORT_ITEM f) where
  getRange :: SORT_ITEM f -> Range
getRange x :: SORT_ITEM f
x = case SORT_ITEM f
x of
    Sort_decl _ p :: Range
p -> Range
p
    Subsort_decl _ _ p :: Range
p -> Range
p
    Subsort_defn _ _ _ _ p :: Range
p -> Range
p
    Iso_decl _ p :: Range
p -> Range
p
  rangeSpan :: SORT_ITEM f -> [Pos]
rangeSpan x :: SORT_ITEM f
x = case SORT_ITEM f
x of
    Sort_decl a :: [SORT]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Subsort_decl a :: [SORT]
a b :: SORT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
b,
                                      Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Subsort_defn a :: SORT
a b :: VAR
b c :: SORT
c d :: Annoted (FORMULA f)
d e :: Range
e -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, VAR -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan VAR
b,
                                          SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
c, Annoted (FORMULA f) -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annoted (FORMULA f)
d, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
e]
    Iso_decl a :: [SORT]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange f => GetRange (OP_ITEM f) where
  getRange :: OP_ITEM f -> Range
getRange x :: OP_ITEM f
x = case OP_ITEM f
x of
    Op_decl _ _ _ p :: Range
p -> Range
p
    Op_defn _ _ _ p :: Range
p -> Range
p
  rangeSpan :: OP_ITEM f -> [Pos]
rangeSpan x :: OP_ITEM f
x = case OP_ITEM f
x of
    Op_decl a :: [SORT]
a b :: OP_TYPE
b c :: [OP_ATTR f]
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, OP_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OP_TYPE
b,
                                   [OP_ATTR f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [OP_ATTR f]
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Op_defn a :: SORT
a b :: OP_HEAD
b c :: Annoted (TERM f)
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, OP_HEAD -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OP_HEAD
b,
                                   Annoted (TERM f) -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annoted (TERM f)
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]

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

instance GetRange OP_TYPE where
  getRange :: OP_TYPE -> Range
getRange x :: OP_TYPE
x = case OP_TYPE
x of
    Op_type _ _ _ p :: Range
p -> Range
p
  rangeSpan :: OP_TYPE -> [Pos]
rangeSpan x :: OP_TYPE
x = case OP_TYPE
x of
    Op_type a :: OpKind
a b :: [SORT]
b c :: SORT
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [OpKind -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OpKind
a, [SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
b,
                                   SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]

instance GetRange OP_HEAD where
  getRange :: OP_HEAD -> Range
getRange x :: OP_HEAD
x = case OP_HEAD
x of
    Op_head _ _ _ p :: Range
p -> Range
p
  rangeSpan :: OP_HEAD -> [Pos]
rangeSpan x :: OP_HEAD
x = case OP_HEAD
x of
    Op_head a :: OpKind
a b :: [VAR_DECL]
b c :: Maybe SORT
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [OpKind -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OpKind
a, [VAR_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [VAR_DECL]
b,
                                   Maybe SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Maybe SORT
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]

instance GetRange f => GetRange (OP_ATTR f) where
  getRange :: OP_ATTR f -> Range
getRange = Range -> OP_ATTR f -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: OP_ATTR f -> [Pos]
rangeSpan x :: OP_ATTR f
x = case OP_ATTR f
x of
    Assoc_op_attr -> []
    Comm_op_attr -> []
    Idem_op_attr -> []
    Unit_op_attr a :: TERM f
a -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a]

instance GetRange f => GetRange (PRED_ITEM f) where
  getRange :: PRED_ITEM f -> Range
getRange x :: PRED_ITEM f
x = case PRED_ITEM f
x of
    Pred_decl _ _ p :: Range
p -> Range
p
    Pred_defn _ _ _ p :: Range
p -> Range
p
  rangeSpan :: PRED_ITEM f -> [Pos]
rangeSpan x :: PRED_ITEM f
x = case PRED_ITEM f
x of
    Pred_decl a :: [SORT]
a b :: PRED_TYPE
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, PRED_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_TYPE
b,
                                   Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Pred_defn a :: SORT
a b :: PRED_HEAD
b c :: Annoted (FORMULA f)
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, PRED_HEAD -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_HEAD
b,
                                     Annoted (FORMULA f) -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Annoted (FORMULA f)
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]

instance GetRange PRED_TYPE where
  getRange :: PRED_TYPE -> Range
getRange x :: PRED_TYPE
x = case PRED_TYPE
x of
    Pred_type _ p :: Range
p -> Range
p
  rangeSpan :: PRED_TYPE -> [Pos]
rangeSpan x :: PRED_TYPE
x = case PRED_TYPE
x of
    Pred_type a :: [SORT]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange PRED_HEAD where
  getRange :: PRED_HEAD -> Range
getRange x :: PRED_HEAD
x = case PRED_HEAD
x of
    Pred_head _ p :: Range
p -> Range
p
  rangeSpan :: PRED_HEAD -> [Pos]
rangeSpan x :: PRED_HEAD
x = case PRED_HEAD
x of
    Pred_head a :: [VAR_DECL]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[VAR_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [VAR_DECL]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange DATATYPE_DECL where
  getRange :: DATATYPE_DECL -> Range
getRange x :: DATATYPE_DECL
x = case DATATYPE_DECL
x of
    Datatype_decl _ _ p :: Range
p -> Range
p
  rangeSpan :: DATATYPE_DECL -> [Pos]
rangeSpan x :: DATATYPE_DECL
x = case DATATYPE_DECL
x of
    Datatype_decl a :: SORT
a b :: [Annoted ALTERNATIVE]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, [Annoted ALTERNATIVE] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted ALTERNATIVE]
b,
                                       Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

instance GetRange ALTERNATIVE where
  getRange :: ALTERNATIVE -> Range
getRange x :: ALTERNATIVE
x = case ALTERNATIVE
x of
    Alt_construct _ _ _ p :: Range
p -> Range
p
    Subsorts _ p :: Range
p -> Range
p
  rangeSpan :: ALTERNATIVE -> [Pos]
rangeSpan x :: ALTERNATIVE
x = case ALTERNATIVE
x of
    Alt_construct a :: OpKind
a b :: SORT
b c :: [COMPONENTS]
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [OpKind -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OpKind
a, SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
b,
                                         [COMPONENTS] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [COMPONENTS]
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Subsorts a :: [SORT]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange COMPONENTS where
  getRange :: COMPONENTS -> Range
getRange x :: COMPONENTS
x = case COMPONENTS
x of
    Cons_select _ _ _ p :: Range
p -> Range
p
    Sort _ -> Range
nullRange
  rangeSpan :: COMPONENTS -> [Pos]
rangeSpan x :: COMPONENTS
x = case COMPONENTS
x of
    Cons_select a :: OpKind
a b :: [SORT]
b c :: SORT
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [OpKind -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OpKind
a, [SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
b,
                                       SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Sort a :: SORT
a -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a]

instance GetRange VAR_DECL where
  getRange :: VAR_DECL -> Range
getRange x :: VAR_DECL
x = case VAR_DECL
x of
    Var_decl _ _ p :: Range
p -> Range
p
  rangeSpan :: VAR_DECL -> [Pos]
rangeSpan x :: VAR_DECL
x = case VAR_DECL
x of
    Var_decl a :: [VAR]
a b :: SORT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [[VAR] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [VAR]
a, SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
b,
                                  Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

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

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

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

instance GetRange f => GetRange (FORMULA f) where
  getRange :: FORMULA f -> Range
getRange x :: FORMULA f
x = case FORMULA f
x of
    Quantification _ _ _ p :: Range
p -> Range
p
    Junction _ _ p :: Range
p -> Range
p
    Relation _ _ _ p :: Range
p -> Range
p
    Negation _ p :: Range
p -> Range
p
    Atom _ p :: Range
p -> Range
p
    Predication _ _ p :: Range
p -> Range
p
    Definedness _ p :: Range
p -> Range
p
    Equation _ _ _ p :: Range
p -> Range
p
    Membership _ _ p :: Range
p -> Range
p
    Mixfix_formula _ -> Range
nullRange
    Unparsed_formula _ p :: Range
p -> Range
p
    Sort_gen_ax _ _ -> Range
nullRange
    QuantOp _ _ _ -> Range
nullRange
    QuantPred _ _ _ -> Range
nullRange
    ExtFORMULA _ -> Range
nullRange
  rangeSpan :: FORMULA f -> [Pos]
rangeSpan x :: FORMULA f
x = case FORMULA f
x of
    Quantification a :: QUANTIFIER
a b :: [VAR_DECL]
b c :: FORMULA f
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [QUANTIFIER -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan QUANTIFIER
a, [VAR_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [VAR_DECL]
b,
                                          FORMULA f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA f
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Junction a :: Junctor
a b :: [FORMULA f]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [Junctor -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Junctor
a, [FORMULA f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [FORMULA f]
b,
                                  Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Relation a :: FORMULA f
a b :: Relation
b c :: FORMULA f
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [FORMULA f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA f
a, Relation -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Relation
b,
                                    FORMULA f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA f
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Negation a :: FORMULA f
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [FORMULA f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA f
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Atom a :: Bool
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [Bool -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Bool
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Predication a :: PRED_SYMB
a b :: [TERM f]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [PRED_SYMB -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_SYMB
a, [TERM f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM f]
b,
                                     Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Definedness a :: TERM f
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Equation a :: TERM f
a b :: Equality
b c :: TERM f
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a, Equality -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Equality
b,
                                    TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Membership a :: TERM f
a b :: SORT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a, SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
b,
                                    Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Mixfix_formula a :: TERM f
a -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a]
    Unparsed_formula a :: String
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [String -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan String
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Sort_gen_ax a :: [Constraint]
a b :: Bool
b -> [[Pos]] -> [Pos]
joinRanges [[Constraint] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Constraint]
a, Bool -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Bool
b]
    QuantOp a :: SORT
a b :: OP_TYPE
b c :: FORMULA f
c -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, OP_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OP_TYPE
b, FORMULA f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA f
c]
    QuantPred a :: SORT
a b :: PRED_TYPE
b c :: FORMULA f
c -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, PRED_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_TYPE
b,
                                   FORMULA f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA f
c]
    ExtFORMULA a :: f
a -> [[Pos]] -> [Pos]
joinRanges [f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan f
a]

instance GetRange Constraint where
  getRange :: Constraint -> Range
getRange = Range -> Constraint -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: Constraint -> [Pos]
rangeSpan x :: Constraint
x = case Constraint
x of
    Constraint a :: SORT
a b :: [(OP_SYMB, [Int])]
b c :: SORT
c -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, [(OP_SYMB, [Int])] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [(OP_SYMB, [Int])]
b,
                                    SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
c]

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

instance GetRange PRED_SYMB where
  getRange :: PRED_SYMB -> Range
getRange x :: PRED_SYMB
x = case PRED_SYMB
x of
    Pred_name _ -> Range
nullRange
    Qual_pred_name _ _ p :: Range
p -> Range
p
  rangeSpan :: PRED_SYMB -> [Pos]
rangeSpan x :: PRED_SYMB
x = case PRED_SYMB
x of
    Pred_name a :: SORT
a -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a]
    Qual_pred_name a :: SORT
a b :: PRED_TYPE
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, PRED_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_TYPE
b,
                                        Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

instance GetRange f => GetRange (TERM f) where
  getRange :: TERM f -> Range
getRange x :: TERM f
x = case TERM f
x of
    Qual_var _ _ p :: Range
p -> Range
p
    Application _ _ p :: Range
p -> Range
p
    Sorted_term _ _ p :: Range
p -> Range
p
    Cast _ _ p :: Range
p -> Range
p
    Conditional _ _ _ p :: Range
p -> Range
p
    Unparsed_term _ p :: Range
p -> Range
p
    Mixfix_qual_pred _ -> Range
nullRange
    Mixfix_term _ -> Range
nullRange
    Mixfix_token _ -> Range
nullRange
    Mixfix_sorted_term _ p :: Range
p -> Range
p
    Mixfix_cast _ p :: Range
p -> Range
p
    Mixfix_parenthesized _ p :: Range
p -> Range
p
    Mixfix_bracketed _ p :: Range
p -> Range
p
    Mixfix_braced _ p :: Range
p -> Range
p
    ExtTERM _ -> Range
nullRange
  rangeSpan :: TERM f -> [Pos]
rangeSpan x :: TERM f
x = case TERM f
x of
    Qual_var a :: VAR
a b :: SORT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [VAR -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan VAR
a, SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
b,
                                  Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Application a :: OP_SYMB
a b :: [TERM f]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [OP_SYMB -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OP_SYMB
a, [TERM f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM f]
b,
                                     Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Sorted_term a :: TERM f
a b :: SORT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a, SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
b,
                                     Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Cast a :: TERM f
a b :: SORT
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a, SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
b, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]
    Conditional a :: TERM f
a b :: FORMULA f
b c :: TERM f
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
a, FORMULA f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA f
b,
                                       TERM f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM f
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    Unparsed_term a :: String
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [String -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan String
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Mixfix_qual_pred a :: PRED_SYMB
a -> [[Pos]] -> [Pos]
joinRanges [PRED_SYMB -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_SYMB
a]
    Mixfix_term a :: [TERM f]
a -> [[Pos]] -> [Pos]
joinRanges [[TERM f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM f]
a]
    Mixfix_token a :: VAR
a -> [[Pos]] -> [Pos]
joinRanges [VAR -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan VAR
a]
    Mixfix_sorted_term a :: SORT
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Mixfix_cast a :: SORT
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Mixfix_parenthesized a :: [TERM f]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[TERM f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM f]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Mixfix_bracketed a :: [TERM f]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[TERM f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM f]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    Mixfix_braced a :: [TERM f]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[TERM f] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [TERM f]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    ExtTERM a :: f
a -> [[Pos]] -> [Pos]
joinRanges [f -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan f
a]

instance GetRange OP_SYMB where
  getRange :: OP_SYMB -> Range
getRange x :: OP_SYMB
x = case OP_SYMB
x of
    Op_name _ -> Range
nullRange
    Qual_op_name _ _ p :: Range
p -> Range
p
  rangeSpan :: OP_SYMB -> [Pos]
rangeSpan x :: OP_SYMB
x = case OP_SYMB
x of
    Op_name a :: SORT
a -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a]
    Qual_op_name a :: SORT
a b :: OP_TYPE
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, OP_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OP_TYPE
b,
                                      Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

instance GetRange SYMB_ITEMS where
  getRange :: SYMB_ITEMS -> Range
getRange x :: SYMB_ITEMS
x = case SYMB_ITEMS
x of
    Symb_items _ _ p :: Range
p -> Range
p
  rangeSpan :: SYMB_ITEMS -> [Pos]
rangeSpan x :: SYMB_ITEMS
x = case SYMB_ITEMS
x of
    Symb_items a :: SYMB_KIND
a b :: [SYMB]
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SYMB_KIND -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SYMB_KIND
a, [SYMB] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SYMB]
b,
                                    Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

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

instance GetRange SYMB_KIND where
  getRange :: SYMB_KIND -> Range
getRange = Range -> SYMB_KIND -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: SYMB_KIND -> [Pos]
rangeSpan x :: SYMB_KIND
x = case SYMB_KIND
x of
    Implicit -> []
    Sorts_kind -> []
    Ops_kind -> []
    Preds_kind -> []

instance GetRange SYMB where
  getRange :: SYMB -> Range
getRange x :: SYMB
x = case SYMB
x of
    Symb_id _ -> Range
nullRange
    Qual_id _ _ p :: Range
p -> Range
p
  rangeSpan :: SYMB -> [Pos]
rangeSpan x :: SYMB
x = case SYMB
x of
    Symb_id a :: SORT
a -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a]
    Qual_id a :: SORT
a b :: TYPE
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a, TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TYPE
b, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]

instance GetRange TYPE where
  getRange :: TYPE -> Range
getRange = Range -> TYPE -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: TYPE -> [Pos]
rangeSpan x :: TYPE
x = case TYPE
x of
    O_type a :: OP_TYPE
a -> [[Pos]] -> [Pos]
joinRanges [OP_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan OP_TYPE
a]
    P_type a :: PRED_TYPE
a -> [[Pos]] -> [Pos]
joinRanges [PRED_TYPE -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan PRED_TYPE
a]
    A_type a :: SORT
a -> [[Pos]] -> [Pos]
joinRanges [SORT -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SORT
a]

instance GetRange SYMB_OR_MAP where
  getRange :: SYMB_OR_MAP -> Range
getRange x :: SYMB_OR_MAP
x = case SYMB_OR_MAP
x of
    Symb _ -> Range
nullRange
    Symb_map _ _ p :: Range
p -> Range
p
  rangeSpan :: SYMB_OR_MAP -> [Pos]
rangeSpan x :: SYMB_OR_MAP
x = case SYMB_OR_MAP
x of
    Symb a :: SYMB
a -> [[Pos]] -> [Pos]
joinRanges [SYMB -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SYMB
a]
    Symb_map a :: SYMB
a b :: SYMB
b c :: Range
c -> [[Pos]] -> [Pos]
joinRanges [SYMB -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SYMB
a, SYMB -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SYMB
b,
                                  Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
c]