{- |

Module : ./Common/Keywords.hs

Description : String constants for CASL keywords to be used for parsing

and printing

Copyright : (c) Christian Maeder and Uni Bremen 2002-2003

License : GPLv2 or higher, see LICENSE.txt

Maintainer : Christian.Maeder@dfki.de

Stability : provisional

Portability : portable

String constants for keywords to be used for parsing and printing

- all identifiers are mixed case (i.e. the keyword followed by a capital S)

- see <http://www.cofi.info/Documents/CASL/Summary/> from 25 March 2001,

C.4 Lexical Syntax

-}

module Common.Keywords where

-- * context dependend keywords

-- | sub sort indicator

lessS :: String

lessS = "<"

-- | modifier for 'existsS'

exMark :: String

exMark = "!"

-- | modifier for 'funS' or 'colonS'

quMark :: String

quMark = "?"

-- * type constructors

-- | total function arrow

funS :: String

funS = "->"

-- | partial function arrow

pFun :: String

pFun = funS ++ quMark

-- | ascii product type sign

prodS :: String

prodS = "*"

-- | alternative latin1 product type sign

timesS :: String

timesS = "\215"

-- * symbol keywords

-- | the colon sign

colonS :: String

colonS = ":"

equiS :: String

equiS = "<->"

-- | the dot sign (ascii)

dotS :: String

dotS = "."

-- | the alternative latin1 centered dot sign

cDot :: String

cDot = "\183"

-- | the vertical bar

barS :: String

barS = "|"

-- | arrow started with a bar

mapsTo :: String

mapsTo = "|->"

-- | two colons and an equal sign

defnS :: String

defnS = "::="

-- | a colon with a question mark

colonQuMark :: String

colonQuMark = colonS ++ quMark

-- | the exists keyword with an exclamation mark

existsUnique :: String

existsUnique = existsS ++ exMark

-- * comment keywords

-- | one percent sign

percentS :: String

percentS = "%"

-- | two percent signs (for line comments)

percents :: String

percents = percentS ++ percentS

-- * formula symbols

-- | implication arrow (equal and greater)

implS :: String

implS = "=>"

-- | equivalent sign

equivS :: String

equivS = "<=>"

-- | the alternative latin1 negation sign for not

negS :: String

negS = "\172"

-- | logical and using slashes

lAnd :: String

lAnd = "/\\"

-- | logical or using slashes

lOr :: String

lOr = "\\/"

-- * further HasCASL key signs

-- | assign sign (colon and equal)

assignS :: String

assignS = ":="

-- | minus sign (for variance)

minusS :: String

minusS = "-"

-- | plus sign (for variance)

plusS :: String

plusS = "+"

-- | total continuous function arrow

contFun :: String

contFun = minusS ++ funS

-- | partial continuous function arrow

pContFun :: String

pContFun = minusS ++ pFun

-- | lambda sign (backslash)

lamS :: String

lamS = "\\"

-- | at sign (for as pattern)

asP :: String

asP = "@"

-- | Here sign

hereP :: String

hereP = "Here"

-- | Bind sign

bindP :: String

bindP = "Bind"

-- | assign sign in monad notation

rightArrow :: String

rightArrow = "<-"

-- * further HasCASL keywords

-- | the new keyword fun ('funS' is already defined differently)

functS :: String

functS = "fun"

-- * CoCasl key signs

-- | the diamond sign (less and greater)

diamondS :: String

diamondS = "<>"

-- | the greater sign

greaterS :: String

greaterS = ">"

-- * OWL key signs

lessEq :: String

lessEq = "<="

greaterEq :: String

greaterEq = ">="

-- * CspCasl key signs

-- | Prefix processes

prefix_procS :: String

prefix_procS = "->"

-- | sequential process operator

sequentialS :: String

sequentialS = ";"

-- | interleaving parallel operator

interleavingS :: String

interleavingS = "|||"

-- | synchronous parallel operator

synchronousS :: String

synchronousS = "||"

-- | Open generalised parallel

genpar_openS :: String

genpar_openS = "[|"

-- | Close generalised parallel

genpar_closeS :: String

genpar_closeS = "|]"

-- | Open alpabetised parallel

alpar_openS :: String

alpar_openS = "["

-- | Separator in alpabetised parallel

alpar_sepS :: String

alpar_sepS = "||"

-- | Close alpabetised parallel

alpar_closeS :: String

alpar_closeS = "]"

-- | External choice

external_choiceS :: String

external_choiceS = "[]"

-- | Internal choice

internal_choiceS :: String

internal_choiceS = "|~|"

-- | Hiding (process)

hiding_procS :: String

hiding_procS = "\\"

-- | Open a renaming (process)

ren_proc_openS :: String

ren_proc_openS = "[["

-- | Close a renaming (process)

ren_proc_closeS :: String

ren_proc_closeS = "]]"

-- * logic definition symbols

newlogicS :: String

newlogicS = "newlogic"

metaS :: String

metaS = "meta"

foundationS :: String

foundationS = "foundation"

syntaxS :: String

syntaxS = "syntax"

patternsS :: String

patternsS = "patterns"

modelsS :: String

modelsS = "models"

proofsS :: String

proofsS = "proofs"

newcomorphismS :: String

newcomorphismS = "newcomorphism"

sourceS :: String

sourceS = "source"

targetS :: String

targetS = "target"

-- * DOL keywords

alignArityBackwardS :: String

alignArityBackwardS = "align-arity-backward"

