{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./Maude/AS_Maude.hs
Description :  Abstract Maude Syntax
Copyright   :  (c) DFKI GmbH 2009
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  ariesco@fdi.ucm.es
Stability   :  experimental
Portability :  portable

The abstract syntax of maude. Basic specs are a list of statements excluding
imports. Sentences are equations, membership axioms, and rules. Sort, subsort
and operations should be converted to signature.

Because maude parses and typechecks an input string in one go, basic specs for
the logic instance are just a wrapped string that is created by a simple
parser.
-}

module Maude.AS_Maude where

import Common.Id hiding (Id)
import Common.Doc (specBraces, text)
import Common.DocUtils (Pretty (..))

import Data.Data

-- * Types

newtype MaudeText = MaudeText String deriving (Int -> MaudeText -> ShowS
[MaudeText] -> ShowS
MaudeText -> String
(Int -> MaudeText -> ShowS)
-> (MaudeText -> String)
-> ([MaudeText] -> ShowS)
-> Show MaudeText
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MaudeText] -> ShowS
$cshowList :: [MaudeText] -> ShowS
show :: MaudeText -> String
$cshow :: MaudeText -> String
showsPrec :: Int -> MaudeText -> ShowS
$cshowsPrec :: Int -> MaudeText -> ShowS
Show, Typeable)

instance Pretty MaudeText where
    pretty :: MaudeText -> Doc
pretty (MaudeText s :: String
s) = Doc -> Doc
specBraces (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
s

instance GetRange MaudeText

type Qid = Token

data Spec = SpecMod Module
          | SpecTh Module
          | SpecView View
          deriving (Int -> Spec -> ShowS
[Spec] -> ShowS
Spec -> String
(Int -> Spec -> ShowS)
-> (Spec -> String) -> ([Spec] -> ShowS) -> Show Spec
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Spec] -> ShowS
$cshowList :: [Spec] -> ShowS
show :: Spec -> String
$cshow :: Spec -> String
showsPrec :: Int -> Spec -> ShowS
$cshowsPrec :: Int -> Spec -> ShowS
Show, ReadPrec [Spec]
ReadPrec Spec
Int -> ReadS Spec
ReadS [Spec]
(Int -> ReadS Spec)
-> ReadS [Spec] -> ReadPrec Spec -> ReadPrec [Spec] -> Read Spec
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Spec]
$creadListPrec :: ReadPrec [Spec]
readPrec :: ReadPrec Spec
$creadPrec :: ReadPrec Spec
readList :: ReadS [Spec]
$creadList :: ReadS [Spec]
readsPrec :: Int -> ReadS Spec
$creadsPrec :: Int -> ReadS Spec
Read, Eq Spec
Eq Spec =>
(Spec -> Spec -> Ordering)
-> (Spec -> Spec -> Bool)
-> (Spec -> Spec -> Bool)
-> (Spec -> Spec -> Bool)
-> (Spec -> Spec -> Bool)
-> (Spec -> Spec -> Spec)
-> (Spec -> Spec -> Spec)
-> Ord Spec
Spec -> Spec -> Bool
Spec -> Spec -> Ordering
Spec -> Spec -> Spec
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Spec -> Spec -> Spec
$cmin :: Spec -> Spec -> Spec
max :: Spec -> Spec -> Spec
$cmax :: Spec -> Spec -> Spec
>= :: Spec -> Spec -> Bool
$c>= :: Spec -> Spec -> Bool
> :: Spec -> Spec -> Bool
$c> :: Spec -> Spec -> Bool
<= :: Spec -> Spec -> Bool
$c<= :: Spec -> Spec -> Bool
< :: Spec -> Spec -> Bool
$c< :: Spec -> Spec -> Bool
compare :: Spec -> Spec -> Ordering
$ccompare :: Spec -> Spec -> Ordering
$cp1Ord :: Eq Spec
Ord, Spec -> Spec -> Bool
(Spec -> Spec -> Bool) -> (Spec -> Spec -> Bool) -> Eq Spec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Spec -> Spec -> Bool
$c/= :: Spec -> Spec -> Bool
== :: Spec -> Spec -> Bool
$c== :: Spec -> Spec -> Bool
Eq, Typeable, Typeable Spec
Constr
DataType
Typeable Spec =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Spec -> c Spec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Spec)
-> (Spec -> Constr)
-> (Spec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Spec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Spec))
-> ((forall b. Data b => b -> b) -> Spec -> Spec)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r)
-> (forall u. (forall d. Data d => d -> u) -> Spec -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Spec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Spec -> m Spec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Spec -> m Spec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Spec -> m Spec)
-> Data Spec
Spec -> Constr
Spec -> DataType
(forall b. Data b => b -> b) -> Spec -> Spec
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Spec -> c Spec
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Spec
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Spec -> u
forall u. (forall d. Data d => d -> u) -> Spec -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Spec -> m Spec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Spec -> m Spec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Spec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Spec -> c Spec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Spec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Spec)
$cSpecView :: Constr
$cSpecTh :: Constr
$cSpecMod :: Constr
$tSpec :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Spec -> m Spec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Spec -> m Spec
gmapMp :: (forall d. Data d => d -> m d) -> Spec -> m Spec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Spec -> m Spec
gmapM :: (forall d. Data d => d -> m d) -> Spec -> m Spec
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Spec -> m Spec
gmapQi :: Int -> (forall d. Data d => d -> u) -> Spec -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Spec -> u
gmapQ :: (forall d. Data d => d -> u) -> Spec -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Spec -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Spec -> r
gmapT :: (forall b. Data b => b -> b) -> Spec -> Spec
$cgmapT :: (forall b. Data b => b -> b) -> Spec -> Spec
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Spec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Spec)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Spec)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Spec)
dataTypeOf :: Spec -> DataType
$cdataTypeOf :: Spec -> DataType
toConstr :: Spec -> Constr
$ctoConstr :: Spec -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Spec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Spec
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Spec -> c Spec
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Spec -> c Spec
$cp1Data :: Typeable Spec
Data)

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

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

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

