{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, DeriveDataTypeable #-}
{- |
Module      :  ./CSL/AS_BASIC_CSL.hs
Description :  Abstract syntax for EnCL
Copyright   :  (c) Dominik Dietrich, Ewaryst Schulz, DFKI Bremen 2010
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  Ewaryst.Schulz@dfki.de
Stability   :  experimental
Portability :  portable

This module contains the abstract syntax types for EnCL as well as the
predefined operator configuration.

-}

module CSL.AS_BASIC_CSL
    ( EXPRESSION (..)     {- datatype for numerical expressions
                             (e.g. polynomials) -}
    , EXTPARAM (..)       -- datatype for extended parameters (e.g. [I=0])
    , BASIC_ITEM (..)    -- Items of a Basic Spec
    , BASIC_SPEC (..)     -- Basic Spec
    , SYMB_ITEMS (..)     -- List of symbols
    , SYMB (..)           -- Symbols
    , SYMB_MAP_ITEMS (..) -- Symbol map
    , SYMB_OR_MAP (..)    -- Symbol or symbol map
    , OPNAME (..)         -- predefined operator names
    , OPID (..)           -- identifier for operators
    , ConstantName (..)   -- names of user-defined constants
    , OP_ITEM (..)        -- operator declaration
    , VAR_ITEM (..)       -- variable declaration
    , VarDecl (..)        -- variable declaration in assignment
    , OpDecl (..)         -- operator declaration in assignment
    , EPDecl (..)         -- extparam declaration
    , EPVal (..)          -- extparam values
    , getEPVarRef
    , Domain              -- domains for variable declarations
    , EPDomain            -- domains for extended parameter declarations
    , GroundConstant (..) -- constants for domain formation
    , cmpFloatToInt       -- comparer for APFloat with APInt
    , AssDefinition (..)  -- A function or constant definition
    , InstantiatedConstant (..) {- for function constants we need to store the
                               instantiation -}
    , CMD (..)            -- Command datatype
    , OperatorState (..)  -- Class providing operator lookup


    , OpInfo (..)         -- Type for Operator information
    , BindInfo (..)       -- Type for Binder information
    , operatorInfo        {- Operator information for pretty printing
                          and static analysis -}
    , operatorInfoMap     -- allows efficient lookup of ops by printname
    , operatorInfoNameMap -- allows efficient lookup of ops by opname
    , operatorBindInfoMap
    , mergeOpArityMap     -- for combining two operator arity maps
    , getOpInfoMap
    , getOpInfoNameMap
    , getBindInfoMap
    , lookupOpInfo
    , lookupOpInfoForParsing
    , lookupBindInfo
    , APInt, APFloat      -- arbitrary precision numbers
    , toFraction, fromFraction
    , OpInfoMap
    , OpInfoNameMap
    , BindInfoMap
    , showOPNAME
    , maxPrecedence
    ) where

import Common.Id as Id
import Common.AS_Annotation as AS_Anno

import Data.Data
import qualified Data.Map as Map
import Data.Ratio

import CSL.TreePO


{- ---------------------------------------------------------------------------
EnCL Basic Data Structures and utils
--------------------------------------------------------------------------- -}

-- Arbitrary precision numbers
type APInt = Integer
type APFloat = Rational

cmpFloatToInt :: APFloat -> APInt -> Ordering
cmpFloatToInt :: APFloat -> APInt -> Ordering
cmpFloatToInt a :: APFloat
a b :: APInt
b = APFloat -> APFloat -> Ordering
forall a. Ord a => a -> a -> Ordering
compare APFloat
a (APFloat -> Ordering) -> APFloat -> Ordering
forall a b. (a -> b) -> a -> b
$ APInt -> APInt -> APFloat
fromFraction APInt
b 1

fromFraction :: Integer -> Integer -> APFloat
fromFraction :: APInt -> APInt -> APFloat
fromFraction = APInt -> APInt -> APFloat
forall a. Integral a => a -> a -> Ratio a
(%)

toFraction :: APFloat -> (Integer, Integer)
toFraction :: APFloat -> (APInt, APInt)
toFraction r :: APFloat
r = (APFloat -> APInt
forall a. Ratio a -> a
numerator APFloat
r, APFloat -> APInt
forall a. Ratio a -> a
denominator APFloat
r)

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

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

newtype BASIC_SPEC = Basic_spec [AS_Anno.Annoted BASIC_ITEM]
                  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)

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

cmpGCs :: GroundConstant -> GroundConstant -> Ordering
cmpGCs :: GroundConstant -> GroundConstant -> Ordering
cmpGCs (GCI a :: APInt
a) (GCI b :: APInt
b) = APInt -> APInt -> Ordering
forall a. Ord a => a -> a -> Ordering
compare APInt
a APInt
b
cmpGCs (GCR a :: APFloat
a) (GCR b :: APFloat
b) = APFloat -> APFloat -> Ordering
forall a. Ord a => a -> a -> Ordering
compare APFloat
a APFloat
b
cmpGCs (GCI a :: APInt
a) (GCR b :: APFloat
b) = Ordering -> Ordering
swapCompare (Ordering -> Ordering) -> Ordering -> Ordering
forall a b. (a -> b) -> a -> b
$ APFloat -> APInt -> Ordering
cmpFloatToInt APFloat
b APInt
a
cmpGCs (GCR a :: APFloat
a) (GCI b :: APInt
b) = APFloat -> APInt -> Ordering
cmpFloatToInt APFloat
a APInt
b

instance Eq GroundConstant where
    a :: GroundConstant
a == :: GroundConstant -> GroundConstant -> Bool
== b :: GroundConstant
b = GroundConstant -> GroundConstant -> Ordering
cmpGCs GroundConstant
a GroundConstant
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ

instance Ord GroundConstant where
    compare :: GroundConstant -> GroundConstant -> Ordering
compare = GroundConstant -> GroundConstant -> Ordering
cmpGCs

instance Continuous GroundConstant

type Domain = SetOrInterval GroundConstant
type EPDomain = ClosedInterval EPVal

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

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

{- | basic items: an operator, extended parameter or variable
     declaration or an axiom -}
data BASIC_ITEM =
    Op_decl OP_ITEM
    | EP_decl [(Id.Token, EPDomain)]
    | EP_domdecl [(Id.Token, APInt)]
    | EP_defval [(Id.Token, APInt)]
    | Var_decls [VAR_ITEM]
    | Axiom_item (AS_Anno.Annoted CMD)
    deriving (Int -> BASIC_ITEM -> ShowS
[BASIC_ITEM] -> ShowS
BASIC_ITEM -> String
(Int -> BASIC_ITEM -> ShowS)
-> (BASIC_ITEM -> String)
-> ([BASIC_ITEM] -> ShowS)
-> Show BASIC_ITEM
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BASIC_ITEM] -> ShowS
$cshowList :: [BASIC_ITEM] -> ShowS
show :: BASIC_ITEM -> String
$cshow :: BASIC_ITEM -> String
showsPrec :: Int -> BASIC_ITEM -> ShowS
$cshowsPrec :: Int -> BASIC_ITEM -> ShowS
Show, Typeable, Typeable BASIC_ITEM
Constr
DataType
Typeable BASIC_ITEM =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BASIC_ITEM -> c BASIC_ITEM)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BASIC_ITEM)
-> (BASIC_ITEM -> Constr)
-> (BASIC_ITEM -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BASIC_ITEM))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BASIC_ITEM))
-> ((forall b. Data b => b -> b) -> BASIC_ITEM -> BASIC_ITEM)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r)
-> (forall u. (forall d. Data d => d -> u) -> BASIC_ITEM -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BASIC_ITEM -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM)
-> Data BASIC_ITEM
BASIC_ITEM -> Constr
BASIC_ITEM -> DataType
(forall b. Data b => b -> b) -> BASIC_ITEM -> BASIC_ITEM
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BASIC_ITEM -> c BASIC_ITEM
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> 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) -> BASIC_ITEM -> u
forall u. (forall d. Data d => d -> u) -> BASIC_ITEM -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BASIC_ITEM
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BASIC_ITEM -> c BASIC_ITEM
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BASIC_ITEM)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BASIC_ITEM)
$cAxiom_item :: Constr
$cVar_decls :: Constr
$cEP_defval :: Constr
$cEP_domdecl :: Constr
$cEP_decl :: Constr
$cOp_decl :: Constr
$tBASIC_ITEM :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
gmapMp :: (forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
gmapM :: (forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BASIC_ITEM -> m BASIC_ITEM
gmapQi :: Int -> (forall d. Data d => d -> u) -> BASIC_ITEM -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BASIC_ITEM -> u
gmapQ :: (forall d. Data d => d -> u) -> BASIC_ITEM -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BASIC_ITEM -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BASIC_ITEM -> r
gmapT :: (forall b. Data b => b -> b) -> BASIC_ITEM -> BASIC_ITEM
$cgmapT :: (forall b. Data b => b -> b) -> BASIC_ITEM -> BASIC_ITEM
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BASIC_ITEM)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BASIC_ITEM)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BASIC_ITEM)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BASIC_ITEM)
dataTypeOf :: BASIC_ITEM -> DataType
$cdataTypeOf :: BASIC_ITEM -> DataType
toConstr :: BASIC_ITEM -> Constr
$ctoConstr :: BASIC_ITEM -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BASIC_ITEM
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BASIC_ITEM
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BASIC_ITEM -> c BASIC_ITEM
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BASIC_ITEM -> c BASIC_ITEM
$cp1Data :: Typeable BASIC_ITEM
Data)

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

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

