{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./CoCASL/AS_CoCASL.der.hs
Description :  Abstract syntax for CoCASL
Copyright   :  (c) T.Mossakowski, C.Maeder, Uni Bremen 2004-2006
License     :  GPLv2 or higher, see LICENSE.txt

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

Abstract syntax for CoCASL, the coalgebraic extension of CASL
  Only the added syntax is specified
-}

module CoCASL.AS_CoCASL where

import Common.Id
import Common.AS_Annotation

import CASL.AS_Basic_CASL

import Data.Data

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

type C_BASIC_SPEC = BASIC_SPEC C_BASIC_ITEM C_SIG_ITEM C_FORMULA

type AnModFORM = Annoted (FORMULA C_FORMULA)

data C_BASIC_ITEM = CoFree_datatype [Annoted CODATATYPE_DECL] Range
                   -- pos: free, type, semi colons
                  | CoSort_gen [Annoted (SIG_ITEMS C_SIG_ITEM C_FORMULA)] Range
                   -- pos: generated, opt. braces
                  deriving (Int -> C_BASIC_ITEM -> ShowS
[C_BASIC_ITEM] -> ShowS
C_BASIC_ITEM -> String
(Int -> C_BASIC_ITEM -> ShowS)
-> (C_BASIC_ITEM -> String)
-> ([C_BASIC_ITEM] -> ShowS)
-> Show C_BASIC_ITEM
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [C_BASIC_ITEM] -> ShowS
$cshowList :: [C_BASIC_ITEM] -> ShowS
show :: C_BASIC_ITEM -> String
$cshow :: C_BASIC_ITEM -> String
showsPrec :: Int -> C_BASIC_ITEM -> ShowS
$cshowsPrec :: Int -> C_BASIC_ITEM -> ShowS
Show, Typeable, Typeable C_BASIC_ITEM
Constr
DataType
Typeable C_BASIC_ITEM =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> C_BASIC_ITEM -> c C_BASIC_ITEM)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c C_BASIC_ITEM)
-> (C_BASIC_ITEM -> Constr)
-> (C_BASIC_ITEM -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c C_BASIC_ITEM))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c C_BASIC_ITEM))
-> ((forall b. Data b => b -> b) -> C_BASIC_ITEM -> C_BASIC_ITEM)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r)
-> (forall u. (forall d. Data d => d -> u) -> C_BASIC_ITEM -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> C_BASIC_ITEM -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM)
-> Data C_BASIC_ITEM
C_BASIC_ITEM -> Constr
C_BASIC_ITEM -> DataType
(forall b. Data b => b -> b) -> C_BASIC_ITEM -> C_BASIC_ITEM
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_BASIC_ITEM -> c C_BASIC_ITEM
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_BASIC_ITEM
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> C_BASIC_ITEM -> u
forall u. (forall d. Data d => d -> u) -> C_BASIC_ITEM -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_BASIC_ITEM
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_BASIC_ITEM -> c C_BASIC_ITEM
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c C_BASIC_ITEM)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c C_BASIC_ITEM)
$cCoSort_gen :: Constr
$cCoFree_datatype :: Constr
$tC_BASIC_ITEM :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
gmapMp :: (forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
gmapM :: (forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> C_BASIC_ITEM -> m C_BASIC_ITEM
gmapQi :: Int -> (forall d. Data d => d -> u) -> C_BASIC_ITEM -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> C_BASIC_ITEM -> u
gmapQ :: (forall d. Data d => d -> u) -> C_BASIC_ITEM -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> C_BASIC_ITEM -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> C_BASIC_ITEM -> r
gmapT :: (forall b. Data b => b -> b) -> C_BASIC_ITEM -> C_BASIC_ITEM
$cgmapT :: (forall b. Data b => b -> b) -> C_BASIC_ITEM -> C_BASIC_ITEM
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c C_BASIC_ITEM)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c C_BASIC_ITEM)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c C_BASIC_ITEM)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c C_BASIC_ITEM)
dataTypeOf :: C_BASIC_ITEM -> DataType
$cdataTypeOf :: C_BASIC_ITEM -> DataType
toConstr :: C_BASIC_ITEM -> Constr
$ctoConstr :: C_BASIC_ITEM -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_BASIC_ITEM
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_BASIC_ITEM
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_BASIC_ITEM -> c C_BASIC_ITEM
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_BASIC_ITEM -> c C_BASIC_ITEM
$cp1Data :: Typeable C_BASIC_ITEM
Data)

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

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

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

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

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