data ModExp = ModExp ModId
            | SummationModExp ModExp ModExp
            | RenamingModExp ModExp [Renaming]
            | InstantiationModExp ModExp [ViewId]
            deriving (Int -> ModExp -> ShowS
[ModExp] -> ShowS
ModExp -> String
(Int -> ModExp -> ShowS)
-> (ModExp -> String) -> ([ModExp] -> ShowS) -> Show ModExp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModExp] -> ShowS
$cshowList :: [ModExp] -> ShowS
show :: ModExp -> String
$cshow :: ModExp -> String
showsPrec :: Int -> ModExp -> ShowS
$cshowsPrec :: Int -> ModExp -> ShowS
Show, ReadPrec [ModExp]
ReadPrec ModExp
Int -> ReadS ModExp
ReadS [ModExp]
(Int -> ReadS ModExp)
-> ReadS [ModExp]
-> ReadPrec ModExp
-> ReadPrec [ModExp]
-> Read ModExp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ModExp]
$creadListPrec :: ReadPrec [ModExp]
readPrec :: ReadPrec ModExp
$creadPrec :: ReadPrec ModExp
readList :: ReadS [ModExp]
$creadList :: ReadS [ModExp]
readsPrec :: Int -> ReadS ModExp
$creadsPrec :: Int -> ReadS ModExp
Read, Eq ModExp
Eq ModExp =>
(ModExp -> ModExp -> Ordering)
-> (ModExp -> ModExp -> Bool)
-> (ModExp -> ModExp -> Bool)
-> (ModExp -> ModExp -> Bool)
-> (ModExp -> ModExp -> Bool)
-> (ModExp -> ModExp -> ModExp)
-> (ModExp -> ModExp -> ModExp)
-> Ord ModExp
ModExp -> ModExp -> Bool
ModExp -> ModExp -> Ordering
ModExp -> ModExp -> ModExp
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModExp -> ModExp -> ModExp
$cmin :: ModExp -> ModExp -> ModExp
max :: ModExp -> ModExp -> ModExp
$cmax :: ModExp -> ModExp -> ModExp
>= :: ModExp -> ModExp -> Bool
$c>= :: ModExp -> ModExp -> Bool
> :: ModExp -> ModExp -> Bool
$c> :: ModExp -> ModExp -> Bool
<= :: ModExp -> ModExp -> Bool
$c<= :: ModExp -> ModExp -> Bool
< :: ModExp -> ModExp -> Bool
$c< :: ModExp -> ModExp -> Bool
compare :: ModExp -> ModExp -> Ordering
$ccompare :: ModExp -> ModExp -> Ordering
$cp1Ord :: Eq ModExp
Ord, ModExp -> ModExp -> Bool
(ModExp -> ModExp -> Bool)
-> (ModExp -> ModExp -> Bool) -> Eq ModExp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModExp -> ModExp -> Bool
$c/= :: ModExp -> ModExp -> Bool
== :: ModExp -> ModExp -> Bool
$c== :: ModExp -> ModExp -> Bool
Eq, Typeable, Typeable ModExp
Constr
DataType
Typeable ModExp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModExp -> c ModExp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModExp)
-> (ModExp -> Constr)
-> (ModExp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModExp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModExp))
-> ((forall b. Data b => b -> b) -> ModExp -> ModExp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModExp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModExp -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModExp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ModExp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModExp -> m ModExp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModExp -> m ModExp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModExp -> m ModExp)
-> Data ModExp
ModExp -> Constr
ModExp -> DataType
(forall b. Data b => b -> b) -> ModExp -> ModExp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModExp -> c ModExp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModExp
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModExp -> u
forall u. (forall d. Data d => d -> u) -> ModExp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModExp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModExp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModExp -> m ModExp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModExp -> m ModExp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModExp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModExp -> c ModExp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModExp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModExp)
$cInstantiationModExp :: Constr
$cRenamingModExp :: Constr
$cSummationModExp :: Constr
$cModExp :: Constr
$tModExp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ModExp -> m ModExp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModExp -> m ModExp
gmapMp :: (forall d. Data d => d -> m d) -> ModExp -> m ModExp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModExp -> m ModExp
gmapM :: (forall d. Data d => d -> m d) -> ModExp -> m ModExp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModExp -> m ModExp
gmapQi :: Int -> (forall d. Data d => d -> u) -> ModExp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModExp -> u
gmapQ :: (forall d. Data d => d -> u) -> ModExp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModExp -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModExp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModExp -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModExp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModExp -> r
gmapT :: (forall b. Data b => b -> b) -> ModExp -> ModExp
$cgmapT :: (forall b. Data b => b -> b) -> ModExp -> ModExp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModExp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModExp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ModExp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModExp)
dataTypeOf :: ModExp -> DataType
$cdataTypeOf :: ModExp -> DataType
toConstr :: ModExp -> Constr
$ctoConstr :: ModExp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModExp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModExp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModExp -> c ModExp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModExp -> c ModExp
$cp1Data :: Typeable ModExp
Data)

data Renaming = SortRenaming Sort Sort
              | LabelRenaming LabelId LabelId
              | OpRenaming1 OpId ToPartRenaming
              | OpRenaming2 OpId [Type] Type ToPartRenaming
              | TermMap Term Term
              deriving (Int -> Renaming -> ShowS
[Renaming] -> ShowS
Renaming -> String
(Int -> Renaming -> ShowS)
-> (Renaming -> String) -> ([Renaming] -> ShowS) -> Show Renaming
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Renaming] -> ShowS
$cshowList :: [Renaming] -> ShowS
show :: Renaming -> String
$cshow :: Renaming -> String
showsPrec :: Int -> Renaming -> ShowS
$cshowsPrec :: Int -> Renaming -> ShowS
Show, ReadPrec [Renaming]
ReadPrec Renaming
Int -> ReadS Renaming
ReadS [Renaming]
(Int -> ReadS Renaming)
-> ReadS [Renaming]
-> ReadPrec Renaming
-> ReadPrec [Renaming]
-> Read Renaming
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Renaming]
$creadListPrec :: ReadPrec [Renaming]
readPrec :: ReadPrec Renaming
$creadPrec :: ReadPrec Renaming
readList :: ReadS [Renaming]
$creadList :: ReadS [Renaming]
readsPrec :: Int -> ReadS Renaming
$creadsPrec :: Int -> ReadS Renaming
Read, Eq Renaming
Eq Renaming =>
(Renaming -> Renaming -> Ordering)
-> (Renaming -> Renaming -> Bool)
-> (Renaming -> Renaming -> Bool)
-> (Renaming -> Renaming -> Bool)
-> (Renaming -> Renaming -> Bool)
-> (Renaming -> Renaming -> Renaming)
-> (Renaming -> Renaming -> Renaming)
-> Ord Renaming
Renaming -> Renaming -> Bool
Renaming -> Renaming -> Ordering
Renaming -> Renaming -> Renaming
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Renaming -> Renaming -> Renaming
$cmin :: Renaming -> Renaming -> Renaming
max :: Renaming -> Renaming -> Renaming
$cmax :: Renaming -> Renaming -> Renaming
>= :: Renaming -> Renaming -> Bool
$c>= :: Renaming -> Renaming -> Bool
> :: Renaming -> Renaming -> Bool
$c> :: Renaming -> Renaming -> Bool
<= :: Renaming -> Renaming -> Bool
$c<= :: Renaming -> Renaming -> Bool
< :: Renaming -> Renaming -> Bool
$c< :: Renaming -> Renaming -> Bool
compare :: Renaming -> Renaming -> Ordering
$ccompare :: Renaming -> Renaming -> Ordering
$cp1Ord :: Eq Renaming
Ord, Renaming -> Renaming -> Bool
(Renaming -> Renaming -> Bool)
-> (Renaming -> Renaming -> Bool) -> Eq Renaming
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Renaming -> Renaming -> Bool
$c/= :: Renaming -> Renaming -> Bool
== :: Renaming -> Renaming -> Bool
$c== :: Renaming -> Renaming -> Bool
Eq, Typeable, Typeable Renaming
Constr
DataType
Typeable Renaming =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Renaming -> c Renaming)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Renaming)
-> (Renaming -> Constr)
-> (Renaming -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Renaming))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Renaming))
-> ((forall b. Data b => b -> b) -> Renaming -> Renaming)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Renaming -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Renaming -> r)
-> (forall u. (forall d. Data d => d -> u) -> Renaming -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Renaming -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Renaming -> m Renaming)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Renaming -> m Renaming)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Renaming -> m Renaming)
-> Data Renaming
Renaming -> Constr
Renaming -> DataType
(forall b. Data b => b -> b) -> Renaming -> Renaming
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Renaming -> c Renaming
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Renaming
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Renaming -> u
forall u. (forall d. Data d => d -> u) -> Renaming -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Renaming -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Renaming -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Renaming -> m Renaming
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Renaming -> m Renaming
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Renaming
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Renaming -> c Renaming
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Renaming)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Renaming)
$cTermMap :: Constr
$cOpRenaming2 :: Constr
$cOpRenaming1 :: Constr
$cLabelRenaming :: Constr
$cSortRenaming :: Constr
$tRenaming :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Renaming -> m Renaming
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Renaming -> m Renaming
gmapMp :: (forall d. Data d => d -> m d) -> Renaming -> m Renaming
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Renaming -> m Renaming
gmapM :: (forall d. Data d => d -> m d) -> Renaming -> m Renaming
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Renaming -> m Renaming
gmapQi :: Int -> (forall d. Data d => d -> u) -> Renaming -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Renaming -> u
gmapQ :: (forall d. Data d => d -> u) -> Renaming -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Renaming -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Renaming -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Renaming -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Renaming -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Renaming -> r
gmapT :: (forall b. Data b => b -> b) -> Renaming -> Renaming
$cgmapT :: (forall b. Data b => b -> b) -> Renaming -> Renaming
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Renaming)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Renaming)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Renaming)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Renaming)
dataTypeOf :: Renaming -> DataType
$cdataTypeOf :: Renaming -> DataType
toConstr :: Renaming -> Constr
$ctoConstr :: Renaming -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Renaming
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Renaming
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Renaming -> c Renaming
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Renaming -> c Renaming
$cp1Data :: Typeable Renaming
Data)

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