{- | Extended Parameter value may be an integer or a reference to an 'EPDomVal'.
This type is used for the domain specification of EPs (see 'EPDomain'). -}
data EPVal = EPVal APInt | EPConstRef Id.Token
  deriving (EPVal -> EPVal -> Bool
(EPVal -> EPVal -> Bool) -> (EPVal -> EPVal -> Bool) -> Eq EPVal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EPVal -> EPVal -> Bool
$c/= :: EPVal -> EPVal -> Bool
== :: EPVal -> EPVal -> Bool
$c== :: EPVal -> EPVal -> Bool
Eq, Eq EPVal
Eq EPVal =>
(EPVal -> EPVal -> Ordering)
-> (EPVal -> EPVal -> Bool)
-> (EPVal -> EPVal -> Bool)
-> (EPVal -> EPVal -> Bool)
-> (EPVal -> EPVal -> Bool)
-> (EPVal -> EPVal -> EPVal)
-> (EPVal -> EPVal -> EPVal)
-> Ord EPVal
EPVal -> EPVal -> Bool
EPVal -> EPVal -> Ordering
EPVal -> EPVal -> EPVal
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 :: EPVal -> EPVal -> EPVal
$cmin :: EPVal -> EPVal -> EPVal
max :: EPVal -> EPVal -> EPVal
$cmax :: EPVal -> EPVal -> EPVal
>= :: EPVal -> EPVal -> Bool
$c>= :: EPVal -> EPVal -> Bool
> :: EPVal -> EPVal -> Bool
$c> :: EPVal -> EPVal -> Bool
<= :: EPVal -> EPVal -> Bool
$c<= :: EPVal -> EPVal -> Bool
< :: EPVal -> EPVal -> Bool
$c< :: EPVal -> EPVal -> Bool
compare :: EPVal -> EPVal -> Ordering
$ccompare :: EPVal -> EPVal -> Ordering
$cp1Ord :: Eq EPVal
Ord, Int -> EPVal -> ShowS
[EPVal] -> ShowS
EPVal -> String
(Int -> EPVal -> ShowS)
-> (EPVal -> String) -> ([EPVal] -> ShowS) -> Show EPVal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EPVal] -> ShowS
$cshowList :: [EPVal] -> ShowS
show :: EPVal -> String
$cshow :: EPVal -> String
showsPrec :: Int -> EPVal -> ShowS
$cshowsPrec :: Int -> EPVal -> ShowS
Show, Typeable, Typeable EPVal
Constr
DataType
Typeable EPVal =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EPVal -> c EPVal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EPVal)
-> (EPVal -> Constr)
-> (EPVal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EPVal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPVal))
-> ((forall b. Data b => b -> b) -> EPVal -> EPVal)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r)
-> (forall u. (forall d. Data d => d -> u) -> EPVal -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> EPVal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EPVal -> m EPVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EPVal -> m EPVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EPVal -> m EPVal)
-> Data EPVal
EPVal -> Constr
EPVal -> DataType
(forall b. Data b => b -> b) -> EPVal -> EPVal
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPVal -> c EPVal
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPVal
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) -> EPVal -> u
forall u. (forall d. Data d => d -> u) -> EPVal -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EPVal -> m EPVal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EPVal -> m EPVal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPVal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPVal -> c EPVal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EPVal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPVal)
$cEPConstRef :: Constr
$cEPVal :: Constr
$tEPVal :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> EPVal -> m EPVal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EPVal -> m EPVal
gmapMp :: (forall d. Data d => d -> m d) -> EPVal -> m EPVal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EPVal -> m EPVal
gmapM :: (forall d. Data d => d -> m d) -> EPVal -> m EPVal
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EPVal -> m EPVal
gmapQi :: Int -> (forall d. Data d => d -> u) -> EPVal -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EPVal -> u
gmapQ :: (forall d. Data d => d -> u) -> EPVal -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EPVal -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EPVal -> r
gmapT :: (forall b. Data b => b -> b) -> EPVal -> EPVal
$cgmapT :: (forall b. Data b => b -> b) -> EPVal -> EPVal
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPVal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EPVal)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EPVal)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EPVal)
dataTypeOf :: EPVal -> DataType
$cdataTypeOf :: EPVal -> DataType
toConstr :: EPVal -> Constr
$ctoConstr :: EPVal -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPVal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EPVal
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPVal -> c EPVal
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EPVal -> c EPVal
$cp1Data :: Typeable EPVal
Data)

getEPVarRef :: EPVal -> Maybe Id.Token
getEPVarRef :: EPVal -> Maybe Token
getEPVarRef (EPConstRef tok :: Token
tok) = Token -> Maybe Token
forall a. a -> Maybe a
Just Token
tok
getEPVarRef _ = Maybe Token
forall a. Maybe a
Nothing

