Hets - the Heterogeneous Tool Set

Copyright(c) Markus Roggenbach and Till Mossakowski and Uni Bremen 2004
LicenseGPLv2 or higher, see LICENSE.txt
Maintainera.m.gimblett@swan.ac.uk
Stabilityprovisional
Portabilityportable
Safe HaskellSafe

CspCASL.AS_CspCASL_Process

Description

Abstract syntax of CSP-CASL processes.

Synopsis

Documentation

type CommAlpha = Set CommType Source #

Type of communication alphabet

data CommType Source #

Instances

Eq CommType Source # 

Methods

(==) :: CommType -> CommType -> Bool

(/=) :: CommType -> CommType -> Bool

Data CommType Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CommType -> c CommType

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CommType

toConstr :: CommType -> Constr

dataTypeOf :: CommType -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CommType)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CommType)

gmapT :: (forall b. Data b => b -> b) -> CommType -> CommType

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CommType -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CommType -> r

gmapQ :: (forall d. Data d => d -> u) -> CommType -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> CommType -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CommType -> m CommType

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CommType -> m CommType

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CommType -> m CommType

Ord CommType Source # 

Methods

compare :: CommType -> CommType -> Ordering

(<) :: CommType -> CommType -> Bool

(<=) :: CommType -> CommType -> Bool

(>) :: CommType -> CommType -> Bool

(>=) :: CommType -> CommType -> Bool

max :: CommType -> CommType -> CommType

min :: CommType -> CommType -> CommType

Show CommType Source #

Type of communication types, either a sort communication or a typed channel communications.

Methods

showsPrec :: Int -> CommType -> ShowS

show :: CommType -> String

showList :: [CommType] -> ShowS

GetRange CommType Source # 

data EVENT Source #

Constructors

TermEvent (TERM ()) Range

t -> p - Term prefix

ExternalPrefixChoice VAR SORT Range

[] var :: s -> p - External nondeterministic prefix choice

InternalPrefixChoice VAR SORT Range

|~| var :: s -> p - Internal nondeterministic prefix choice

ChanSend CHANNEL_NAME (TERM ()) Range

c ! t -> p - Channel send

ChanNonDetSend CHANNEL_NAME VAR SORT Range

c ! var :: s -> p - Channel nondeterministic send

ChanRecv CHANNEL_NAME VAR SORT Range

c ? var :: s -> p - Channel recieve

FQTermEvent (TERM ()) Range

t -> p - Fully Qualified Term prefix

FQExternalPrefixChoice (TERM ()) Range

[] var :: s -> p - Fully Qualified External nondeterministic prefix choice. The term here holds the fully qualified variable (name and sort).

FQInternalPrefixChoice (TERM ()) Range

|~| var :: s -> p - Fully Qualified Internal nondeterministic prefix choice. The term here holds the fully qualified variable (name and sort).

FQChanSend (CHANNEL_NAME, SORT) (TERM ()) Range

c ! t -> p - Fully Qualified Channel send. The term holds the fully term to send.

FQChanNonDetSend (CHANNEL_NAME, SORT) (TERM ()) Range

c ! var :: s -> p - Fully Qualified Channel nondeterministic send. The term here holds the fully qualified variable (name and sort).

FQChanRecv (CHANNEL_NAME, SORT) (TERM ()) Range

c ? var :: s -> p - Fully Qualified Channel recieve. The term here holds the fully qualified variable (name and sort).

Instances

Eq EVENT Source # 

Methods

(==) :: EVENT -> EVENT -> Bool

(/=) :: EVENT -> EVENT -> Bool

Data EVENT Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EVENT -> c EVENT

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EVENT

toConstr :: EVENT -> Constr

dataTypeOf :: EVENT -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c EVENT)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EVENT)

gmapT :: (forall b. Data b => b -> b) -> EVENT -> EVENT

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EVENT -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EVENT -> r

gmapQ :: (forall d. Data d => d -> u) -> EVENT -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> EVENT -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EVENT -> m EVENT

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EVENT -> m EVENT

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EVENT -> m EVENT

Ord EVENT Source # 

Methods

compare :: EVENT -> EVENT -> Ordering

(<) :: EVENT -> EVENT -> Bool

(<=) :: EVENT -> EVENT -> Bool

(>) :: EVENT -> EVENT -> Bool

(>=) :: EVENT -> EVENT -> Bool

max :: EVENT -> EVENT -> EVENT

min :: EVENT -> EVENT -> EVENT

Show EVENT Source # 

Methods