data Statement = ImportStmnt Import
               | SortStmnt Sort
               | SubsortStmnt SubsortDecl
               | OpStmnt Operator
               | EqStmnt Equation
               | MbStmnt Membership
               | RlStmnt Rule
               deriving (Int -> Statement -> ShowS
[Statement] -> ShowS
Statement -> String
(Int -> Statement -> ShowS)
-> (Statement -> String)
-> ([Statement] -> ShowS)
-> Show Statement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Statement] -> ShowS
$cshowList :: [Statement] -> ShowS
show :: Statement -> String
$cshow :: Statement -> String
showsPrec :: Int -> Statement -> ShowS
$cshowsPrec :: Int -> Statement -> ShowS
Show, ReadPrec [Statement]
ReadPrec Statement
Int -> ReadS Statement
ReadS [Statement]
(Int -> ReadS Statement)
-> ReadS [Statement]
-> ReadPrec Statement
-> ReadPrec [Statement]
-> Read Statement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Statement]
$creadListPrec :: ReadPrec [Statement]
readPrec :: ReadPrec Statement
$creadPrec :: ReadPrec Statement
readList :: ReadS [Statement]
$creadList :: ReadS [Statement]
readsPrec :: Int -> ReadS Statement
$creadsPrec :: Int -> ReadS Statement
Read, Eq Statement
Eq Statement =>
(Statement -> Statement -> Ordering)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Statement)
-> (Statement -> Statement -> Statement)
-> Ord Statement
Statement -> Statement -> Bool
Statement -> Statement -> Ordering
Statement -> Statement -> Statement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Statement -> Statement -> Statement
$cmin :: Statement -> Statement -> Statement
max :: Statement -> Statement -> Statement
$cmax :: Statement -> Statement -> Statement
>= :: Statement -> Statement -> Bool
$c>= :: Statement -> Statement -> Bool
> :: Statement -> Statement -> Bool
$c> :: Statement -> Statement -> Bool
<= :: Statement -> Statement -> Bool
$c<= :: Statement -> Statement -> Bool
< :: Statement -> Statement -> Bool
$c< :: Statement -> Statement -> Bool
compare :: Statement -> Statement -> Ordering
$ccompare :: Statement -> Statement -> Ordering
$cp1Ord :: Eq Statement
Ord, Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c== :: Statement -> Statement -> Bool
Eq, Typeable, Typeable Statement
Constr
DataType
Typeable Statement =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Statement -> c Statement)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Statement)
-> (Statement -> Constr)
-> (Statement -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Statement))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement))
-> ((forall b. Data b => b -> b) -> Statement -> Statement)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement -> m Statement)
-> Data Statement
Statement -> Constr
Statement -> DataType
(forall b. Data b => b -> b) -> Statement -> Statement
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
forall u. (forall d. Data d => d -> u) -> Statement -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cRlStmnt :: Constr
$cMbStmnt :: Constr
$cEqStmnt :: Constr
$cOpStmnt :: Constr
$cSubsortStmnt :: Constr
$cSortStmnt :: Constr
$cImportStmnt :: Constr
$tStatement :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapMp :: (forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapM :: (forall d. Data d => d -> m d) -> Statement -> m Statement
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement -> m Statement
gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement -> u
gmapQ :: (forall d. Data d => d -> u) -> Statement -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Statement -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement -> r
gmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
$cgmapT :: (forall b. Data b => b -> b) -> Statement -> Statement
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Statement)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Statement)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Statement)
dataTypeOf :: Statement -> DataType
$cdataTypeOf :: Statement -> DataType
toConstr :: Statement -> Constr
$ctoConstr :: Statement -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Statement
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement -> c Statement
$cp1Data :: Typeable Statement
Data)

data Import = Including ModExp
            | Extending ModExp
            | Protecting ModExp
            deriving (Int -> Import -> ShowS
[Import] -> ShowS
Import -> String
(Int -> Import -> ShowS)
-> (Import -> String) -> ([Import] -> ShowS) -> Show Import
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Import] -> ShowS
$cshowList :: [Import] -> ShowS
show :: Import -> String
$cshow :: Import -> String
showsPrec :: Int -> Import -> ShowS
$cshowsPrec :: Int -> Import -> ShowS
Show, ReadPrec [Import]
ReadPrec Import
Int -> ReadS Import
ReadS [Import]
(Int -> ReadS Import)
-> ReadS [Import]
-> ReadPrec Import
-> ReadPrec [Import]
-> Read Import
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Import]
$creadListPrec :: ReadPrec [Import]
readPrec :: ReadPrec Import
$creadPrec :: ReadPrec Import
readList :: ReadS [Import]
$creadList :: ReadS [Import]
readsPrec :: Int -> ReadS Import
$creadsPrec :: Int -> ReadS Import
Read, Eq Import
Eq Import =>
(Import -> Import -> Ordering)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Import)
-> (Import -> Import -> Import)
-> Ord Import
Import -> Import -> Bool
Import -> Import -> Ordering
Import -> Import -> Import
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Import -> Import -> Import
$cmin :: Import -> Import -> Import
max :: Import -> Import -> Import
$cmax :: Import -> Import -> Import
>= :: Import -> Import -> Bool
$c>= :: Import -> Import -> Bool
> :: Import -> Import -> Bool
$c> :: Import -> Import -> Bool
<= :: Import -> Import -> Bool
$c<= :: Import -> Import -> Bool
< :: Import -> Import -> Bool
$c< :: Import -> Import -> Bool
compare :: Import -> Import -> Ordering
$ccompare :: Import -> Import -> Ordering
$cp1Ord :: Eq Import
Ord, Import -> Import -> Bool
(Import -> Import -> Bool)
-> (Import -> Import -> Bool) -> Eq Import
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Import -> Import -> Bool
$c/= :: Import -> Import -> Bool
== :: Import -> Import -> Bool
$c== :: Import -> Import -> Bool
Eq, Typeable, Typeable Import
Constr
DataType
Typeable Import =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Import -> c Import)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Import)
-> (Import -> Constr)
-> (Import -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Import))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import))
-> ((forall b. Data b => b -> b) -> Import -> Import)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Import -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Import -> r)
-> (forall u. (forall d. Data d => d -> u) -> Import -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Import -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Import -> m Import)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Import -> m Import)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Import -> m Import)
-> Data Import
Import -> Constr
Import -> DataType
(forall b. Data b => b -> b) -> Import -> Import
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Import -> c Import
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Import
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Import -> u
forall u. (forall d. Data d => d -> u) -> Import -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Import -> m Import
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Import -> m Import
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Import
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Import -> c Import
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Import)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import)
$cProtecting :: Constr
$cExtending :: Constr
$cIncluding :: Constr
$tImport :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Import -> m Import
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Import -> m Import
gmapMp :: (forall d. Data d => d -> m d) -> Import -> m Import
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Import -> m Import
gmapM :: (forall d. Data d => d -> m d) -> Import -> m Import
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Import -> m Import
gmapQi :: Int -> (forall d. Data d => d -> u) -> Import -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Import -> u
gmapQ :: (forall d. Data d => d -> u) -> Import -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Import -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r
gmapT :: (forall b. Data b => b -> b) -> Import -> Import
$cgmapT :: (forall b. Data b => b -> b) -> Import -> Import
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Import)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Import)
dataTypeOf :: Import -> DataType
$cdataTypeOf :: Import -> DataType
toConstr :: Import -> Constr
$ctoConstr :: Import -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Import
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Import
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Import -> c Import
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Import -> c Import
$cp1Data :: Typeable Import
Data)

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