data OPNAME =
    -- arithmetic operators
    OP_mult | OP_div | OP_plus | OP_minus | OP_neg | OP_pow
    -- roots, trigonometric and other operators
  | OP_fthrt | OP_sqrt | OP_abs | OP_max | OP_min | OP_sign
  | OP_cos | OP_sin | OP_tan | OP_cot | OP_Pi
  | OP_reldist

  -- special CAS operators
  | OP_minimize | OP_minloc | OP_maximize | OP_maxloc | OP_factor | OP_approx
  | OP_divide | OP_factorize | OP_int | OP_rlqe | OP_simplify | OP_solve

  -- comparison predicates
  | OP_neq | OP_lt | OP_leq | OP_eq | OP_gt | OP_geq | OP_convergence
  | OP_reldistLe

  -- containment predicate
  | OP_in

  -- special CAS constants
  | OP_undef | OP_failure

  -- boolean constants and connectives
  | OP_false | OP_true | OP_not | OP_and | OP_or | OP_impl

  -- quantifiers
  | OP_ex | OP_all

  -- types
  | OP_hastype | OP_real

    deriving (OPNAME -> OPNAME -> Bool
(OPNAME -> OPNAME -> Bool)
-> (OPNAME -> OPNAME -> Bool) -> Eq OPNAME
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OPNAME -> OPNAME -> Bool
$c/= :: OPNAME -> OPNAME -> Bool
== :: OPNAME -> OPNAME -> Bool
$c== :: OPNAME -> OPNAME -> Bool
Eq, Eq OPNAME
Eq OPNAME =>
(OPNAME -> OPNAME -> Ordering)
-> (OPNAME -> OPNAME -> Bool)
-> (OPNAME -> OPNAME -> Bool)
-> (OPNAME -> OPNAME -> Bool)
-> (OPNAME -> OPNAME -> Bool)
-> (OPNAME -> OPNAME -> OPNAME)
-> (OPNAME -> OPNAME -> OPNAME)
-> Ord OPNAME
OPNAME -> OPNAME -> Bool
OPNAME -> OPNAME -> Ordering
OPNAME -> OPNAME -> OPNAME
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 :: OPNAME -> OPNAME -> OPNAME
$cmin :: OPNAME -> OPNAME -> OPNAME
max :: OPNAME -> OPNAME -> OPNAME
$cmax :: OPNAME -> OPNAME -> OPNAME
>= :: OPNAME -> OPNAME -> Bool
$c>= :: OPNAME -> OPNAME -> Bool
> :: OPNAME -> OPNAME -> Bool
$c> :: OPNAME -> OPNAME -> Bool
<= :: OPNAME -> OPNAME -> Bool
$c<= :: OPNAME -> OPNAME -> Bool
< :: OPNAME -> OPNAME -> Bool
$c< :: OPNAME -> OPNAME -> Bool
compare :: OPNAME -> OPNAME -> Ordering
$ccompare :: OPNAME -> OPNAME -> Ordering
$cp1Ord :: Eq OPNAME
Ord, Typeable, Typeable OPNAME
Constr
DataType
Typeable OPNAME =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OPNAME -> c OPNAME)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OPNAME)
-> (OPNAME -> Constr)
-> (OPNAME -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OPNAME))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OPNAME))
-> ((forall b. Data b => b -> b) -> OPNAME -> OPNAME)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OPNAME -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OPNAME -> r)
-> (forall u. (forall d. Data d => d -> u) -> OPNAME -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OPNAME -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OPNAME -> m OPNAME)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OPNAME -> m OPNAME)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OPNAME -> m OPNAME)
-> Data OPNAME
OPNAME -> Constr
OPNAME -> DataType
(forall b. Data b => b -> b) -> OPNAME -> OPNAME
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OPNAME -> c OPNAME
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OPNAME
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) -> OPNAME -> u
forall u. (forall d. Data d => d -> u) -> OPNAME -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OPNAME -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OPNAME -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OPNAME
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OPNAME -> c OPNAME
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OPNAME)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OPNAME)
$cOP_real :: Constr
$cOP_hastype :: Constr
$cOP_all :: Constr
$cOP_ex :: Constr
$cOP_impl :: Constr
$cOP_or :: Constr
$cOP_and :: Constr
$cOP_not :: Constr
$cOP_true :: Constr
$cOP_false :: Constr
$cOP_failure :: Constr
$cOP_undef :: Constr
$cOP_in :: Constr
$cOP_reldistLe :: Constr
$cOP_convergence :: Constr
$cOP_geq :: Constr
$cOP_gt :: Constr
$cOP_eq :: Constr
$cOP_leq :: Constr
$cOP_lt :: Constr
$cOP_neq :: Constr
$cOP_solve :: Constr
$cOP_simplify :: Constr
$cOP_rlqe :: Constr
$cOP_int :: Constr
$cOP_factorize :: Constr
$cOP_divide :: Constr
$cOP_approx :: Constr
$cOP_factor :: Constr
$cOP_maxloc :: Constr
$cOP_maximize :: Constr
$cOP_minloc :: Constr
$cOP_minimize :: Constr
$cOP_reldist :: Constr
$cOP_Pi :: Constr
$cOP_cot :: Constr
$cOP_tan :: Constr
$cOP_sin :: Constr
$cOP_cos :: Constr
$cOP_sign :: Constr
$cOP_min :: Constr
$cOP_max :: Constr
$cOP_abs :: Constr
$cOP_sqrt :: Constr
$cOP_fthrt :: Constr
$cOP_pow :: Constr
$cOP_neg :: Constr
$cOP_minus :: Constr
$cOP_plus :: Constr
$cOP_div :: Constr
$cOP_mult :: Constr
$tOPNAME :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
gmapMp :: (forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
gmapM :: (forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OPNAME -> m OPNAME
gmapQi :: Int -> (forall d. Data d => d -> u) -> OPNAME -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OPNAME -> u
gmapQ :: (forall d. Data d => d -> u) -> OPNAME -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OPNAME -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OPNAME -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OPNAME -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OPNAME -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OPNAME -> r
gmapT :: (forall b. Data b => b -> b) -> OPNAME -> OPNAME
$cgmapT :: (forall b. Data b => b -> b) -> OPNAME -> OPNAME
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OPNAME)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OPNAME)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OPNAME)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OPNAME)
dataTypeOf :: OPNAME -> DataType
$cdataTypeOf :: OPNAME -> DataType
toConstr :: OPNAME -> Constr
$ctoConstr :: OPNAME -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OPNAME
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OPNAME
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OPNAME -> c OPNAME
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OPNAME -> c OPNAME
$cp1Data :: Typeable OPNAME
Data)

instance Show OPNAME where
    show :: OPNAME -> String
show = OPNAME -> String
showOPNAME

showOPNAME :: OPNAME -> String
showOPNAME :: OPNAME -> String
showOPNAME x :: OPNAME
x =
        case OPNAME
x of
          OP_neq -> "!="
          OP_mult -> "*"
          OP_plus -> "+"
          OP_minus -> "-"
          OP_neg -> "-"
          OP_div -> "/"
          OP_lt -> "<"
          OP_leq -> "<="
          OP_eq -> "="
          OP_gt -> ">"
          OP_geq -> ">="
          OP_Pi -> "Pi"
          OP_pow -> "^"
          OP_abs -> "abs"
          OP_sign -> "sign"
          OP_all -> "all"
          OP_and -> "and"
          OP_convergence -> "convergence"
          OP_cos -> "cos"
          OP_divide -> "divide"
          OP_ex -> "ex"
          OP_factor -> "factor"
          OP_factorize -> "factorize"
          OP_fthrt -> "fthrt"
          OP_impl -> "impl"
          OP_int -> "int"
          OP_max -> "max"
          OP_maximize -> "maximize"
          OP_maxloc -> "maxloc"
          OP_min -> "min"
          OP_minimize -> "minimize"
          OP_minloc -> "minloc"
          OP_not -> "not"
          OP_or -> "or"
          OP_reldist -> "reldist"
          OP_reldistLe -> "reldistLe"
          OP_rlqe -> "rlqe"
          OP_simplify -> "simplify"
          OP_sin -> "sin"
          OP_solve -> "solve"
          OP_sqrt -> "sqrt"
          OP_tan -> "tan"
          OP_cot -> "cot"
          OP_false -> "false"
          OP_true -> "true"
          OP_in -> "in"
          OP_approx -> "approx"

          OP_undef -> "undef"
          OP_failure -> "fail"

          OP_hastype -> "::"
          OP_real -> "real"

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