showsPrec :: Int -> EVENT -> ShowS

show :: EVENT -> String

showList :: [EVENT] -> ShowS

GetRange EVENT Source # 

data EVENT_SET Source #

Event sets are sets of communication types.

Constructors

EventSet [CommType] Range 

Instances

Eq EVENT_SET Source # 

Methods

(==) :: EVENT_SET -> EVENT_SET -> Bool

(/=) :: EVENT_SET -> EVENT_SET -> Bool

Data EVENT_SET Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EVENT_SET -> c EVENT_SET

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EVENT_SET

toConstr :: EVENT_SET -> Constr

dataTypeOf :: EVENT_SET -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c EVENT_SET)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EVENT_SET)

gmapT :: (forall b. Data b => b -> b) -> EVENT_SET -> EVENT_SET

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EVENT_SET -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EVENT_SET -> r

gmapQ :: (forall d. Data d => d -> u) -> EVENT_SET -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> EVENT_SET -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EVENT_SET -> m EVENT_SET

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EVENT_SET -> m EVENT_SET

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EVENT_SET -> m EVENT_SET

Ord EVENT_SET Source # 

Methods

compare :: EVENT_SET -> EVENT_SET -> Ordering

(<) :: EVENT_SET -> EVENT_SET -> Bool

(<=) :: EVENT_SET -> EVENT_SET -> Bool

(>) :: EVENT_SET -> EVENT_SET -> Bool

(>=) :: EVENT_SET -> EVENT_SET -> Bool

max :: EVENT_SET -> EVENT_SET -> EVENT_SET

min :: EVENT_SET -> EVENT_SET -> EVENT_SET

Show EVENT_SET Source # 

Methods

showsPrec :: Int -> EVENT_SET -> ShowS

show :: EVENT_SET -> String

showList :: [EVENT_SET] -> ShowS

GetRange EVENT_SET Source # 

data FQ_PROCESS_NAME Source #

A process name is either a fully qualified process name or a plain process name.

Constructors

PROCESS_NAME PROCESS_NAME

A non-fully qualified process name

FQ_PROCESS_NAME PROCESS_NAME ProcProfile

A name with parameter sorts and communication ids from the parser. This is where the user has tried to specify a fully qualified process name

Instances

Eq FQ_PROCESS_NAME Source # 
Data FQ_PROCESS_NAME Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FQ_PROCESS_NAME -> c FQ_PROCESS_NAME

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FQ_PROCESS_NAME

toConstr :: FQ_PROCESS_NAME -> Constr

dataTypeOf :: FQ_PROCESS_NAME -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FQ_PROCESS_NAME)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FQ_PROCESS_NAME)

gmapT :: (forall b. Data b => b -> b) -> FQ_PROCESS_NAME -> FQ_PROCESS_NAME

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FQ_PROCESS_NAME -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FQ_PROCESS_NAME -> r

gmapQ :: (forall d. Data d => d -> u) -> FQ_PROCESS_NAME -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FQ_PROCESS_NAME -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FQ_PROCESS_NAME -> m FQ_PROCESS_NAME

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FQ_PROCESS_NAME -> m FQ_PROCESS_NAME

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FQ_PROCESS_NAME -> m FQ_PROCESS_NAME

Ord FQ_PROCESS_NAME Source # 
Show FQ_PROCESS_NAME Source # 

Methods

showsPrec :: Int -> FQ_PROCESS_NAME -> ShowS

show :: FQ_PROCESS_NAME -> String

showList :: [FQ_PROCESS_NAME] -> ShowS

GetRange FQ_PROCESS_NAME Source # 

data PROCESS Source #

CSP-CASL process expressions.

Constructors

Skip Range

Skip - Terminate immediately

Stop Range

Stop - Do nothing

Div Range

div - Divergence

Run EVENT_SET Range

Run es - Accept any event in es, forever

Chaos EVENT_SET Range

Chaos es - Accept/refuse any event in es, forever

PrefixProcess EVENT PROCESS Range

event -> p - Prefix process

Sequential PROCESS PROCESS Range

p ; q - Sequential process

ExternalChoice PROCESS PROCESS Range

p [] q - External choice

InternalChoice PROCESS PROCESS Range

p |~| q - Internal choice

Interleaving PROCESS PROCESS Range

p ||| q - Interleaving

SynchronousParallel PROCESS PROCESS Range

p || q - Synchronous parallel

GeneralisedParallel PROCESS EVENT_SET PROCESS Range

p [| a |] q - Generalised parallel