data Operator = Op OpId [Type] Type [Attr]
              deriving (Int -> Operator -> ShowS
[Operator] -> ShowS
Operator -> String
(Int -> Operator -> ShowS)
-> (Operator -> String) -> ([Operator] -> ShowS) -> Show Operator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Operator] -> ShowS
$cshowList :: [Operator] -> ShowS
show :: Operator -> String
$cshow :: Operator -> String
showsPrec :: Int -> Operator -> ShowS
$cshowsPrec :: Int -> Operator -> ShowS
Show, ReadPrec [Operator]
ReadPrec Operator
Int -> ReadS Operator
ReadS [Operator]
(Int -> ReadS Operator)
-> ReadS [Operator]
-> ReadPrec Operator
-> ReadPrec [Operator]
-> Read Operator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Operator]
$creadListPrec :: ReadPrec [Operator]
readPrec :: ReadPrec Operator
$creadPrec :: ReadPrec Operator
readList :: ReadS [Operator]
$creadList :: ReadS [Operator]
readsPrec :: Int -> ReadS Operator
$creadsPrec :: Int -> ReadS Operator
Read, Eq Operator
Eq Operator =>
(Operator -> Operator -> Ordering)
-> (Operator -> Operator -> Bool)
-> (Operator -> Operator -> Bool)
-> (Operator -> Operator -> Bool)
-> (Operator -> Operator -> Bool)
-> (Operator -> Operator -> Operator)
-> (Operator -> Operator -> Operator)
-> Ord Operator
Operator -> Operator -> Bool
Operator -> Operator -> Ordering
Operator -> Operator -> Operator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Operator -> Operator -> Operator
$cmin :: Operator -> Operator -> Operator
max :: Operator -> Operator -> Operator
$cmax :: Operator -> Operator -> Operator
>= :: Operator -> Operator -> Bool
$c>= :: Operator -> Operator -> Bool
> :: Operator -> Operator -> Bool
$c> :: Operator -> Operator -> Bool
<= :: Operator -> Operator -> Bool
$c<= :: Operator -> Operator -> Bool
< :: Operator -> Operator -> Bool
$c< :: Operator -> Operator -> Bool
compare :: Operator -> Operator -> Ordering
$ccompare :: Operator -> Operator -> Ordering
$cp1Ord :: Eq Operator
Ord, Operator -> Operator -> Bool
(Operator -> Operator -> Bool)
-> (Operator -> Operator -> Bool) -> Eq Operator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Operator -> Operator -> Bool
$c/= :: Operator -> Operator -> Bool
== :: Operator -> Operator -> Bool
$c== :: Operator -> Operator -> Bool
Eq, Typeable, Typeable Operator
Constr
DataType
Typeable Operator =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Operator -> c Operator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Operator)
-> (Operator -> Constr)
-> (Operator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Operator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator))
-> ((forall b. Data b => b -> b) -> Operator -> Operator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Operator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Operator -> r)
-> (forall u. (forall d. Data d => d -> u) -> Operator -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Operator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Operator -> m Operator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Operator -> m Operator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Operator -> m Operator)
-> Data Operator
Operator -> Constr
Operator -> DataType
(forall b. Data b => b -> b) -> Operator -> Operator
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operator -> c Operator
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operator
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Operator -> u
forall u. (forall d. Data d => d -> u) -> Operator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operator -> c Operator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator)
$cOp :: Constr
$tOperator :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Operator -> m Operator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
gmapMp :: (forall d. Data d => d -> m d) -> Operator -> m Operator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
gmapM :: (forall d. Data d => d -> m d) -> Operator -> m Operator
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operator -> m Operator
gmapQi :: Int -> (forall d. Data d => d -> u) -> Operator -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Operator -> u
gmapQ :: (forall d. Data d => d -> u) -> Operator -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Operator -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operator -> r
gmapT :: (forall b. Data b => b -> b) -> Operator -> Operator
$cgmapT :: (forall b. Data b => b -> b) -> Operator -> Operator
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operator)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Operator)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operator)
dataTypeOf :: Operator -> DataType
$cdataTypeOf :: Operator -> DataType
toConstr :: Operator -> Constr
$ctoConstr :: Operator -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operator
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operator -> c Operator
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operator -> c Operator
$cp1Data :: Typeable Operator
Data)

data Membership = Mb Term Sort [Condition] [StmntAttr]
                deriving (Int -> Membership -> ShowS
[Membership] -> ShowS
Membership -> String
(Int -> Membership -> ShowS)
-> (Membership -> String)
-> ([Membership] -> ShowS)
-> Show Membership
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Membership] -> ShowS
$cshowList :: [Membership] -> ShowS
show :: Membership -> String
$cshow :: Membership -> String
showsPrec :: Int -> Membership -> ShowS
$cshowsPrec :: Int -> Membership -> ShowS
Show, ReadPrec [Membership]
ReadPrec Membership
Int -> ReadS Membership
ReadS [Membership]
(Int -> ReadS Membership)
-> ReadS [Membership]
-> ReadPrec Membership
-> ReadPrec [Membership]
-> Read Membership
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Membership]
$creadListPrec :: ReadPrec [Membership]
readPrec :: ReadPrec Membership
$creadPrec :: ReadPrec Membership
readList :: ReadS [Membership]
$creadList :: ReadS [Membership]
readsPrec :: Int -> ReadS Membership
$creadsPrec :: Int -> ReadS Membership
Read, Eq Membership
Eq Membership =>
(Membership -> Membership -> Ordering)
-> (Membership -> Membership -> Bool)
-> (Membership -> Membership -> Bool)
-> (Membership -> Membership -> Bool)
-> (Membership -> Membership -> Bool)
-> (Membership -> Membership -> Membership)
-> (Membership -> Membership -> Membership)
-> Ord Membership
Membership -> Membership -> Bool
Membership -> Membership -> Ordering
Membership -> Membership -> Membership
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Membership -> Membership -> Membership
$cmin :: Membership -> Membership -> Membership
max :: Membership -> Membership -> Membership
$cmax :: Membership -> Membership -> Membership
>= :: Membership -> Membership -> Bool
$c>= :: Membership -> Membership -> Bool
> :: Membership -> Membership -> Bool
$c> :: Membership -> Membership -> Bool
<= :: Membership -> Membership -> Bool
$c<= :: Membership -> Membership -> Bool
< :: Membership -> Membership -> Bool
$c< :: Membership -> Membership -> Bool
compare :: Membership -> Membership -> Ordering
$ccompare :: Membership -> Membership -> Ordering
$cp1Ord :: Eq Membership
Ord, Membership -> Membership -> Bool
(Membership -> Membership -> Bool)
-> (Membership -> Membership -> Bool) -> Eq Membership
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Membership -> Membership -> Bool
$c/= :: Membership -> Membership -> Bool
== :: Membership -> Membership -> Bool
$c== :: Membership -> Membership -> Bool
Eq, Typeable, Typeable Membership
Constr
DataType
Typeable Membership =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Membership -> c Membership)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Membership)
-> (Membership -> Constr)
-> (Membership -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Membership))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Membership))
-> ((forall b. Data b => b -> b) -> Membership -> Membership)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Membership -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Membership -> r)
-> (forall u. (forall d. Data d => d -> u) -> Membership -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Membership -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Membership -> m Membership)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Membership -> m Membership)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Membership -> m Membership)
-> Data Membership
Membership -> Constr
Membership -> DataType
(forall b. Data b => b -> b) -> Membership -> Membership
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Membership -> c Membership
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Membership
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Membership -> u
forall u. (forall d. Data d => d -> u) -> Membership -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Membership -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Membership -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Membership -> m Membership
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Membership -> m Membership
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Membership
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Membership -> c Membership
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Membership)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Membership)
$cMb :: Constr
$tMembership :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Membership -> m Membership
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Membership -> m Membership
gmapMp :: (forall d. Data d => d -> m d) -> Membership -> m Membership
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Membership -> m Membership
gmapM :: (forall d. Data d => d -> m d) -> Membership -> m Membership
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Membership -> m Membership
gmapQi :: Int -> (forall d. Data d => d -> u) -> Membership -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Membership -> u
gmapQ :: (forall d. Data d => d -> u) -> Membership -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Membership -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Membership -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Membership -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Membership -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Membership -> r
gmapT :: (forall b. Data b => b -> b) -> Membership -> Membership
$cgmapT :: (forall b. Data b => b -> b) -> Membership -> Membership
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Membership)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Membership)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Membership)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Membership)
dataTypeOf :: Membership -> DataType
$cdataTypeOf :: Membership -> DataType
toConstr :: Membership -> Constr
$ctoConstr :: Membership -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Membership
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Membership
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Membership -> c Membership
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Membership -> c Membership
$cp1Data :: Typeable Membership
Data)

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