{- | We differentiate between simple constant names and indexed constant names
resulting from the extended parameter elimination. -}
data ConstantName = SimpleConstant String | ElimConstant String Int
                    deriving (ConstantName -> ConstantName -> Bool
(ConstantName -> ConstantName -> Bool)
-> (ConstantName -> ConstantName -> Bool) -> Eq ConstantName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstantName -> ConstantName -> Bool
$c/= :: ConstantName -> ConstantName -> Bool
== :: ConstantName -> ConstantName -> Bool
$c== :: ConstantName -> ConstantName -> Bool
Eq, Eq ConstantName
Eq ConstantName =>
(ConstantName -> ConstantName -> Ordering)
-> (ConstantName -> ConstantName -> Bool)
-> (ConstantName -> ConstantName -> Bool)
-> (ConstantName -> ConstantName -> Bool)
-> (ConstantName -> ConstantName -> Bool)
-> (ConstantName -> ConstantName -> ConstantName)
-> (ConstantName -> ConstantName -> ConstantName)
-> Ord ConstantName
ConstantName -> ConstantName -> Bool
ConstantName -> ConstantName -> Ordering
ConstantName -> ConstantName -> ConstantName
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 :: ConstantName -> ConstantName -> ConstantName
$cmin :: ConstantName -> ConstantName -> ConstantName
max :: ConstantName -> ConstantName -> ConstantName
$cmax :: ConstantName -> ConstantName -> ConstantName
>= :: ConstantName -> ConstantName -> Bool
$c>= :: ConstantName -> ConstantName -> Bool
> :: ConstantName -> ConstantName -> Bool
$c> :: ConstantName -> ConstantName -> Bool
<= :: ConstantName -> ConstantName -> Bool
$c<= :: ConstantName -> ConstantName -> Bool
< :: ConstantName -> ConstantName -> Bool
$c< :: ConstantName -> ConstantName -> Bool
compare :: ConstantName -> ConstantName -> Ordering
$ccompare :: ConstantName -> ConstantName -> Ordering
$cp1Ord :: Eq ConstantName
Ord, Int -> ConstantName -> ShowS
[ConstantName] -> ShowS
ConstantName -> String
(Int -> ConstantName -> ShowS)
-> (ConstantName -> String)
-> ([ConstantName] -> ShowS)
-> Show ConstantName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstantName] -> ShowS
$cshowList :: [ConstantName] -> ShowS
show :: ConstantName -> String
$cshow :: ConstantName -> String
showsPrec :: Int -> ConstantName -> ShowS
$cshowsPrec :: Int -> ConstantName -> ShowS
Show, Typeable, Typeable ConstantName
Constr
DataType
Typeable ConstantName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ConstantName -> c ConstantName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConstantName)
-> (ConstantName -> Constr)
-> (ConstantName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConstantName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ConstantName))
-> ((forall b. Data b => b -> b) -> ConstantName -> ConstantName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConstantName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConstantName -> r)
-> (forall u. (forall d. Data d => d -> u) -> ConstantName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ConstantName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConstantName -> m ConstantName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConstantName -> m ConstantName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConstantName -> m ConstantName)
-> Data ConstantName
ConstantName -> Constr
ConstantName -> DataType
(forall b. Data b => b -> b) -> ConstantName -> ConstantName
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstantName -> c ConstantName
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstantName
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) -> ConstantName -> u
forall u. (forall d. Data d => d -> u) -> ConstantName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstantName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstantName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstantName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstantName -> c ConstantName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstantName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstantName)
$cElimConstant :: Constr
$cSimpleConstant :: Constr
$tConstantName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
gmapMp :: (forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
gmapM :: (forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstantName -> m ConstantName
gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstantName -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConstantName -> u
gmapQ :: (forall d. Data d => d -> u) -> ConstantName -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConstantName -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstantName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstantName -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstantName -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstantName -> r
gmapT :: (forall b. Data b => b -> b) -> ConstantName -> ConstantName
$cgmapT :: (forall b. Data b => b -> b) -> ConstantName -> ConstantName
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstantName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstantName)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ConstantName)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstantName)
dataTypeOf :: ConstantName -> DataType
$cdataTypeOf :: ConstantName -> DataType
toConstr :: ConstantName -> Constr
$ctoConstr :: ConstantName -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstantName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstantName
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstantName -> c ConstantName
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstantName -> c ConstantName
$cp1Data :: Typeable ConstantName
Data)

{-
instance Show OPID where
    show (OpId n) = show n
    show (OpUser s) = show s

instance Show ConstantName where
    show (SimpleConstant s) = s
    show (ElimConstant s i) = if i > 0 then s ++ "__" ++ show i else s
-}

-- | Datatype for expressions
data EXPRESSION =
    Var Id.Token
  | Op OPID [EXTPARAM] [EXPRESSION] Id.Range
  -- TODO: don't need lists anymore, they should be removed soon
  | List [EXPRESSION] Id.Range
  | Interval Double Double Id.Range
  | Int APInt Id.Range
  | Rat APFloat Id.Range
  deriving (EXPRESSION -> EXPRESSION -> Bool
(EXPRESSION -> EXPRESSION -> Bool)
-> (EXPRESSION -> EXPRESSION -> Bool) -> Eq EXPRESSION
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EXPRESSION -> EXPRESSION -> Bool
$c/= :: EXPRESSION -> EXPRESSION -> Bool
== :: EXPRESSION -> EXPRESSION -> Bool
$c== :: EXPRESSION -> EXPRESSION -> Bool
Eq, Eq EXPRESSION
Eq EXPRESSION =>
(EXPRESSION -> EXPRESSION -> Ordering)
-> (EXPRESSION -> EXPRESSION -> Bool)
-> (EXPRESSION -> EXPRESSION -> Bool)
-> (EXPRESSION -> EXPRESSION -> Bool)
-> (EXPRESSION -> EXPRESSION -> Bool)
-> (EXPRESSION -> EXPRESSION -> EXPRESSION)
-> (EXPRESSION -> EXPRESSION -> EXPRESSION)
-> Ord EXPRESSION
EXPRESSION -> EXPRESSION -> Bool
EXPRESSION -> EXPRESSION -> Ordering
EXPRESSION -> EXPRESSION -> EXPRESSION
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 :: EXPRESSION -> EXPRESSION -> EXPRESSION
$cmin :: EXPRESSION -> EXPRESSION -> EXPRESSION
max :: EXPRESSION -> EXPRESSION -> EXPRESSION
$cmax :: EXPRESSION -> EXPRESSION -> EXPRESSION
>= :: EXPRESSION -> EXPRESSION -> Bool
$c>= :: EXPRESSION -> EXPRESSION -> Bool
> :: EXPRESSION -> EXPRESSION -> Bool
$c> :: EXPRESSION -> EXPRESSION -> Bool
<= :: EXPRESSION -> EXPRESSION -> Bool
$c<= :: EXPRESSION -> EXPRESSION -> Bool
< :: EXPRESSION -> EXPRESSION -> Bool
$c< :: EXPRESSION -> EXPRESSION -> Bool
compare :: EXPRESSION -> EXPRESSION -> Ordering
$ccompare :: EXPRESSION -> EXPRESSION -> Ordering
$cp1Ord :: Eq EXPRESSION
Ord, Int -> EXPRESSION -> ShowS
[EXPRESSION] -> ShowS
EXPRESSION -> String
(Int -> EXPRESSION -> ShowS)
-> (EXPRESSION -> String)
-> ([EXPRESSION] -> ShowS)
-> Show EXPRESSION
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EXPRESSION] -> ShowS
$cshowList :: [EXPRESSION] -> ShowS
show :: EXPRESSION -> String
$cshow :: EXPRESSION -> String
showsPrec :: Int -> EXPRESSION -> ShowS
$cshowsPrec :: Int -> EXPRESSION -> ShowS
Show, Typeable, Typeable EXPRESSION
Constr
DataType
Typeable EXPRESSION =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EXPRESSION -> c EXPRESSION)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EXPRESSION)
-> (EXPRESSION -> Constr)
-> (EXPRESSION -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EXPRESSION))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EXPRESSION))
-> ((forall b. Data b => b -> b) -> EXPRESSION -> EXPRESSION)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r)
-> (forall u. (forall d. Data d => d -> u) -> EXPRESSION -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EXPRESSION -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION)
-> Data EXPRESSION
EXPRESSION -> Constr
EXPRESSION -> DataType
(forall b. Data b => b -> b) -> EXPRESSION -> EXPRESSION
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EXPRESSION -> c EXPRESSION
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EXPRESSION
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) -> EXPRESSION -> u
forall u. (forall d. Data d => d -> u) -> EXPRESSION -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EXPRESSION
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EXPRESSION -> c EXPRESSION
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EXPRESSION)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EXPRESSION)
$cRat :: Constr
$cInt :: Constr
$cInterval :: Constr
$cList :: Constr
$cOp :: Constr
$cVar :: Constr
$tEXPRESSION :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
gmapMp :: (forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
gmapM :: (forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EXPRESSION -> m EXPRESSION
gmapQi :: Int -> (forall d. Data d => d -> u) -> EXPRESSION -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EXPRESSION -> u
gmapQ :: (forall d. Data d => d -> u) -> EXPRESSION -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EXPRESSION -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EXPRESSION -> r
gmapT :: (forall b. Data b => b -> b) -> EXPRESSION -> EXPRESSION
$cgmapT :: (forall b. Data b => b -> b) -> EXPRESSION -> EXPRESSION
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EXPRESSION)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EXPRESSION)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EXPRESSION)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EXPRESSION)
dataTypeOf :: EXPRESSION -> DataType
$cdataTypeOf :: EXPRESSION -> DataType
toConstr :: EXPRESSION -> Constr
$ctoConstr :: EXPRESSION -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EXPRESSION
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EXPRESSION
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EXPRESSION -> c EXPRESSION
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EXPRESSION -> c EXPRESSION
$cp1Data :: Typeable EXPRESSION
Data)

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

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