data C_FORMULA = BoxOrDiamond Bool MODALITY (FORMULA C_FORMULA) Range
               {- The identifier and the term specify the kind of the modality
               pos: "[]" or  "<>", True if Box, False if Diamond -}
               | CoSort_gen_ax [SORT] [OP_SYMB] Bool
               -- flag: belongs to a cofree type and hence is cofreeness axiom?
             deriving (Int -> C_FORMULA -> ShowS
[C_FORMULA] -> ShowS
C_FORMULA -> String
(Int -> C_FORMULA -> ShowS)
-> (C_FORMULA -> String)
-> ([C_FORMULA] -> ShowS)
-> Show C_FORMULA
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [C_FORMULA] -> ShowS
$cshowList :: [C_FORMULA] -> ShowS
show :: C_FORMULA -> String
$cshow :: C_FORMULA -> String
showsPrec :: Int -> C_FORMULA -> ShowS
$cshowsPrec :: Int -> C_FORMULA -> ShowS
Show, C_FORMULA -> C_FORMULA -> Bool
(C_FORMULA -> C_FORMULA -> Bool)
-> (C_FORMULA -> C_FORMULA -> Bool) -> Eq C_FORMULA
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: C_FORMULA -> C_FORMULA -> Bool
$c/= :: C_FORMULA -> C_FORMULA -> Bool
== :: C_FORMULA -> C_FORMULA -> Bool
$c== :: C_FORMULA -> C_FORMULA -> Bool
Eq, Eq C_FORMULA
Eq C_FORMULA =>
(C_FORMULA -> C_FORMULA -> Ordering)
-> (C_FORMULA -> C_FORMULA -> Bool)
-> (C_FORMULA -> C_FORMULA -> Bool)
-> (C_FORMULA -> C_FORMULA -> Bool)
-> (C_FORMULA -> C_FORMULA -> Bool)
-> (C_FORMULA -> C_FORMULA -> C_FORMULA)
-> (C_FORMULA -> C_FORMULA -> C_FORMULA)
-> Ord C_FORMULA
C_FORMULA -> C_FORMULA -> Bool
C_FORMULA -> C_FORMULA -> Ordering
C_FORMULA -> C_FORMULA -> C_FORMULA
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: C_FORMULA -> C_FORMULA -> C_FORMULA
$cmin :: C_FORMULA -> C_FORMULA -> C_FORMULA
max :: C_FORMULA -> C_FORMULA -> C_FORMULA
$cmax :: C_FORMULA -> C_FORMULA -> C_FORMULA
>= :: C_FORMULA -> C_FORMULA -> Bool
$c>= :: C_FORMULA -> C_FORMULA -> Bool
> :: C_FORMULA -> C_FORMULA -> Bool
$c> :: C_FORMULA -> C_FORMULA -> Bool
<= :: C_FORMULA -> C_FORMULA -> Bool
$c<= :: C_FORMULA -> C_FORMULA -> Bool
< :: C_FORMULA -> C_FORMULA -> Bool
$c< :: C_FORMULA -> C_FORMULA -> Bool
compare :: C_FORMULA -> C_FORMULA -> Ordering
$ccompare :: C_FORMULA -> C_FORMULA -> Ordering
$cp1Ord :: Eq C_FORMULA
Ord, Typeable, Typeable C_FORMULA
Constr
DataType
Typeable C_FORMULA =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> C_FORMULA -> c C_FORMULA)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c C_FORMULA)
-> (C_FORMULA -> Constr)
-> (C_FORMULA -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c C_FORMULA))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c C_FORMULA))
-> ((forall b. Data b => b -> b) -> C_FORMULA -> C_FORMULA)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r)
-> (forall u. (forall d. Data d => d -> u) -> C_FORMULA -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> C_FORMULA -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA)
-> Data C_FORMULA
C_FORMULA -> Constr
C_FORMULA -> DataType
(forall b. Data b => b -> b) -> C_FORMULA -> C_FORMULA
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_FORMULA -> c C_FORMULA
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_FORMULA
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> C_FORMULA -> u
forall u. (forall d. Data d => d -> u) -> C_FORMULA -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_FORMULA
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_FORMULA -> c C_FORMULA
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c C_FORMULA)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c C_FORMULA)
$cCoSort_gen_ax :: Constr
$cBoxOrDiamond :: Constr
$tC_FORMULA :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
gmapMp :: (forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
gmapM :: (forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> C_FORMULA -> m C_FORMULA
gmapQi :: Int -> (forall d. Data d => d -> u) -> C_FORMULA -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> C_FORMULA -> u
gmapQ :: (forall d. Data d => d -> u) -> C_FORMULA -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> C_FORMULA -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> C_FORMULA -> r
gmapT :: (forall b. Data b => b -> b) -> C_FORMULA -> C_FORMULA
$cgmapT :: (forall b. Data b => b -> b) -> C_FORMULA -> C_FORMULA
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c C_FORMULA)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c C_FORMULA)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c C_FORMULA)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c C_FORMULA)
dataTypeOf :: C_FORMULA -> DataType
$cdataTypeOf :: C_FORMULA -> DataType
toConstr :: C_FORMULA -> Constr
$ctoConstr :: C_FORMULA -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_FORMULA
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c C_FORMULA
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_FORMULA -> c C_FORMULA
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> C_FORMULA -> c C_FORMULA
$cp1Data :: Typeable C_FORMULA
Data)

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