data Rule = Rl Term Term [Condition] [StmntAttr]
          deriving (Int -> Rule -> ShowS
[Rule] -> ShowS
Rule -> String
(Int -> Rule -> ShowS)
-> (Rule -> String) -> ([Rule] -> ShowS) -> Show Rule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Rule] -> ShowS
$cshowList :: [Rule] -> ShowS
show :: Rule -> String
$cshow :: Rule -> String
showsPrec :: Int -> Rule -> ShowS
$cshowsPrec :: Int -> Rule -> ShowS
Show, ReadPrec [Rule]
ReadPrec Rule
Int -> ReadS Rule
ReadS [Rule]
(Int -> ReadS Rule)
-> ReadS [Rule] -> ReadPrec Rule -> ReadPrec [Rule] -> Read Rule
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Rule]
$creadListPrec :: ReadPrec [Rule]
readPrec :: ReadPrec Rule
$creadPrec :: ReadPrec Rule
readList :: ReadS [Rule]
$creadList :: ReadS [Rule]
readsPrec :: Int -> ReadS Rule
$creadsPrec :: Int -> ReadS Rule
Read, Eq Rule
Eq Rule =>
(Rule -> Rule -> Ordering)
-> (Rule -> Rule -> Bool)
-> (Rule -> Rule -> Bool)
-> (Rule -> Rule -> Bool)
-> (Rule -> Rule -> Bool)
-> (Rule -> Rule -> Rule)
-> (Rule -> Rule -> Rule)
-> Ord Rule
Rule -> Rule -> Bool
Rule -> Rule -> Ordering
Rule -> Rule -> Rule
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Rule -> Rule -> Rule
$cmin :: Rule -> Rule -> Rule
max :: Rule -> Rule -> Rule
$cmax :: Rule -> Rule -> Rule
>= :: Rule -> Rule -> Bool
$c>= :: Rule -> Rule -> Bool
> :: Rule -> Rule -> Bool
$c> :: Rule -> Rule -> Bool
<= :: Rule -> Rule -> Bool
$c<= :: Rule -> Rule -> Bool
< :: Rule -> Rule -> Bool
$c< :: Rule -> Rule -> Bool
compare :: Rule -> Rule -> Ordering
$ccompare :: Rule -> Rule -> Ordering
$cp1Ord :: Eq Rule
Ord, Rule -> Rule -> Bool
(Rule -> Rule -> Bool) -> (Rule -> Rule -> Bool) -> Eq Rule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Rule -> Rule -> Bool
$c/= :: Rule -> Rule -> Bool
== :: Rule -> Rule -> Bool
$c== :: Rule -> Rule -> Bool
Eq, Typeable, Typeable Rule
Constr
DataType
Typeable Rule =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Rule -> c Rule)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Rule)
-> (Rule -> Constr)
-> (Rule -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Rule))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rule))
-> ((forall b. Data b => b -> b) -> Rule -> Rule)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r)
-> (forall u. (forall d. Data d => d -> u) -> Rule -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Rule -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Rule -> m Rule)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rule -> m Rule)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Rule -> m Rule)
-> Data Rule
Rule -> Constr
Rule -> DataType
(forall b. Data b => b -> b) -> Rule -> Rule
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule -> c Rule
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rule
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Rule -> u
forall u. (forall d. Data d => d -> u) -> Rule -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rule -> m Rule
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rule -> m Rule
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rule
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule -> c Rule
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rule)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rule)
$cRl :: Constr
$tRule :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Rule -> m Rule
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rule -> m Rule
gmapMp :: (forall d. Data d => d -> m d) -> Rule -> m Rule
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Rule -> m Rule
gmapM :: (forall d. Data d => d -> m d) -> Rule -> m Rule
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Rule -> m Rule
gmapQi :: Int -> (forall d. Data d => d -> u) -> Rule -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Rule -> u
gmapQ :: (forall d. Data d => d -> u) -> Rule -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Rule -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r
gmapT :: (forall b. Data b => b -> b) -> Rule -> Rule
$cgmapT :: (forall b. Data b => b -> b) -> Rule -> Rule
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rule)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rule)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Rule)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Rule)
dataTypeOf :: Rule -> DataType
$cdataTypeOf :: Rule -> DataType
toConstr :: Rule -> Constr
$ctoConstr :: Rule -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rule
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Rule
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule -> c Rule
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Rule -> c Rule
$cp1Data :: Typeable Rule
Data)

data Condition = EqCond Term Term
               | MbCond Term Sort
               | MatchCond Term Term
               | RwCond Term Term
               deriving (Int -> Condition -> ShowS
[Condition] -> ShowS
Condition -> String
(Int -> Condition -> ShowS)
-> (Condition -> String)
-> ([Condition] -> ShowS)
-> Show Condition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Condition] -> ShowS
$cshowList :: [Condition] -> ShowS
show :: Condition -> String
$cshow :: Condition -> String
showsPrec :: Int -> Condition -> ShowS
$cshowsPrec :: Int -> Condition -> ShowS
Show, ReadPrec [Condition]
ReadPrec Condition
Int -> ReadS Condition
ReadS [Condition]
(Int -> ReadS Condition)
-> ReadS [Condition]
-> ReadPrec Condition
-> ReadPrec [Condition]
-> Read Condition
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Condition]
$creadListPrec :: ReadPrec [Condition]
readPrec :: ReadPrec Condition
$creadPrec :: ReadPrec Condition
readList :: ReadS [Condition]
$creadList :: ReadS [Condition]
readsPrec :: Int -> ReadS Condition
$creadsPrec :: Int -> ReadS Condition
Read, Eq Condition
Eq Condition =>
(Condition -> Condition -> Ordering)
-> (Condition -> Condition -> Bool)
-> (Condition -> Condition -> Bool)
-> (Condition -> Condition -> Bool)
-> (Condition -> Condition -> Bool)
-> (Condition -> Condition -> Condition)
-> (Condition -> Condition -> Condition)
-> Ord Condition
Condition -> Condition -> Bool
Condition -> Condition -> Ordering
Condition -> Condition -> Condition
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Condition -> Condition -> Condition
$cmin :: Condition -> Condition -> Condition
max :: Condition -> Condition -> Condition
$cmax :: Condition -> Condition -> Condition
>= :: Condition -> Condition -> Bool
$c>= :: Condition -> Condition -> Bool
> :: Condition -> Condition -> Bool
$c> :: Condition -> Condition -> Bool
<= :: Condition -> Condition -> Bool
$c<= :: Condition -> Condition -> Bool
< :: Condition -> Condition -> Bool
$c< :: Condition -> Condition -> Bool
compare :: Condition -> Condition -> Ordering
$ccompare :: Condition -> Condition -> Ordering
$cp1Ord :: Eq Condition
Ord, Condition -> Condition -> Bool
(Condition -> Condition -> Bool)
-> (Condition -> Condition -> Bool) -> Eq Condition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Condition -> Condition -> Bool
$c/= :: Condition -> Condition -> Bool
== :: Condition -> Condition -> Bool
$c== :: Condition -> Condition -> Bool
Eq, Typeable, Typeable Condition
Constr
DataType
Typeable Condition =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Condition -> c Condition)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Condition)
-> (Condition -> Constr)
-> (Condition -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Condition))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition))
-> ((forall b. Data b => b -> b) -> Condition -> Condition)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Condition -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Condition -> r)
-> (forall u. (forall d. Data d => d -> u) -> Condition -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Condition -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Condition -> m Condition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Condition -> m Condition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Condition -> m Condition)
-> Data Condition
Condition -> Constr
Condition -> DataType
(forall b. Data b => b -> b) -> Condition -> Condition
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Condition -> u
forall u. (forall d. Data d => d -> u) -> Condition -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Condition)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition)
$cRwCond :: Constr
$cMatchCond :: Constr
$cMbCond :: Constr
$cEqCond :: Constr
$tCondition :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Condition -> m Condition
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
gmapMp :: (forall d. Data d => d -> m d) -> Condition -> m Condition
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
gmapM :: (forall d. Data d => d -> m d) -> Condition -> m Condition
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
gmapQi :: Int -> (forall d. Data d => d -> u) -> Condition -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Condition -> u
gmapQ :: (forall d. Data d => d -> u) -> Condition -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Condition -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
gmapT :: (forall b. Data b => b -> b) -> Condition -> Condition
$cgmapT :: (forall b. Data b => b -> b) -> Condition -> Condition
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Condition)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Condition)
dataTypeOf :: Condition -> DataType
$cdataTypeOf :: Condition -> DataType
toConstr :: Condition -> Constr
$ctoConstr :: Condition -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
$cp1Data :: Typeable Condition
Data)