-- TODO: add Range-support to this type
data CMD = Ass OpDecl EXPRESSION
         | Cmd String [EXPRESSION]
         | Sequence [CMD] -- program sequence
         | Cond [(EXPRESSION, [CMD])]
         | Repeat EXPRESSION [CMD] -- constraint, statements
           deriving (Int -> CMD -> ShowS
[CMD] -> ShowS
CMD -> String
(Int -> CMD -> ShowS)
-> (CMD -> String) -> ([CMD] -> ShowS) -> Show CMD
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CMD] -> ShowS
$cshowList :: [CMD] -> ShowS
show :: CMD -> String
$cshow :: CMD -> String
showsPrec :: Int -> CMD -> ShowS
$cshowsPrec :: Int -> CMD -> ShowS
Show, CMD -> CMD -> Bool
(CMD -> CMD -> Bool) -> (CMD -> CMD -> Bool) -> Eq CMD
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CMD -> CMD -> Bool
$c/= :: CMD -> CMD -> Bool
== :: CMD -> CMD -> Bool
$c== :: CMD -> CMD -> Bool
Eq, Eq CMD
Eq CMD =>
(CMD -> CMD -> Ordering)
-> (CMD -> CMD -> Bool)
-> (CMD -> CMD -> Bool)
-> (CMD -> CMD -> Bool)
-> (CMD -> CMD -> Bool)
-> (CMD -> CMD -> CMD)
-> (CMD -> CMD -> CMD)
-> Ord CMD
CMD -> CMD -> Bool
CMD -> CMD -> Ordering
CMD -> CMD -> CMD
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 :: CMD -> CMD -> CMD
$cmin :: CMD -> CMD -> CMD
max :: CMD -> CMD -> CMD
$cmax :: CMD -> CMD -> CMD
>= :: CMD -> CMD -> Bool
$c>= :: CMD -> CMD -> Bool
> :: CMD -> CMD -> Bool
$c> :: CMD -> CMD -> Bool
<= :: CMD -> CMD -> Bool
$c<= :: CMD -> CMD -> Bool
< :: CMD -> CMD -> Bool
$c< :: CMD -> CMD -> Bool
compare :: CMD -> CMD -> Ordering
$ccompare :: CMD -> CMD -> Ordering
$cp1Ord :: Eq CMD
Ord, Typeable, Typeable CMD
Constr
DataType
Typeable CMD =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CMD -> c CMD)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CMD)
-> (CMD -> Constr)
-> (CMD -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CMD))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMD))
-> ((forall b. Data b => b -> b) -> CMD -> CMD)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r)
-> (forall u. (forall d. Data d => d -> u) -> CMD -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CMD -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CMD -> m CMD)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CMD -> m CMD)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CMD -> m CMD)
-> Data CMD
CMD -> Constr
CMD -> DataType
(forall b. Data b => b -> b) -> CMD -> CMD
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMD -> c CMD
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMD
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) -> CMD -> u
forall u. (forall d. Data d => d -> u) -> CMD -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CMD -> m CMD
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CMD -> m CMD
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMD
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMD -> c CMD
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CMD)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMD)
$cRepeat :: Constr
$cCond :: Constr
$cSequence :: Constr
$cCmd :: Constr
$cAss :: Constr
$tCMD :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CMD -> m CMD
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CMD -> m CMD
gmapMp :: (forall d. Data d => d -> m d) -> CMD -> m CMD
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CMD -> m CMD
gmapM :: (forall d. Data d => d -> m d) -> CMD -> m CMD
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CMD -> m CMD
gmapQi :: Int -> (forall d. Data d => d -> u) -> CMD -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CMD -> u
gmapQ :: (forall d. Data d => d -> u) -> CMD -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CMD -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CMD -> r
gmapT :: (forall b. Data b => b -> b) -> CMD -> CMD
$cgmapT :: (forall b. Data b => b -> b) -> CMD -> CMD
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMD)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CMD)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CMD)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CMD)
dataTypeOf :: CMD -> DataType
$cdataTypeOf :: CMD -> DataType
toConstr :: CMD -> Constr
$ctoConstr :: CMD -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMD
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CMD
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMD -> c CMD
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CMD -> c CMD
$cp1Data :: Typeable CMD
Data)

-- | symbol lists for hiding
data SYMB_ITEMS = Symb_items [SYMB] Id.Range
                  -- pos: SYMB_KIND, commas
                  deriving (Int -> SYMB_ITEMS -> ShowS
[SYMB_ITEMS] -> ShowS
SYMB_ITEMS -> String
(Int -> SYMB_ITEMS -> ShowS)
-> (SYMB_ITEMS -> String)
-> ([SYMB_ITEMS] -> ShowS)
-> Show SYMB_ITEMS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SYMB_ITEMS] -> ShowS
$cshowList :: [SYMB_ITEMS] -> ShowS
show :: SYMB_ITEMS -> String
$cshow :: SYMB_ITEMS -> String
showsPrec :: Int -> SYMB_ITEMS -> ShowS
$cshowsPrec :: Int -> SYMB_ITEMS -> ShowS
Show, SYMB_ITEMS -> SYMB_ITEMS -> Bool
(SYMB_ITEMS -> SYMB_ITEMS -> Bool)
-> (SYMB_ITEMS -> SYMB_ITEMS -> Bool) -> Eq SYMB_ITEMS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SYMB_ITEMS -> SYMB_ITEMS -> Bool
$c/= :: SYMB_ITEMS -> SYMB_ITEMS -> Bool
== :: SYMB_ITEMS -> SYMB_ITEMS -> Bool
$c== :: SYMB_ITEMS -> SYMB_ITEMS -> Bool
Eq, 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)

-- | symbol for identifiers
newtype SYMB = Symb_id Id.Token
            -- pos: colon
            deriving (Int -> SYMB -> ShowS
[SYMB] -> ShowS
SYMB -> String
(Int -> SYMB -> ShowS)
-> (SYMB -> String) -> ([SYMB] -> ShowS) -> Show SYMB
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SYMB] -> ShowS
$cshowList :: [SYMB] -> ShowS
show :: SYMB -> String
$cshow :: SYMB -> String
showsPrec :: Int -> SYMB -> ShowS
$cshowsPrec :: Int -> SYMB -> ShowS
Show, SYMB -> SYMB -> Bool
(SYMB -> SYMB -> Bool) -> (SYMB -> SYMB -> Bool) -> Eq SYMB
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SYMB -> SYMB -> Bool
$c/= :: SYMB -> SYMB -> Bool
== :: SYMB -> SYMB -> Bool
$c== :: SYMB -> SYMB -> Bool
Eq, 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)

-- | symbol maps for renamings
data SYMB_MAP_ITEMS = Symb_map_items [SYMB_OR_MAP] Id.Range
                      -- pos: SYMB_KIND, commas
                      deriving (Int -> SYMB_MAP_ITEMS -> ShowS
[SYMB_MAP_ITEMS] -> ShowS
SYMB_MAP_ITEMS -> String
(Int -> SYMB_MAP_ITEMS -> ShowS)
-> (SYMB_MAP_ITEMS -> String)
-> ([SYMB_MAP_ITEMS] -> ShowS)
-> Show SYMB_MAP_ITEMS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SYMB_MAP_ITEMS] -> ShowS
$cshowList :: [SYMB_MAP_ITEMS] -> ShowS
show :: SYMB_MAP_ITEMS -> String
$cshow :: SYMB_MAP_ITEMS -> String
showsPrec :: Int -> SYMB_MAP_ITEMS -> ShowS
$cshowsPrec :: Int -> SYMB_MAP_ITEMS -> ShowS
Show, SYMB_MAP_ITEMS -> SYMB_MAP_ITEMS -> Bool
(SYMB_MAP_ITEMS -> SYMB_MAP_ITEMS -> Bool)
-> (SYMB_MAP_ITEMS -> SYMB_MAP_ITEMS -> Bool) -> Eq SYMB_MAP_ITEMS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SYMB_MAP_ITEMS -> SYMB_MAP_ITEMS -> Bool
$c/= :: SYMB_MAP_ITEMS -> SYMB_MAP_ITEMS -> Bool
== :: SYMB_MAP_ITEMS -> SYMB_MAP_ITEMS -> Bool
$c== :: SYMB_MAP_ITEMS -> SYMB_MAP_ITEMS -> Bool
Eq, 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)

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