AlphabetisedParallel PROCESS EVENT_SET EVENT_SET PROCESS Range

p [ a || b ] q - Alphabetised parallel

Hiding PROCESS EVENT_SET Range

p \ es - Hiding

RenamingProcess PROCESS RENAMING Range

p [[r]] - Renaming

ConditionalProcess (FORMULA ()) PROCESS PROCESS Range

if f then p else q - Conditional

NamedProcess FQ_PROCESS_NAME [TERM ()] Range

Named process

FQProcess PROCESS CommAlpha Range

Fully qualified process. The range here shall be the same as in the process.

Instances

Eq PROCESS Source # 

Methods

(==) :: PROCESS -> PROCESS -> Bool

(/=) :: PROCESS -> PROCESS -> Bool

Data PROCESS Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PROCESS -> c PROCESS

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PROCESS

toConstr :: PROCESS -> Constr

dataTypeOf :: PROCESS -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PROCESS)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PROCESS)

gmapT :: (forall b. Data b => b -> b) -> PROCESS -> PROCESS

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PROCESS -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PROCESS -> r

gmapQ :: (forall d. Data d => d -> u) -> PROCESS -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PROCESS -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PROCESS -> m PROCESS

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PROCESS -> m PROCESS

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PROCESS -> m PROCESS

Ord PROCESS Source # 

Methods

compare :: PROCESS -> PROCESS -> Ordering

(<) :: PROCESS -> PROCESS -> Bool

(<=) :: PROCESS -> PROCESS -> Bool

(>) :: PROCESS -> PROCESS -> Bool

(>=) :: PROCESS -> PROCESS -> Bool

max :: PROCESS -> PROCESS -> PROCESS

min :: PROCESS -> PROCESS -> PROCESS

Show PROCESS Source # 

Methods

showsPrec :: Int -> PROCESS -> ShowS

show :: PROCESS -> String

showList :: [PROCESS] -> ShowS

GetRange PROCESS Source # 

data PROC_ALPHABET Source #

Constructors

ProcAlphabet [CommType] 

Instances

Eq PROC_ALPHABET Source # 
Data PROC_ALPHABET Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PROC_ALPHABET -> c PROC_ALPHABET

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PROC_ALPHABET

toConstr :: PROC_ALPHABET -> Constr

dataTypeOf :: PROC_ALPHABET -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PROC_ALPHABET)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PROC_ALPHABET)

gmapT :: (forall b. Data b => b -> b) -> PROC_ALPHABET -> PROC_ALPHABET

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PROC_ALPHABET -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PROC_ALPHABET -> r

gmapQ :: (forall d. Data d => d -> u) -> PROC_ALPHABET -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PROC_ALPHABET -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PROC_ALPHABET -> m PROC_ALPHABET

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PROC_ALPHABET -> m PROC_ALPHABET

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PROC_ALPHABET -> m PROC_ALPHABET

Ord PROC_ALPHABET Source # 
Show PROC_ALPHABET Source # 

Methods

showsPrec :: Int -> PROC_ALPHABET -> ShowS

show :: PROC_ALPHABET -> String

showList :: [PROC_ALPHABET] -> ShowS

GetRange PROC_ALPHABET Source # 

data ProcProfile Source #

Fully qualified process names have parameter sorts, and a communication alphabet (a Set of sorts). The CommAlpha here should always contain the minimal super sorts only. The communication over subsorts is implied

Instances

Eq ProcProfile Source # 

Methods

(==) :: ProcProfile -> ProcProfile -> Bool

(/=) :: ProcProfile -> ProcProfile -> Bool

Data ProcProfile Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProcProfile -> c ProcProfile

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ProcProfile

toConstr :: ProcProfile -> Constr

dataTypeOf :: ProcProfile -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ProcProfile)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ProcProfile)

gmapT :: (forall b. Data b => b -> b) -> ProcProfile -> ProcProfile

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProcProfile -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProcProfile -> r

gmapQ :: (forall d. Data d => d -> u) -> ProcProfile -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProcProfile -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProcProfile -> m ProcProfile

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcProfile -> m ProcProfile

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcProfile -> m ProcProfile

Ord ProcProfile Source # 
Show ProcProfile Source # 

Methods

showsPrec :: Int -> ProcProfile -> ShowS

show :: ProcProfile -> String

showList :: [ProcProfile] -> ShowS

GetRange ProcProfile Source # 

data RenameKind Source #

Constructors

TotOp 
PartOp 
BinPred 

Instances

Eq RenameKind Source # 

Methods