data Attr = Assoc
          | Comm
          | Idem
          | Iter
          | Id Term
          | LeftId Term
          | RightId Term
          | Strat [Int]
          | Memo
          | Prec Int
          | Gather [Qid]
          | Format [Qid]
          | Ctor
          | Config
          | Object
          | Msg
          | Frozen [Int]
          | Poly [Int]
          | Special [Hook]
          deriving (Int -> Attr -> ShowS
[Attr] -> ShowS
Attr -> String
(Int -> Attr -> ShowS)
-> (Attr -> String) -> ([Attr] -> ShowS) -> Show Attr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Attr] -> ShowS
$cshowList :: [Attr] -> ShowS
show :: Attr -> String
$cshow :: Attr -> String
showsPrec :: Int -> Attr -> ShowS
$cshowsPrec :: Int -> Attr -> ShowS
Show, ReadPrec [Attr]
ReadPrec Attr
Int -> ReadS Attr
ReadS [Attr]
(Int -> ReadS Attr)
-> ReadS [Attr] -> ReadPrec Attr -> ReadPrec [Attr] -> Read Attr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Attr]
$creadListPrec :: ReadPrec [Attr]
readPrec :: ReadPrec Attr
$creadPrec :: ReadPrec Attr
readList :: ReadS [Attr]
$creadList :: ReadS [Attr]
readsPrec :: Int -> ReadS Attr
$creadsPrec :: Int -> ReadS Attr
Read, Eq Attr
Eq Attr =>
(Attr -> Attr -> Ordering)
-> (Attr -> Attr -> Bool)
-> (Attr -> Attr -> Bool)
-> (Attr -> Attr -> Bool)
-> (Attr -> Attr -> Bool)
-> (Attr -> Attr -> Attr)
-> (Attr -> Attr -> Attr)
-> Ord Attr
Attr -> Attr -> Bool
Attr -> Attr -> Ordering
Attr -> Attr -> Attr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Attr -> Attr -> Attr
$cmin :: Attr -> Attr -> Attr
max :: Attr -> Attr -> Attr
$cmax :: Attr -> Attr -> Attr
>= :: Attr -> Attr -> Bool
$c>= :: Attr -> Attr -> Bool
> :: Attr -> Attr -> Bool
$c> :: Attr -> Attr -> Bool
<= :: Attr -> Attr -> Bool
$c<= :: Attr -> Attr -> Bool
< :: Attr -> Attr -> Bool
$c< :: Attr -> Attr -> Bool
compare :: Attr -> Attr -> Ordering
$ccompare :: Attr -> Attr -> Ordering
$cp1Ord :: Eq Attr
Ord, Attr -> Attr -> Bool
(Attr -> Attr -> Bool) -> (Attr -> Attr -> Bool) -> Eq Attr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Attr -> Attr -> Bool
$c/= :: Attr -> Attr -> Bool
== :: Attr -> Attr -> Bool
$c== :: Attr -> Attr -> Bool
Eq, Typeable, Typeable Attr
Constr
DataType
Typeable Attr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Attr -> c Attr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attr)
-> (Attr -> Constr)
-> (Attr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr))
-> ((forall b. Data b => b -> b) -> Attr -> Attr)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r)
-> (forall u. (forall d. Data d => d -> u) -> Attr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr)
-> Data Attr
Attr -> Constr
Attr -> DataType
(forall b. Data b => b -> b) -> Attr -> Attr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attr -> c Attr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attr
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u
forall u. (forall d. Data d => d -> u) -> Attr -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attr -> m Attr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attr -> m Attr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attr -> c Attr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
$cSpecial :: Constr
$cPoly :: Constr
$cFrozen :: Constr
$cMsg :: Constr
$cObject :: Constr
$cConfig :: Constr
$cCtor :: Constr
$cFormat :: Constr
$cGather :: Constr
$cPrec :: Constr
$cMemo :: Constr
$cStrat :: Constr
$cRightId :: Constr
$cLeftId :: Constr
$cId :: Constr
$cIter :: Constr
$cIdem :: Constr
$cComm :: Constr
$cAssoc :: Constr
$tAttr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Attr -> m Attr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attr -> m Attr
gmapMp :: (forall d. Data d => d -> m d) -> Attr -> m Attr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attr -> m Attr
gmapM :: (forall d. Data d => d -> m d) -> Attr -> m Attr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attr -> m Attr
gmapQi :: Int -> (forall d. Data d => d -> u) -> Attr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u
gmapQ :: (forall d. Data d => d -> u) -> Attr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Attr -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
gmapT :: (forall b. Data b => b -> b) -> Attr -> Attr
$cgmapT :: (forall b. Data b => b -> b) -> Attr -> Attr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Attr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attr)
dataTypeOf :: Attr -> DataType
$cdataTypeOf :: Attr -> DataType
toConstr :: Attr -> Constr
$ctoConstr :: Attr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attr -> c Attr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attr -> c Attr
$cp1Data :: Typeable Attr
Data)

data StmntAttr = Label Qid
               | Metadata String
               | Owise
               | Nonexec
               | Print [Qid]
               deriving (Int -> StmntAttr -> ShowS
[StmntAttr] -> ShowS
StmntAttr -> String
(Int -> StmntAttr -> ShowS)
-> (StmntAttr -> String)
-> ([StmntAttr] -> ShowS)
-> Show StmntAttr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StmntAttr] -> ShowS
$cshowList :: [StmntAttr] -> ShowS
show :: StmntAttr -> String
$cshow :: StmntAttr -> String
showsPrec :: Int -> StmntAttr -> ShowS
$cshowsPrec :: Int -> StmntAttr -> ShowS
Show, ReadPrec [StmntAttr]
ReadPrec StmntAttr
Int -> ReadS StmntAttr
ReadS [StmntAttr]
(Int -> ReadS StmntAttr)
-> ReadS [StmntAttr]
-> ReadPrec StmntAttr
-> ReadPrec [StmntAttr]
-> Read StmntAttr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StmntAttr]
$creadListPrec :: ReadPrec [StmntAttr]
readPrec :: ReadPrec StmntAttr
$creadPrec :: ReadPrec StmntAttr
readList :: ReadS [StmntAttr]
$creadList :: ReadS [StmntAttr]
readsPrec :: Int -> ReadS StmntAttr
$creadsPrec :: Int -> ReadS StmntAttr
Read, Eq StmntAttr
Eq StmntAttr =>
(StmntAttr -> StmntAttr -> Ordering)
-> (StmntAttr -> StmntAttr -> Bool)
-> (StmntAttr -> StmntAttr -> Bool)
-> (StmntAttr -> StmntAttr -> Bool)
-> (StmntAttr -> StmntAttr -> Bool)
-> (StmntAttr -> StmntAttr -> StmntAttr)
-> (StmntAttr -> StmntAttr -> StmntAttr)
-> Ord StmntAttr
StmntAttr -> StmntAttr -> Bool
StmntAttr -> StmntAttr -> Ordering
StmntAttr -> StmntAttr -> StmntAttr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: StmntAttr -> StmntAttr -> StmntAttr
$cmin :: StmntAttr -> StmntAttr -> StmntAttr
max :: StmntAttr -> StmntAttr -> StmntAttr
$cmax :: StmntAttr -> StmntAttr -> StmntAttr
>= :: StmntAttr -> StmntAttr -> Bool
$c>= :: StmntAttr -> StmntAttr -> Bool
> :: StmntAttr -> StmntAttr -> Bool
$c> :: StmntAttr -> StmntAttr -> Bool
<= :: StmntAttr -> StmntAttr -> Bool
$c<= :: StmntAttr -> StmntAttr -> Bool
< :: StmntAttr -> StmntAttr -> Bool
$c< :: StmntAttr -> StmntAttr -> Bool
compare :: StmntAttr -> StmntAttr -> Ordering
$ccompare :: StmntAttr -> StmntAttr -> Ordering
$cp1Ord :: Eq StmntAttr
Ord, StmntAttr -> StmntAttr -> Bool
(StmntAttr -> StmntAttr -> Bool)
-> (StmntAttr -> StmntAttr -> Bool) -> Eq StmntAttr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StmntAttr -> StmntAttr -> Bool
$c/= :: StmntAttr -> StmntAttr -> Bool
== :: StmntAttr -> StmntAttr -> Bool
$c== :: StmntAttr -> StmntAttr -> Bool
Eq, Typeable, Typeable StmntAttr
Constr
DataType
Typeable StmntAttr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> StmntAttr -> c StmntAttr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StmntAttr)
-> (StmntAttr -> Constr)
-> (StmntAttr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StmntAttr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StmntAttr))
-> ((forall b. Data b => b -> b) -> StmntAttr -> StmntAttr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StmntAttr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StmntAttr -> r)
-> (forall u. (forall d. Data d => d -> u) -> StmntAttr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StmntAttr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr)
-> Data StmntAttr
StmntAttr -> Constr
StmntAttr -> DataType
(forall b. Data b => b -> b) -> StmntAttr -> StmntAttr
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StmntAttr -> c StmntAttr
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StmntAttr
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> StmntAttr -> u
forall u. (forall d. Data d => d -> u) -> StmntAttr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StmntAttr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StmntAttr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StmntAttr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StmntAttr -> c StmntAttr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StmntAttr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StmntAttr)
$cPrint :: Constr
$cNonexec :: Constr
$cOwise :: Constr
$cMetadata :: Constr
$cLabel :: Constr
$tStmntAttr :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
gmapMp :: (forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
gmapM :: (forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StmntAttr -> m StmntAttr
gmapQi :: Int -> (forall d. Data d => d -> u) -> StmntAttr -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StmntAttr -> u
gmapQ :: (forall d. Data d => d -> u) -> StmntAttr -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StmntAttr -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StmntAttr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StmntAttr -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StmntAttr -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StmntAttr -> r
gmapT :: (forall b. Data b => b -> b) -> StmntAttr -> StmntAttr
$cgmapT :: (forall b. Data b => b -> b) -> StmntAttr -> StmntAttr
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StmntAttr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StmntAttr)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c StmntAttr)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StmntAttr)
dataTypeOf :: StmntAttr -> DataType
$cdataTypeOf :: StmntAttr -> DataType
toConstr :: StmntAttr -> Constr
$ctoConstr :: StmntAttr -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StmntAttr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StmntAttr
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StmntAttr -> c StmntAttr
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StmntAttr -> c StmntAttr
$cp1Data :: Typeable StmntAttr
Data)