alignArityForwardS :: String

alignArityForwardS = "align-arity-forward"

alignmentS :: String

alignmentS = "alignment"

combineS :: String

combineS = "combine"

excludingS :: String

excludingS = "excluding"

entailmentS :: String

entailmentS = "entailment"

entailsS :: String

entailsS = "entails"

forS :: String

forS = "for"

interpretationS :: String

interpretationS = "interpretation"

moduleS :: String

moduleS = "module"

ontologyS :: String

ontologyS = "ontology"

networkS :: String

networkS = "network"

relationS :: String

relationS = "relation"

serializationS :: String

serializationS = "serialization"

-- * frameworks

lfS :: String

lfS = "LF"

isabelleS :: String

isabelleS = "Isabelle"

maudeS :: String

maudeS = "Maude"

-- * MMT symbols

sigDelimS :: String

sigDelimS = ".."

structDelimS :: String

structDelimS = "/"

-- * Twelf conventions

-- non breaking space

whiteChars :: String

whiteChars = "\n\r\t\v\f \160"

-- special characters permitted in a Twelf symbol name

twelfSymChars :: String

twelfSymChars = "_-+*/<=>@^"

-- special characters permitted in a Twelf declaration

twelfDeclChars :: String

twelfDeclChars = twelfSymChars ++ ":{}[]()"

-- special characters permitted in a Twelf declaration of multiple symbols

twelfMultDeclChars :: String

twelfMultDeclChars = twelfDeclChars ++ ","

-- * letter keywords taken from Keywords.txt

andS :: String

andS = "and"

archS :: String

archS = "arch"

asS :: String

asS = "as"

assocS :: String

assocS = "assoc"

axiomS :: String

axiomS = "axiom"

behaviourallyS :: String

behaviourallyS = "behaviourally"

caseS :: String

caseS = "case"

classS :: String

classS = "class"

closedS :: String

closedS = "closed"

closedworldS :: String

closedworldS = "closed-world"

cofreeS :: String

cofreeS = "cofree"

cogeneratedS :: String

cogeneratedS = "cogenerated"

commS :: String

commS = "comm"

cotypeS :: String

cotypeS = "cotype"

dataS :: String

dataS = "data"

defS :: String

defS = "def"

derivingS :: String

derivingS = "deriving"

displayS :: String

displayS = "display"

doS :: String

doS = "do"

elseS :: String

elseS = "else"

emptyS :: String

emptyS = "empty"

endS :: String

endS = "end"

equivalenceS :: String

equivalenceS = "equivalence"

esortS :: String

esortS = "esort"

etypeS :: String

etypeS = "etype"

existsS :: String

existsS = "exists"

extractS :: String

extractS = "extract"

falseS :: String

falseS = "false"

fitS :: String

fitS = "fit"

flexibleS :: String

flexibleS = "flexible"

floatingS :: String

floatingS = "floating"

forallS :: String

forallS = "forall"

forgetS :: String

forgetS = "forget"

freeS :: String

freeS = "free"

fromS :: String

fromS = "from"

generatedS :: String

generatedS = "generated"

getS :: String

getS = "get"

givenS :: String

givenS = "given"

hideS :: String

hideS = "hide"

keepS :: String

keepS = "keep"

approximateS :: String

approximateS = "approximate"

idemS :: String

idemS = "idem"

ifS :: String

ifS = "if"

inS :: String

inS = "in"

instanceS :: String

instanceS = "instance"

internalS :: String

internalS = "internal"

intersectS :: String

intersectS = "intersect"

lambdaS :: String

lambdaS = "lambda"

left_assocS :: String

left_assocS = "left_assoc"

letS :: String

letS = "let"

libraryS :: String

libraryS = "library"

listS :: String

listS = "list"

localS :: String

localS = "local"

logicS :: String

logicS = "logic"

minimizeS :: String

minimizeS = "minimize"

modalitiesS :: String

modalitiesS = "modalities"

modalityS :: String

modalityS = "modality"

notS :: String

notS = "not"

numberS :: String

numberS = "number"

ofS :: String

ofS = "of"

opS :: String

opS = "op"

precS :: String

precS = "prec"

predS :: String

predS = "pred"

prefixS :: String

prefixS = "prefix"

programS :: String

programS = "program"

propS :: String

propS = "prop"

refinedS :: String

refinedS = "refined"

refinementS :: String

refinementS = "refinement"

rejectS :: String

rejectS = "reject"

removeS :: String

removeS = "remove"

resultS :: String

resultS = "result"

revealS :: String

revealS = "reveal"

right_assocS :: String

right_assocS = "right_assoc"

rigidS :: String

rigidS = "rigid"

sS :: String

sS = "s"

selectS :: String

selectS = "select"

sortS :: String

sortS = "sort"

specS :: String

specS = "spec"

stringS :: String

stringS = "string"

structS :: String

structS = "struct"

termS :: String

termS = "term"

thenS :: String

thenS = "then"

toS :: String

toS = "to"

trueS :: String

trueS = "true"

typeS :: String

typeS = "type"

unitS :: String

unitS = "unit"

varS :: String

varS = "var"

varsS :: String

varsS = "vars"

versionS :: String

versionS = "version"

viaS :: String

viaS = "via"

viewS :: String

viewS = "view"

whenS :: String

whenS = "when"

whereS :: String

whereS = "where"

withS :: String

withS = "with"

withinS :: String

withinS = "within"