{- ---------------------------------------------------------------------------
Predefined Operators: info for parsing/printing and static analysis
--------------------------------------------------------------------------- -}

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

data OpInfo = OpInfo { OpInfo -> Int
prec :: Int -- ^ precedence between 0 and maxPrecedence
                     , OpInfo -> Bool
infx :: Bool -- ^ True = infix
                     , OpInfo -> Int
arity :: Int -- ^ the operator arity
                     , OpInfo -> Bool
foldNAry :: Bool {- ^ True = fold nary-applications
                                        during construction into binary ones -}
                     , OpInfo -> OPNAME
opname :: OPNAME -- ^ The actual operator name
                     , OpInfo -> Maybe BindInfo
bind :: Maybe BindInfo -- ^ More info for binders
                     } deriving (OpInfo -> OpInfo -> Bool
(OpInfo -> OpInfo -> Bool)
-> (OpInfo -> OpInfo -> Bool) -> Eq OpInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OpInfo -> OpInfo -> Bool
$c/= :: OpInfo -> OpInfo -> Bool
== :: OpInfo -> OpInfo -> Bool
$c== :: OpInfo -> OpInfo -> Bool
Eq, Eq OpInfo
Eq OpInfo =>
(OpInfo -> OpInfo -> Ordering)
-> (OpInfo -> OpInfo -> Bool)
-> (OpInfo -> OpInfo -> Bool)
-> (OpInfo -> OpInfo -> Bool)
-> (OpInfo -> OpInfo -> Bool)
-> (OpInfo -> OpInfo -> OpInfo)
-> (OpInfo -> OpInfo -> OpInfo)
-> Ord OpInfo
OpInfo -> OpInfo -> Bool
OpInfo -> OpInfo -> Ordering
OpInfo -> OpInfo -> OpInfo
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 :: OpInfo -> OpInfo -> OpInfo
$cmin :: OpInfo -> OpInfo -> OpInfo
max :: OpInfo -> OpInfo -> OpInfo
$cmax :: OpInfo -> OpInfo -> OpInfo
>= :: OpInfo -> OpInfo -> Bool
$c>= :: OpInfo -> OpInfo -> Bool
> :: OpInfo -> OpInfo -> Bool
$c> :: OpInfo -> OpInfo -> Bool
<= :: OpInfo -> OpInfo -> Bool
$c<= :: OpInfo -> OpInfo -> Bool
< :: OpInfo -> OpInfo -> Bool
$c< :: OpInfo -> OpInfo -> Bool
compare :: OpInfo -> OpInfo -> Ordering
$ccompare :: OpInfo -> OpInfo -> Ordering
$cp1Ord :: Eq OpInfo
Ord, Int -> OpInfo -> ShowS
[OpInfo] -> ShowS
OpInfo -> String
(Int -> OpInfo -> ShowS)
-> (OpInfo -> String) -> ([OpInfo] -> ShowS) -> Show OpInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OpInfo] -> ShowS
$cshowList :: [OpInfo] -> ShowS
show :: OpInfo -> String
$cshow :: OpInfo -> String
showsPrec :: Int -> OpInfo -> ShowS
$cshowsPrec :: Int -> OpInfo -> ShowS
Show, Typeable, Typeable OpInfo
Constr
DataType
Typeable OpInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OpInfo -> c OpInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OpInfo)
-> (OpInfo -> Constr)
-> (OpInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OpInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpInfo))
-> ((forall b. Data b => b -> b) -> OpInfo -> OpInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OpInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OpInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> OpInfo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OpInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OpInfo -> m OpInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OpInfo -> m OpInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OpInfo -> m OpInfo)
-> Data OpInfo
OpInfo -> Constr
OpInfo -> DataType
(forall b. Data b => b -> b) -> OpInfo -> OpInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpInfo -> c OpInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpInfo
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) -> OpInfo -> u
forall u. (forall d. Data d => d -> u) -> OpInfo -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpInfo -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpInfo -> c OpInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OpInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpInfo)
$cOpInfo :: Constr
$tOpInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
gmapMp :: (forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
gmapM :: (forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OpInfo -> m OpInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> OpInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OpInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> OpInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OpInfo -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpInfo -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpInfo -> r
gmapT :: (forall b. Data b => b -> b) -> OpInfo -> OpInfo
$cgmapT :: (forall b. Data b => b -> b) -> OpInfo -> OpInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OpInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OpInfo)
dataTypeOf :: OpInfo -> DataType
$cdataTypeOf :: OpInfo -> DataType
toConstr :: OpInfo -> Constr
$ctoConstr :: OpInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OpInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpInfo -> c OpInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OpInfo -> c OpInfo
$cp1Data :: Typeable OpInfo
Data)

type ArityMap = Map.Map Int OpInfo
type OpInfoArityMap a = Map.Map a ArityMap
type OpInfoMap = OpInfoArityMap String
type OpInfoNameMap = OpInfoArityMap OPNAME
type BindInfoMap = Map.Map String OpInfo


{- | Merges two OpInfoArityMaps together with the first map as default map
and the second overwriting the default values -}
mergeOpArityMap :: Ord a => OpInfoArityMap a -> OpInfoArityMap a
                -> OpInfoArityMap a
mergeOpArityMap :: OpInfoArityMap a -> OpInfoArityMap a -> OpInfoArityMap a
mergeOpArityMap = (OpInfoArityMap a -> OpInfoArityMap a -> OpInfoArityMap a)
-> OpInfoArityMap a -> OpInfoArityMap a -> OpInfoArityMap a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((OpInfoArityMap a -> OpInfoArityMap a -> OpInfoArityMap a)
 -> OpInfoArityMap a -> OpInfoArityMap a -> OpInfoArityMap a)
-> (OpInfoArityMap a -> OpInfoArityMap a -> OpInfoArityMap a)
-> OpInfoArityMap a
-> OpInfoArityMap a
-> OpInfoArityMap a
forall a b. (a -> b) -> a -> b
$ (Map Int OpInfo -> Map Int OpInfo -> Map Int OpInfo)
-> OpInfoArityMap a -> OpInfoArityMap a -> OpInfoArityMap a
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith Map Int OpInfo -> Map Int OpInfo -> Map Int OpInfo
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union


{- | Mapping of operator names to arity-'OpInfo'-maps (an operator may
behave differently for different arities). -}
getOpInfoMap :: (OpInfo -> String) -> [OpInfo] -> OpInfoMap
getOpInfoMap :: (OpInfo -> String) -> [OpInfo] -> OpInfoMap
getOpInfoMap pf :: OpInfo -> String
pf = (OpInfoMap -> OpInfo -> OpInfoMap)
-> OpInfoMap -> [OpInfo] -> OpInfoMap
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl OpInfoMap -> OpInfo -> OpInfoMap
f OpInfoMap
forall k a. Map k a
Map.empty
    where f :: OpInfoMap -> OpInfo -> OpInfoMap
f m :: OpInfoMap
m oi :: OpInfo
oi = (Map Int OpInfo -> Map Int OpInfo -> Map Int OpInfo)
-> String -> Map Int OpInfo -> OpInfoMap -> OpInfoMap
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Map Int OpInfo -> Map Int OpInfo -> Map Int OpInfo
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union (OpInfo -> String
pf OpInfo
oi)
                   ([(Int, OpInfo)] -> Map Int OpInfo
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(OpInfo -> Int
arity OpInfo
oi, OpInfo
oi)]) OpInfoMap
m

-- | Same as operatorInfoMap but with keys of type OPNAME instead of String
getOpInfoNameMap :: [OpInfo] -> OpInfoNameMap
getOpInfoNameMap :: [OpInfo] -> OpInfoNameMap
getOpInfoNameMap = (OpInfoNameMap -> OpInfo -> OpInfoNameMap)
-> OpInfoNameMap -> [OpInfo] -> OpInfoNameMap
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl OpInfoNameMap -> OpInfo -> OpInfoNameMap
f OpInfoNameMap
forall k a. Map k a
Map.empty
    where f :: OpInfoNameMap -> OpInfo -> OpInfoNameMap
