{-# LANGUAGE DeriveDataTypeable #-}
{- |
Module      :  ./Temporal/AS_BASIC_Temporal.hs
Description :  Abstract syntax of temporal basic specifications
Copyright   :  (c) Klaus Hartke, Uni Bremen 2008
License     :  GPLv2 or higher, see LICENSE.txt

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

pretty poor abstract syntax of temporal Basic_spec, Formula, Symb_items and
Symb_map_items.
-}

module Temporal.AS_BASIC_Temporal
    (
      FORMULA (..)
    , BASIC_SPEC (..)          -- Basic Spec
    , SYMB_ITEMS (..)          -- List of symbols
    , SYMB (..)                -- Symbols
    , SYMB_MAP_ITEMS (..)      -- Symbol map
    ) where

import Common.DocUtils
import Common.Doc
import Common.Id

import Data.Data

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

instance GetRange BASIC_SPEC

instance Pretty BASIC_SPEC where
   pretty :: BASIC_SPEC -> Doc
pretty = String -> Doc
text (String -> Doc) -> (BASIC_SPEC -> String) -> BASIC_SPEC -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BASIC_SPEC -> String
forall a. Show a => a -> String
show

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

instance GetRange FORMULA

instance Pretty FORMULA where
   pretty :: FORMULA -> Doc
pretty = String -> Doc
text (String -> Doc) -> (FORMULA -> String) -> FORMULA -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FORMULA -> String
forall a. Show a => a -> String
show

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

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

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