instance GetRange C_BASIC_ITEM where
  getRange :: C_BASIC_ITEM -> Range
getRange x :: C_BASIC_ITEM
x = case C_BASIC_ITEM
x of
    CoFree_datatype _ p :: Range
p -> Range
p
    CoSort_gen _ p :: Range
p -> Range
p
  rangeSpan :: C_BASIC_ITEM -> [Pos]
rangeSpan x :: C_BASIC_ITEM
x = case C_BASIC_ITEM
x of
    CoFree_datatype a :: [Annoted CODATATYPE_DECL]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[Annoted CODATATYPE_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted CODATATYPE_DECL]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]
    CoSort_gen a :: [Annoted (SIG_ITEMS C_SIG_ITEM C_FORMULA)]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[Annoted (SIG_ITEMS C_SIG_ITEM C_FORMULA)] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted (SIG_ITEMS C_SIG_ITEM C_FORMULA)]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

instance GetRange C_SIG_ITEM where
  getRange :: C_SIG_ITEM -> Range
getRange x :: C_SIG_ITEM
x = case C_SIG_ITEM
x of
    CoDatatype_items _ p :: Range
p -> Range
p
  rangeSpan :: C_SIG_ITEM -> [Pos]
rangeSpan x :: C_SIG_ITEM
x = case C_SIG_ITEM
x of
    CoDatatype_items a :: [Annoted CODATATYPE_DECL]
a b :: Range
b -> [[Pos]] -> [Pos]
joinRanges [[Annoted CODATATYPE_DECL] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [Annoted CODATATYPE_DECL]
a, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
b]

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

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

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

instance GetRange MODALITY where
  getRange :: MODALITY -> Range
getRange = Range -> MODALITY -> Range
forall a b. a -> b -> a
const Range
nullRange
  rangeSpan :: MODALITY -> [Pos]
rangeSpan x :: MODALITY
x = case MODALITY
x of
    Simple_mod a :: SIMPLE_ID
a -> [[Pos]] -> [Pos]
joinRanges [SIMPLE_ID -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan SIMPLE_ID
a]
    Term_mod a :: TERM C_FORMULA
a -> [[Pos]] -> [Pos]
joinRanges [TERM C_FORMULA -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan TERM C_FORMULA
a]

instance GetRange C_FORMULA where
  getRange :: C_FORMULA -> Range
getRange x :: C_FORMULA
x = case C_FORMULA
x of
    BoxOrDiamond _ _ _ p :: Range
p -> Range
p
    CoSort_gen_ax _ _ _ -> Range
nullRange
  rangeSpan :: C_FORMULA -> [Pos]
rangeSpan x :: C_FORMULA
x = case C_FORMULA
x of
    BoxOrDiamond a :: Bool
a b :: MODALITY
b c :: FORMULA C_FORMULA
c d :: Range
d -> [[Pos]] -> [Pos]
joinRanges [Bool -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Bool
a, MODALITY -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan MODALITY
b,
                                        FORMULA C_FORMULA -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan FORMULA C_FORMULA
c, Range -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Range
d]
    CoSort_gen_ax a :: [SORT]
a b :: [OP_SYMB]
b c :: Bool
c -> [[Pos]] -> [Pos]
joinRanges [[SORT] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [SORT]
a, [OP_SYMB] -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan [OP_SYMB]
b,
                                       Bool -> [Pos]
forall a. GetRange a => a -> [Pos]
rangeSpan Bool
c]