(==) :: RenameKind -> RenameKind -> Bool

(/=) :: RenameKind -> RenameKind -> Bool

Data RenameKind Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RenameKind -> c RenameKind

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RenameKind

toConstr :: RenameKind -> Constr

dataTypeOf :: RenameKind -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RenameKind)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RenameKind)

gmapT :: (forall b. Data b => b -> b) -> RenameKind -> RenameKind

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RenameKind -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RenameKind -> r

gmapQ :: (forall d. Data d => d -> u) -> RenameKind -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RenameKind -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RenameKind -> m RenameKind

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RenameKind -> m RenameKind

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RenameKind -> m RenameKind

Ord RenameKind Source # 
Show RenameKind Source # 

Methods

showsPrec :: Int -> RenameKind -> ShowS

show :: RenameKind -> String

showList :: [RenameKind] -> ShowS

GetRange RenameKind Source # 

data Rename Source #

Constructors

Rename Id (Maybe (RenameKind, Maybe (SORT, SORT))) 

Instances

Eq Rename Source # 

Methods

(==) :: Rename -> Rename -> Bool

(/=) :: Rename -> Rename -> Bool

Data Rename Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rename -> c Rename

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Rename

toConstr :: Rename -> Constr

dataTypeOf :: Rename -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Rename)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rename)

gmapT :: (forall b. Data b => b -> b) -> Rename -> Rename

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rename -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rename -> r

gmapQ :: (forall d. Data d => d -> u) -> Rename -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rename -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rename -> m Rename

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rename -> m Rename

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rename -> m Rename

Ord Rename Source # 

Methods

compare :: Rename -> Rename -> Ordering

(<) :: Rename -> Rename -> Bool

(<=) :: Rename -> Rename -> Bool

(>) :: Rename -> Rename -> Bool

(>=) :: Rename -> Rename -> Bool

max :: Rename -> Rename -> Rename

min :: Rename -> Rename -> Rename

Show Rename Source # 

Methods

showsPrec :: Int -> Rename -> ShowS

show :: Rename -> String

showList :: [Rename] -> ShowS

GetRange Rename Source # 

data RENAMING Source #

CSP renamings are predicate names or op names.

Constructors

Renaming [Rename] 

Instances

Eq RENAMING Source # 

Methods

(==) :: RENAMING -> RENAMING -> Bool

(/=) :: RENAMING -> RENAMING -> Bool

Data RENAMING Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RENAMING -> c RENAMING

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RENAMING

toConstr :: RENAMING -> Constr

dataTypeOf :: RENAMING -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RENAMING)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RENAMING)

gmapT :: (forall b. Data b => b -> b) -> RENAMING -> RENAMING

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RENAMING -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RENAMING -> r

gmapQ :: (forall d. Data d => d -> u) -> RENAMING -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RENAMING -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RENAMING -> m RENAMING

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RENAMING -> m RENAMING

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RENAMING -> m RENAMING

Ord RENAMING Source # 

Methods

compare :: RENAMING -> RENAMING -> Ordering

(<) :: RENAMING -> RENAMING -> Bool

(<=) :: RENAMING -> RENAMING -> Bool

(>) :: RENAMING -> RENAMING -> Bool

(>=) :: RENAMING -> RENAMING -> Bool

max :: RENAMING -> RENAMING -> RENAMING

min :: RENAMING -> RENAMING -> RENAMING

Show RENAMING Source # 

Methods

showsPrec :: Int -> RENAMING -> ShowS

show :: RENAMING -> String

showList :: [RENAMING] -> ShowS

GetRange RENAMING Source # 

data TypedChanName Source #

A process communication alphabet consists of a set of sort names and typed channel names.

Instances

Eq TypedChanName Source # 
Data TypedChanName Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypedChanName -> c TypedChanName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypedChanName

toConstr :: TypedChanName -> Constr

dataTypeOf :: TypedChanName -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypedChanName)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypedChanName)

gmapT :: (forall b. Data b => b -> b) -> TypedChanName -> TypedChanName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypedChanName -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypedChanName -> r

gmapQ :: (forall d. Data d => d -> u) -> TypedChanName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypedChanName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypedChanName -> m TypedChanName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypedChanName -> m TypedChanName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypedChanName -> m TypedChanName

Ord TypedChanName Source # 
Show TypedChanName Source # 

Methods

showsPrec :: Int -> TypedChanName -> ShowS

show :: TypedChanName -> String

showList :: [TypedChanName] -> ShowS

GetRange TypedChanName Source #