f m :: OpInfoNameMap
m oi :: OpInfo
oi = (Map Int OpInfo -> Map Int OpInfo -> Map Int OpInfo)
-> OPNAME -> Map Int OpInfo -> OpInfoNameMap -> OpInfoNameMap
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Map Int OpInfo -> Map Int OpInfo -> Map Int OpInfo
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union (OpInfo -> OPNAME
opname OpInfo
oi)
                   ([(Int, OpInfo)] -> Map Int OpInfo
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(OpInfo -> Int
arity OpInfo
oi, OpInfo
oi)]) OpInfoNameMap
m

{- | a special map for binders which have to be unique for each name
(no different arities). -}
getBindInfoMap :: [OpInfo] -> BindInfoMap
getBindInfoMap :: [OpInfo] -> BindInfoMap
getBindInfoMap = (BindInfoMap -> OpInfo -> BindInfoMap)
-> BindInfoMap -> [OpInfo] -> BindInfoMap
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl BindInfoMap -> OpInfo -> BindInfoMap
f BindInfoMap
forall k a. Map k a
Map.empty
    where f :: BindInfoMap -> OpInfo -> BindInfoMap
f m :: BindInfoMap
m oi :: OpInfo
oi@(OpInfo {bind :: OpInfo -> Maybe BindInfo
bind = Just _}) =
              (OpInfo -> OpInfo -> OpInfo)
-> String -> OpInfo -> BindInfoMap -> BindInfoMap
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith OpInfo -> OpInfo -> OpInfo
forall p a. OpInfo -> p -> a
cf (OPNAME -> String
forall a. Show a => a -> String
show (OPNAME -> String) -> OPNAME -> String
forall a b. (a -> b) -> a -> b
$ OpInfo -> OPNAME
opname OpInfo
oi) OpInfo
oi BindInfoMap
m
          f m :: BindInfoMap
m _ = BindInfoMap
m
          cf :: OpInfo -> p -> a
cf a :: OpInfo
a _ = String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ "operatorBindInfoMap: duplicate entry for "
                   String -> ShowS
forall a. [a] -> [a] -> [a]
++ OPNAME -> String
forall a. Show a => a -> String
show (OpInfo -> OPNAME
opname OpInfo
a)


-- | opInfoMap for the predefined 'operatorInfo'
operatorInfoMap :: OpInfoMap
operatorInfoMap :: OpInfoMap
operatorInfoMap = (OpInfo -> String) -> [OpInfo] -> OpInfoMap
getOpInfoMap (OPNAME -> String
forall a. Show a => a -> String
show (OPNAME -> String) -> (OpInfo -> OPNAME) -> OpInfo -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OpInfo -> OPNAME
opname) [OpInfo]
operatorInfo

-- | opInfoNameMap for the predefined 'operatorInfo'
operatorInfoNameMap :: OpInfoNameMap
operatorInfoNameMap :: OpInfoNameMap
operatorInfoNameMap = [OpInfo] -> OpInfoNameMap
getOpInfoNameMap [OpInfo]
operatorInfo


operatorBindInfoMap :: BindInfoMap
operatorBindInfoMap :: BindInfoMap
operatorBindInfoMap = [OpInfo] -> BindInfoMap
getBindInfoMap [OpInfo]
operatorInfo

{- | Mapping of operator names to arity-'OpInfo'-maps (an operator may
behave differently for different arities). -}
operatorInfo :: [OpInfo]
operatorInfo :: [OpInfo]
operatorInfo =
    let -- arity (-1 means flex), precedence, infix
        toSgl :: OPNAME -> Int -> Int -> OpInfo
toSgl n :: OPNAME
n i :: Int
i p :: Int
p = OpInfo :: Int -> Bool -> Int -> Bool -> OPNAME -> Maybe BindInfo -> OpInfo
OpInfo { prec :: Int
prec = if Int
p Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0 then Int
maxPrecedence else Int
p
                             , infx :: Bool
infx = Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0
                             , arity :: Int
arity = Int
i
                             , opname :: OPNAME
opname = OPNAME
n
                             , foldNAry :: Bool
foldNAry = Bool
False
                             , bind :: Maybe BindInfo
bind = Maybe BindInfo
forall a. Maybe a
Nothing
                             }
        toSglBind :: OPNAME -> Int -> Int -> Int -> OpInfo
toSglBind n :: OPNAME
n i :: Int
i bv :: Int
bv bb :: Int
bb =
            OpInfo :: Int -> Bool -> Int -> Bool -> OPNAME -> Maybe BindInfo -> OpInfo
OpInfo { prec :: Int
prec = Int
maxPrecedence
                   , infx :: Bool
infx = Bool
False
                   , arity :: Int
arity = Int
i
                   , opname :: OPNAME
opname = OPNAME
n
                   , foldNAry :: Bool
foldNAry = Bool
False
                   , bind :: Maybe BindInfo
bind = BindInfo -> Maybe BindInfo
forall a. a -> Maybe a
Just (BindInfo -> Maybe BindInfo) -> BindInfo -> Maybe BindInfo
forall a b. (a -> b) -> a -> b
$ [Int] -> [Int] -> BindInfo
BindInfo [Int
bv] [Int
bb]
                   }
        -- arityX simple ops
        aX :: Int -> OPNAME -> OpInfo
aX i :: Int
i s :: OPNAME
s = OPNAME -> Int -> Int -> OpInfo
toSgl OPNAME
s Int
i 0
        -- arityflex simple ops
        aflex :: OPNAME -> OpInfo
aflex = Int -> OPNAME -> OpInfo
aX (-1)
        -- arity2 binder
        a2bind :: Int -> Int -> OPNAME -> OpInfo
a2bind bv :: Int
bv bb :: Int
bb s :: OPNAME
s = OPNAME -> Int -> Int -> Int -> OpInfo
toSglBind OPNAME
s 2 Int
bv Int
bb
        -- arity4 binder
        a4bind :: Int -> Int -> OPNAME -> OpInfo
a4bind bv :: Int
bv bb :: Int
bb s :: OPNAME
s = OPNAME -> Int -> Int -> Int -> OpInfo
toSglBind OPNAME
s 4 Int
bv Int
bb
        -- arity2 infix with precedence
        a2i :: Int -> OPNAME -> OpInfo
a2i p :: Int
p s :: OPNAME
s = OPNAME -> Int -> Int -> OpInfo
toSgl OPNAME
s 2 Int
p
    in (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
aX 0) [ OPNAME
OP_failure, OPNAME
OP_undef, OPNAME
OP_Pi, OPNAME
OP_true, OPNAME
OP_false, OPNAME
OP_real ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
aX 1)
                  [ OPNAME
OP_neg, OPNAME
OP_cos, OPNAME
OP_sin, OPNAME
OP_tan, OPNAME
OP_cot, OPNAME
OP_sqrt, OPNAME
OP_fthrt
                  , OPNAME
OP_abs, OPNAME
OP_sign, OPNAME
OP_simplify, OPNAME
OP_rlqe, OPNAME
OP_factor
                  , OPNAME
OP_factorize ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 5) [ OPNAME
OP_hastype ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Int -> OPNAME -> OpInfo
a2bind 0 1) [ OPNAME
OP_ex, OPNAME
OP_all ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 30) [ OPNAME
OP_or, OPNAME
OP_impl ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 40) [ OPNAME
OP_and ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 50) [ OPNAME
OP_eq, OPNAME
OP_gt, OPNAME
OP_leq, OPNAME
OP_geq, OPNAME
OP_neq, OPNAME
OP_lt, OPNAME
OP_in]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 60) [ OPNAME
OP_plus ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 70) [ OPNAME
OP_minus ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 80) [OPNAME
OP_mult]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 90) [OPNAME
OP_div]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
a2i 100) [OPNAME
OP_pow]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
aX 2)
                  [ OPNAME
OP_int, OPNAME
OP_divide, OPNAME
OP_solve, OPNAME
OP_convergence, OPNAME
OP_reldist
                  , OPNAME
OP_approx]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> OPNAME -> OpInfo
aX 3) [OPNAME
OP_reldistLe]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map OPNAME -> OpInfo
aflex [ OPNAME
OP_min, OPNAME
OP_max ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Int -> OPNAME -> OpInfo
a2bind 1 0) [ OPNAME
OP_maximize, OPNAME
OP_minimize ]
           [OpInfo] -> [OpInfo] -> [OpInfo]