data Hook = IdHook Qid [Qid]
          | OpHook Qid Qid [Qid] Qid
          | TermHook Qid Term
          deriving (Int -> Hook -> ShowS
[Hook] -> ShowS
Hook -> String
(Int -> Hook -> ShowS)
-> (Hook -> String) -> ([Hook] -> ShowS) -> Show Hook
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Hook] -> ShowS
$cshowList :: [Hook] -> ShowS
show :: Hook -> String
$cshow :: Hook -> String
showsPrec :: Int -> Hook -> ShowS
$cshowsPrec :: Int -> Hook -> ShowS
Show, ReadPrec [Hook]
ReadPrec Hook
Int -> ReadS Hook
ReadS [Hook]
(Int -> ReadS Hook)
-> ReadS [Hook] -> ReadPrec Hook -> ReadPrec [Hook] -> Read Hook
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Hook]
$creadListPrec :: ReadPrec [Hook]
readPrec :: ReadPrec Hook
$creadPrec :: ReadPrec Hook
readList :: ReadS [Hook]
$creadList :: ReadS [Hook]
readsPrec :: Int -> ReadS Hook
$creadsPrec :: Int -> ReadS Hook
Read, Eq Hook
Eq Hook =>
(Hook -> Hook -> Ordering)
-> (Hook -> Hook -> Bool)
-> (Hook -> Hook -> Bool)
-> (Hook -> Hook -> Bool)
-> (Hook -> Hook -> Bool)
-> (Hook -> Hook -> Hook)
-> (Hook -> Hook -> Hook)
-> Ord Hook
Hook -> Hook -> Bool
Hook -> Hook -> Ordering
Hook -> Hook -> Hook
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Hook -> Hook -> Hook
$cmin :: Hook -> Hook -> Hook
max :: Hook -> Hook -> Hook
$cmax :: Hook -> Hook -> Hook
>= :: Hook -> Hook -> Bool
$c>= :: Hook -> Hook -> Bool
> :: Hook -> Hook -> Bool
$c> :: Hook -> Hook -> Bool
<= :: Hook -> Hook -> Bool
$c<= :: Hook -> Hook -> Bool
< :: Hook -> Hook -> Bool
$c< :: Hook -> Hook -> Bool
compare :: Hook -> Hook -> Ordering
$ccompare :: Hook -> Hook -> Ordering
$cp1Ord :: Eq Hook
Ord, Hook -> Hook -> Bool
(Hook -> Hook -> Bool) -> (Hook -> Hook -> Bool) -> Eq Hook
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Hook -> Hook -> Bool
$c/= :: Hook -> Hook -> Bool
== :: Hook -> Hook -> Bool
$c== :: Hook -> Hook -> Bool
Eq, Typeable, Typeable Hook
Constr
DataType
Typeable Hook =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Hook -> c Hook)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Hook)
-> (Hook -> Constr)
-> (Hook -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Hook))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hook))
-> ((forall b. Data b => b -> b) -> Hook -> Hook)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r)
-> (forall u. (forall d. Data d => d -> u) -> Hook -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Hook -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Hook -> m Hook)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Hook -> m Hook)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Hook -> m Hook)
-> Data Hook
Hook -> Constr
Hook -> DataType
(forall b. Data b => b -> b) -> Hook -> Hook
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Hook -> c Hook
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Hook
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Hook -> u
forall u. (forall d. Data d => d -> u) -> Hook -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Hook -> m Hook
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Hook -> m Hook
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Hook
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Hook -> c Hook
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Hook)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hook)
$cTermHook :: Constr
$cOpHook :: Constr
$cIdHook :: Constr
$tHook :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Hook -> m Hook
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Hook -> m Hook
gmapMp :: (forall d. Data d => d -> m d) -> Hook -> m Hook
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Hook -> m Hook
gmapM :: (forall d. Data d => d -> m d) -> Hook -> m Hook
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Hook -> m Hook
gmapQi :: Int -> (forall d. Data d => d -> u) -> Hook -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Hook -> u
gmapQ :: (forall d. Data d => d -> u) -> Hook -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Hook -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Hook -> r
gmapT :: (forall b. Data b => b -> b) -> Hook -> Hook
$cgmapT :: (forall b. Data b => b -> b) -> Hook -> Hook
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hook)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Hook)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Hook)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Hook)
dataTypeOf :: Hook -> DataType
$cdataTypeOf :: Hook -> DataType
toConstr :: Hook -> Constr
$ctoConstr :: Hook -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Hook
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Hook
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Hook -> c Hook
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Hook -> c Hook
$cp1Data :: Typeable Hook
Data)

data Term = Const Qid Type
          | Var Qid Type
          | Apply Qid [Term] Type
          deriving (Int -> Term -> ShowS
[Term] -> ShowS
Term -> String
(Int -> Term -> ShowS)
-> (Term -> String) -> ([Term] -> ShowS) -> Show Term
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Term] -> ShowS
$cshowList :: [Term] -> ShowS
show :: Term -> String
$cshow :: Term -> String
showsPrec :: Int -> Term -> ShowS
$cshowsPrec :: Int -> Term -> ShowS
Show, ReadPrec [Term]
ReadPrec Term
Int -> ReadS Term
ReadS [Term]
(Int -> ReadS Term)
-> ReadS [Term] -> ReadPrec Term -> ReadPrec [Term] -> Read Term
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Term]
$creadListPrec :: ReadPrec [Term]
readPrec :: ReadPrec Term
$creadPrec :: ReadPrec Term
readList :: ReadS [Term]
$creadList :: ReadS [Term]
readsPrec :: Int -> ReadS Term
$creadsPrec :: Int -> ReadS Term
Read, Eq Term
Eq Term =>
(Term -> Term -> Ordering)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Bool)
-> (Term -> Term -> Term)
-> (Term -> Term -> Term)
-> Ord Term
Term -> Term -> Bool
Term -> Term -> Ordering
Term -> Term -> Term
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Term -> Term -> Term
$cmin :: Term -> Term -> Term
max :: Term -> Term -> Term
$cmax :: Term -> Term -> Term
>= :: Term -> Term -> Bool
$c>= :: Term -> Term -> Bool
> :: Term -> Term -> Bool
$c> :: Term -> Term -> Bool
<= :: Term -> Term -> Bool
$c<= :: Term -> Term -> Bool
< :: Term -> Term -> Bool
$c< :: Term -> Term -> Bool
compare :: Term -> Term -> Ordering
$ccompare :: Term -> Term -> Ordering
$cp1Ord :: Eq Term
Ord, Term -> Term -> Bool
(Term -> Term -> Bool) -> (Term -> Term -> Bool) -> Eq Term
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Term -> Term -> Bool
$c/= :: Term -> Term -> Bool
== :: Term -> Term -> Bool
$c== :: Term -> Term -> Bool
Eq, Typeable, Typeable Term
Constr
DataType
Typeable Term =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Term -> c Term)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Term)
-> (Term -> Constr)
-> (Term -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Term))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term))
-> ((forall b. Data b => b -> b) -> Term -> Term)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r)
-> (forall u. (forall d. Data d => d -> u) -> Term -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Term -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Term -> m Term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Term -> m Term)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Term -> m Term)
-> Data Term
Term -> Constr
Term -> DataType
(forall b. Data b => b -> b) -> Term -> Term
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Term -> u
forall u. (forall d. Data d => d -> u) -> Term -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Term -> m Term
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term -> m Term
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Term)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term)
$cApply :: Constr
$cVar :: Constr
$cConst :: Constr
$tTerm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Term -> m Term
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term -> m Term
gmapMp :: (forall d. Data d => d -> m d) -> Term -> m Term
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term -> m Term
gmapM :: (forall d. Data d => d -> m d) -> Term -> m Term
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Term -> m Term
gmapQi :: Int -> (forall d. Data d => d -> u) -> Term -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Term -> u
gmapQ :: (forall d. Data d => d -> u) -> Term -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Term -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term -> r
gmapT :: (forall b. Data b => b -> b) -> Term -> Term
$cgmapT :: (forall b. Data b => b -> b) -> Term -> Term
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Term)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Term)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Term)
dataTypeOf :: Term -> DataType
$cdataTypeOf :: Term -> DataType
toConstr :: Term -> Constr
$ctoConstr :: Term -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Term
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term -> c Term
$cp1Data :: Typeable Term
Data)