forall a. [a] -> [a] -> [a]
++ (OPNAME -> OpInfo) -> [OPNAME] -> [OpInfo]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Int -> OPNAME -> OpInfo
a4bind 1 0) [ OPNAME
OP_maxloc, OPNAME
OP_minloc ]

maxPrecedence :: Int
maxPrecedence :: Int
maxPrecedence = 120


{- ---------------------------------------------------------------------------
OpInfo lookup utils
--------------------------------------------------------------------------- -}

class OperatorState a where
    addVar :: a -> String -> a
    addVar = a -> String -> a
forall a b. a -> b -> a
const
    isVar :: a -> String -> Bool
    isVar _ _ = Bool
False
    lookupOperator :: a
                   -> String -- ^ operator name
                   -> Int -- ^ operator arity
                   -> Either Bool OpInfo
    lookupBinder :: a
                   -> String -- ^ binder name
                   -> Maybe OpInfo

instance OperatorState () where
    lookupOperator :: () -> String -> Int -> Either Bool OpInfo
lookupOperator _ = OpInfoMap -> String -> Int -> Either Bool OpInfo
lookupOpInfoForParsing OpInfoMap
operatorInfoMap
    lookupBinder :: () -> String -> Maybe OpInfo
lookupBinder _ = (String -> BindInfoMap -> Maybe OpInfo)
-> BindInfoMap -> String -> Maybe OpInfo
forall a b c. (a -> b -> c) -> b -> a -> c
flip String -> BindInfoMap -> Maybe OpInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup BindInfoMap
operatorBindInfoMap

instance OperatorState (OpInfoMap, BindInfoMap) where
    lookupOperator :: (OpInfoMap, BindInfoMap) -> String -> Int -> Either Bool OpInfo
lookupOperator = OpInfoMap -> String -> Int -> Either Bool OpInfo
lookupOpInfoForParsing (OpInfoMap -> String -> Int -> Either Bool OpInfo)
-> ((OpInfoMap, BindInfoMap) -> OpInfoMap)
-> (OpInfoMap, BindInfoMap)
-> String
-> Int
-> Either Bool OpInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (OpInfoMap, BindInfoMap) -> OpInfoMap
forall a b. (a, b) -> a
fst
    lookupBinder :: (OpInfoMap, BindInfoMap) -> String -> Maybe OpInfo
lookupBinder = (String -> BindInfoMap -> Maybe OpInfo)
-> BindInfoMap -> String -> Maybe OpInfo
forall a b c. (a -> b -> c) -> b -> a -> c
flip String -> BindInfoMap -> Maybe OpInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (BindInfoMap -> String -> Maybe OpInfo)
-> ((OpInfoMap, BindInfoMap) -> BindInfoMap)
-> (OpInfoMap, BindInfoMap)
-> String
-> Maybe OpInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (OpInfoMap, BindInfoMap) -> BindInfoMap
forall a b. (a, b) -> b
snd


{- | For the given name and arity we lookup an 'OpInfo', where arity=-1
means flexible arity. If an operator is registered for the given
string but not for the arity we return: Left True.
This function is designed for the lookup of operators in not statically
analyzed terms. For statically analyzed terms use lookupOpInfo. -}
lookupOpInfoForParsing :: OpInfoMap -- ^ map to be used for lookup
             -> String -- ^ operator name
             -> Int -- ^ operator arity
             -> Either Bool OpInfo
lookupOpInfoForParsing :: OpInfoMap -> String -> Int -> Either Bool OpInfo
lookupOpInfoForParsing oiMap :: OpInfoMap
oiMap op :: String
op arit :: Int
arit =
    case String -> OpInfoMap -> Maybe (Map Int OpInfo)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup String
op OpInfoMap
oiMap of
      Just oim :: Map Int OpInfo
oim ->
          case Int -> Map Int OpInfo -> Maybe OpInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Int
arit Map Int OpInfo
oim of
            Just x :: OpInfo
x -> OpInfo -> Either Bool OpInfo
forall a b. b -> Either a b
Right OpInfo
x
            Nothing ->
                case Int -> Map Int OpInfo -> Maybe OpInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (-1) Map Int OpInfo
oim of
                  Just x :: OpInfo
x -> OpInfo -> Either Bool OpInfo
forall a b. b -> Either a b
Right OpInfo
x
                  _ -> Bool -> Either Bool OpInfo
forall a b. a -> Either a b
Left Bool
True
      _ -> Bool -> Either Bool OpInfo
forall a b. a -> Either a b
Left Bool
False

{- | For the given name and arity we lookup an 'OpInfo', where arity=-1
means flexible arity. If an operator is registered for the given
string but not for the arity we return: Left True. -}
lookupOpInfo :: OpInfoNameMap -> OPID -- ^ operator id
             -> Int -- ^ operator arity
             -> Either Bool OpInfo
lookupOpInfo :: OpInfoNameMap -> OPID -> Int -> Either Bool OpInfo
lookupOpInfo oinm :: OpInfoNameMap
oinm (OpId op :: OPNAME
op) arit :: Int
arit =
    case OPNAME -> OpInfoNameMap -> Maybe (Map Int OpInfo)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup OPNAME
op OpInfoNameMap
oinm of
      Just oim :: Map Int OpInfo
oim ->
          case Int -> Map Int OpInfo -> Maybe OpInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Int
arit Map Int OpInfo
oim of
            Just x :: OpInfo
x -> OpInfo -> Either Bool OpInfo
forall a b. b -> Either a b
Right OpInfo
x
            Nothing ->
                case Int -> Map Int OpInfo -> Maybe OpInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (-1) Map Int OpInfo
oim of
                  Just x :: OpInfo
x -> OpInfo -> Either Bool OpInfo
forall a b. b -> Either a b
Right OpInfo
x
                  _ -> Bool -> Either Bool OpInfo
forall a b. a -> Either a b
Left Bool
True
      _ -> String -> Either Bool OpInfo
forall a. HasCallStack => String -> a
error (String -> Either Bool OpInfo) -> String -> Either Bool OpInfo
forall a b. (a -> b) -> a -> b
$ "lookupOpInfo: no opinfo for " String -> ShowS
forall a. [a] -> [a] -> [a]
++ OPNAME -> String
forall a. Show a => a -> String
show OPNAME
op
lookupOpInfo _ (OpUser _) _ = Bool -> Either Bool OpInfo
forall a b. a -> Either a b
Left Bool
False

{- | For the given name and arity we lookup an 'BindInfo', where arity=-1
means flexible arity. -}
lookupBindInfo :: OpInfoNameMap -> OPID -- ^ operator name
             -> Int -- ^ operator arity
             -> Maybe BindInfo
lookupBindInfo :: OpInfoNameMap -> OPID -> Int -> Maybe BindInfo
lookupBindInfo oinm :: OpInfoNameMap
oinm (OpId op :: OPNAME
op) arit :: Int
arit =
    case OPNAME -> OpInfoNameMap -> Maybe (Map Int OpInfo)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup OPNAME
op OpInfoNameMap
oinm of
      Just oim :: Map Int OpInfo
oim ->
          case Int -> Map Int OpInfo -> Maybe OpInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Int
arit Map Int OpInfo
oim of
            Just x :: OpInfo
x -> OpInfo -> Maybe BindInfo
bind OpInfo
x
            _ -> Maybe BindInfo
forall a. Maybe a
Nothing
      _ -> String -> Maybe BindInfo
forall a. HasCallStack => String -> a
error (String -> Maybe BindInfo) -> String -> Maybe BindInfo
forall a b. (a -> b) -> a -> b
$ "lookupBindInfo: no opinfo for " String -> ShowS
forall a. [a] -> [a] -> [a]
++ OPNAME -> String
forall a. Show a => a -> String
show OPNAME
op
lookupBindInfo _ (OpUser _) _ = Maybe BindInfo
forall a. Maybe a
Nothing