data Type = TypeSort Sort
          | TypeKind Kind
          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, ReadPrec [Type]
ReadPrec Type
Int -> ReadS Type
ReadS [Type]
(Int -> ReadS Type)
-> ReadS [Type] -> ReadPrec Type -> ReadPrec [Type] -> Read Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Type]
$creadListPrec :: ReadPrec [Type]
readPrec :: ReadPrec Type
$creadPrec :: ReadPrec Type
readList :: ReadS [Type]
$creadList :: ReadS [Type]
readsPrec :: Int -> ReadS Type
$creadsPrec :: Int -> ReadS Type
Read, 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, 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, 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)
$cTypeKind :: Constr
$cTypeSort :: 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)

newtype Sort = SortId Qid
          deriving (Int -> Sort -> ShowS
[Sort] -> ShowS
Sort -> String
(Int -> Sort -> ShowS)
-> (Sort -> String) -> ([Sort] -> ShowS) -> Show Sort
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sort] -> ShowS
$cshowList :: [Sort] -> ShowS
show :: Sort -> String
$cshow :: Sort -> String
showsPrec :: Int -> Sort -> ShowS
$cshowsPrec :: Int -> Sort -> ShowS
Show, ReadPrec [Sort]
ReadPrec Sort
Int -> ReadS Sort
ReadS [Sort]
(Int -> ReadS Sort)
-> ReadS [Sort] -> ReadPrec Sort -> ReadPrec [Sort] -> Read Sort
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Sort]
$creadListPrec :: ReadPrec [Sort]
readPrec :: ReadPrec Sort
$creadPrec :: ReadPrec Sort
readList :: ReadS [Sort]
$creadList :: ReadS [Sort]
readsPrec :: Int -> ReadS Sort
$creadsPrec :: Int -> ReadS Sort
Read, Eq Sort
Eq Sort =>
(Sort -> Sort -> Ordering)
-> (Sort -> Sort -> Bool)
-> (Sort -> Sort -> Bool)
-> (Sort -> Sort -> Bool)
-> (Sort -> Sort -> Bool)
-> (Sort -> Sort -> Sort)
-> (Sort -> Sort -> Sort)
-> Ord Sort
Sort -> Sort -> Bool
Sort -> Sort -> Ordering
Sort -> Sort -> Sort
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Sort -> Sort -> Sort
$cmin :: Sort -> Sort -> Sort
max :: Sort -> Sort -> Sort
$cmax :: Sort -> Sort -> Sort
>= :: Sort -> Sort -> Bool
$c>= :: Sort -> Sort -> Bool
> :: Sort -> Sort -> Bool
$c> :: Sort -> Sort -> Bool
<= :: Sort -> Sort -> Bool
$c<= :: Sort -> Sort -> Bool
< :: Sort -> Sort -> Bool
$c< :: Sort -> Sort -> Bool
compare :: Sort -> Sort -> Ordering
$ccompare :: Sort -> Sort -> Ordering
$cp1Ord :: Eq Sort
Ord, Sort -> Sort -> Bool
(Sort -> Sort -> Bool) -> (Sort -> Sort -> Bool) -> Eq Sort
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sort -> Sort -> Bool
$c/= :: Sort -> Sort -> Bool
== :: Sort -> Sort -> Bool
$c== :: Sort -> Sort -> Bool
Eq, Typeable, Typeable Sort
Constr
DataType
Typeable Sort =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Sort -> c Sort)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Sort)
-> (Sort -> Constr)
-> (Sort -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Sort))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort))
-> ((forall b. Data b => b -> b) -> Sort -> Sort)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sort -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sort -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sort -> m Sort)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sort -> m Sort)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sort -> m Sort)
-> Data Sort
Sort -> Constr
Sort -> DataType
(forall b. Data b => b -> b) -> Sort -> Sort
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (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 -> u
forall u. (forall d. Data d => d -> u) -> Sort -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sort)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort)
$cSortId :: Constr
$tSort :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Sort -> m Sort
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
gmapMp :: (forall d. Data d => d -> m d) -> Sort -> m Sort
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
gmapM :: (forall d. Data d => d -> m d) -> Sort -> m Sort
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sort -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sort -> u
gmapQ :: (forall d. Data d => d -> u) -> Sort -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sort -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
gmapT :: (forall b. Data b => b -> b) -> Sort -> Sort
$cgmapT :: (forall b. Data b => b -> b) -> Sort -> Sort
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Sort)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sort)
dataTypeOf :: Sort -> DataType
$cdataTypeOf :: Sort -> DataType
toConstr :: Sort -> Constr
$ctoConstr :: Sort -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
$cp1Data :: Typeable Sort
Data)

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

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

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

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

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

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

-- * Construction

-- | Create a 'Var' 'Term' from the given arguments.
mkVar :: String -> Type -> Term
mkVar :: String -> Type -> Term
mkVar = Qid -> Type -> Term
Var (Qid -> Type -> Term) -> (String -> Qid) -> String -> Type -> Term
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Qid
mkSimpleId

-- * Information Extraction

-- | Extract the 'Type' from the given 'Term'.
getTermType :: Term -> Type
getTermType :: Term -> Type
getTermType term :: Term
term = case Term
term of
    Const _ typ :: Type
typ -> Type
typ
    Var _ typ :: Type
typ -> Type
typ
    Apply _ _ typ :: Type
typ -> Type
typ

-- * Attribute Classification

-- | True iff the argument is the @assoc@ attribute.
assoc :: Attr -> Bool
assoc :: Attr -> Bool
assoc attr :: Attr
attr = case Attr
attr of
    Assoc -> Bool
True
    _ -> Bool
False

-- | True iff the argument is the @comm@ attribute.
comm :: Attr -> Bool
comm :: Attr -> Bool
comm attr :: Attr
attr = case Attr
attr of
    Comm -> Bool
True
    _ -> Bool
False

-- | True iff the argument is the @idem@ attribute.
idem :: Attr -> Bool
idem :: Attr -> Bool
idem attr :: Attr
attr = case Attr
attr of
    Idem -> Bool
True
    _ -> Bool
False

-- | True iff the argument is the identity attribute.
idtty :: Attr -> Bool
idtty :: Attr -> Bool
idtty attr :: Attr
attr = case Attr
attr of
    Id _ -> Bool
True
    _ -> Bool
False

-- | True iff the argument is the left identity attribute.
leftId :: Attr -> Bool
leftId :: Attr -> Bool
leftId attr :: Attr
attr = case Attr
attr of
    LeftId _ -> Bool
True
    _ -> Bool
False

-- | True iff the argument is the right identity attribute.
rightId :: Attr -> Bool
rightId :: Attr -> Bool
rightId attr :: Attr
attr = case Attr
attr of
    RightId _ -> Bool
True
    _ -> Bool
False

-- | True iff the argument is the @ctor@ attribute.
ctor :: Attr -> Bool
ctor :: Attr -> Bool
ctor attr :: Attr
attr = case Attr
attr of
    Ctor -> Bool
True
    _ -> Bool
False

-- | True iff the argument is the @owise@ attribute.
owise :: StmntAttr -> Bool
owise :: StmntAttr -> Bool
owise attr :: StmntAttr
attr = case StmntAttr
attr of
    Owise -> Bool
True
    _ -> Bool
False