Copyright	(c) Christian Maeder and Uni Bremen 2002-2005
License	GPLv2 or higher, see LICENSE.txt
Maintainer	Christian.Maeder@dfki.de
Stability	provisional
Portability	portable
Safe Haskell	None

HasCASL.ParseTerm

Contents

key sign tokens
parser for bracketed lists
kinds
type variables
parse special identifier tokens
type patterns
types a parsed type may also be interpreted as a kind (by the mixfix analysis)
varDecls and genVarDecls
patterns
terms

Description

parser for HasCASL kinds, types, terms, patterns and equations

Synopsis

colT :: AParser st Token
bracketParser :: AParser st a -> AParser st Token -> AParser st Token -> AParser st Token -> ([a] -> Range -> b) -> AParser st b
mkBrackets :: AParser st a -> ([a] -> Range -> b) -> AParser st b
mkBraces :: AParser st a -> ([a] -> Range -> b) -> AParser st b
parseClassId :: AParser st Kind
parseSimpleKind :: AParser st Kind
parseExtKind :: AParser st (Variance, Kind)
arrowKind :: (Variance, Kind) -> AParser st Kind
kind :: AParser st Kind
extKind :: AParser st (Variance, Kind)
variance :: AParser st Variance
extVar :: AParser st Id -> AParser st (Id, Variance)
typeVars :: AParser st [TypeArg]
allIsNonVar :: [(Id, Variance)] -> Bool
typeKind :: Bool -> [(Id, Variance)] -> [Token] -> AParser st [TypeArg]
makeTypeArgs :: [(Id, Variance)] -> [Token] -> Variance -> VarKind -> Range -> [TypeArg]
singleTypeArg :: AParser st TypeArg
parenTypeArg :: AParser st (TypeArg, [Token])
typeArg :: AParser st (TypeArg, [Token])
typePatternArg :: AParser st TypePattern
type TokenMode = [String]
aToken :: TokenMode -> AParser st Token
idToken :: AParser st Token
primTypePatternOrId :: AParser st TypePattern
mixTypePattern :: AParser st TypePattern -> AParser st TypePattern
typePatternOrId :: AParser st TypePattern
typePatternToken :: AParser st TypePattern
primTypePattern :: AParser st TypePattern
typePattern :: AParser st TypePattern
typeToken :: AParser st Type
primTypeOrId :: AParser st Type
mkMixfixType :: AParser st Type -> AParser st Type
mkKindedMixType :: AParser st Type -> AParser st Type
typeOrId :: AParser st Type
kindAnno :: Type -> AParser st Type
primType :: AParser st Type
lazyType :: AParser st Type
mixType :: AParser st Type
prodType :: AParser st Type
parseType :: AParser st Type
arrowT :: AParser st Id
typeScheme :: PolyId -> AParser st TypeScheme
varDecls :: AParser st [VarDecl]
varDeclType :: [Id] -> [Token] -> AParser st [VarDecl]
makeVarDecls :: [Id] -> [Token] -> Type -> Range -> [VarDecl]
genVarDecls :: AParser st [GenVarDecl]
tokenPattern :: TokenMode -> AParser st Term
primPattern :: TokenMode -> AParser st Term
mkMixfixTerm :: [Term] -> Term
mixPattern :: TokenMode -> AParser st Term
typedPattern :: TokenMode -> AParser st Term
asPattern :: TokenMode -> AParser st Term
pattern :: AParser st Term
myChoice :: [(AParser st Token, a)] -> AParser st (a, Token)
lamDot :: AParser st (Partiality, Token)
lamPattern :: AParser st [Term]
tToken :: TokenMode -> AParser st Token
termToken :: TokenMode -> AParser st Term
primTerm :: TokenMode -> AParser st Term
data InMode
- = NoIn
- | WithIn
baseTerm :: (InMode, TokenMode) -> AParser st Term
whenTerm :: (InMode, TokenMode) -> AParser st Term
ifTerm :: (InMode, TokenMode) -> AParser st Term
termInParens :: AParser st Term
varTerm :: AParser st Term
opBrand :: AParser st (Token, OpBrand)
parsePolyId :: AParser st PolyId
qualOpName :: AParser st Term
qualPredName :: AParser st Term
typeQual :: InMode -> AParser st (TypeQual, Token)
qualAndType :: InMode -> AParser st Term
typedTerm :: (InMode, TokenMode) -> AParser st Term
mixTerm :: (InMode, TokenMode) -> AParser st Term
hasCaslStartKeywords :: [String]
whereTerm :: (InMode, TokenMode) -> AParser st Term
term :: AParser st Term
exQuant :: AParser st (Token, Quantifier)
exTerm :: (InMode, TokenMode) -> AParser st Term
lamDecls :: AParser st [Term]
lambdaTerm :: (InMode, TokenMode) -> AParser st Term
caseTerm :: (InMode, TokenMode) -> AParser st Term
letTerm :: (InMode, TokenMode) -> AParser st Term
patternTermPair :: TokenMode -> (InMode, TokenMode) -> String -> AParser st ProgEq

key sign tokens

colT :: AParser st Token Source #

a colon not followed by a question mark

parser for bracketed lists

bracketParser :: AParser st a -> AParser st Token -> AParser st Token -> AParser st Token -> ([a] -> Range -> b) -> AParser st b Source #

a generic bracket parser

mkBrackets :: AParser st a -> ([a] -> Range -> b) -> AParser st b Source #

parser for square brackets

mkBraces :: AParser st a -> ([a] -> Range -> b) -> AParser st b Source #

parser for braces

kinds

parseClassId :: AParser st Kind Source #

parse a simple class name or the type universe as kind

parseSimpleKind :: AParser st Kind Source #

do parseClassId or a kind in parenthessis

parseExtKind :: AParser st (Variance, Kind) Source #

do parseSimpleKind and check for an optional Variance

arrowKind :: (Variance, Kind) -> AParser st Kind Source #

parse a (right associative) function kind for a given argument kind

kind :: AParser st Kind Source #

parse a function kind but reject an extended kind

extKind :: AParser st (Variance, Kind) Source #

parse a function kind but accept an extended kind

type variables

variance :: AParser st Variance Source #

extVar :: AParser st Id -> AParser st (Id, Variance) Source #

typeVars :: AParser st [TypeArg] Source #

allIsNonVar :: [(Id, Variance)] -> Bool Source #

typeKind :: Bool -> [(Id, Variance)] -> [Token] -> AParser st [TypeArg] Source #

makeTypeArgs :: [(Id, Variance)] -> [Token] -> Variance -> VarKind -> Range -> [TypeArg] Source #

add the Kind to all extVar and yield a TypeArg

singleTypeArg :: AParser st TypeArg Source #

a single TypeArg (parsed by typeVars)

parenTypeArg :: AParser st (TypeArg, [Token]) Source #

a singleTypeArg put in parentheses

typeArg :: AParser st (TypeArg, [Token]) Source #

a singleTypeArg possibly put in parentheses

typePatternArg :: AParser st TypePattern Source #

a singleTypeArg put in parentheses as TypePattern

parse special identifier tokens

type TokenMode = [String] Source #

aToken :: TokenMode -> AParser st Token Source #

parse a Token of an Id (to be declared) but exclude the signs in TokenMode

idToken :: AParser st Token Source #

just aToken only excluding basic HasCASL keywords

type patterns

primTypePatternOrId :: AParser st TypePattern Source #

mixTypePattern :: AParser st TypePattern -> AParser st TypePattern Source #

typePatternOrId :: AParser st TypePattern Source #

typePatternToken :: AParser st TypePattern Source #

those (top-level) Tokens (less than idToken) that may appear in TypePatterns as TypePatternToken.

primTypePattern :: AParser st TypePattern Source #

a typePatternToken or something in braces (a typePattern), in square brackets (a typePatternOrId covering compound lists) or parenthesis (typePatternArg)

typePattern :: AParser st TypePattern Source #

types a parsed type may also be interpreted as a kind (by the mixfix analysis)

typeToken :: AParser st Type Source #

type tokens with some symbols removed

primTypeOrId :: AParser st Type Source #

TypeTokens within BracketTypes may recusively be idTokens. Parenthesis may group a mixfix type or may be interpreted as a kind later on in a GEN-VAR-DECL.

mkMixfixType :: AParser st Type -> AParser st Type Source #

mkKindedMixType :: AParser st Type -> AParser st Type Source #

typeOrId :: AParser st Type Source #

several primTypeOrIds possibly yielding a MixfixType and possibly followed by a kindAnno.

kindAnno :: Type -> AParser st Type Source #

a Kind annotation starting with colT.

primType :: AParser st Type Source #

a typeToken' or a BracketType. Square brackets may contain typeOrId.

lazyType :: AParser st Type Source #

a primType possibly preceded by quMarkT

mixType :: AParser st Type Source #

several lazyTypes (as MixfixType) possibly followed by kindAnno

prodType :: AParser st Type Source #

mixType possibly interspersed with crossT

parseType :: AParser st Type Source #

a (right associativ) function type

arrowT :: AParser st Id Source #

parse one of the four possible Arrows

typeScheme :: PolyId -> AParser st TypeScheme Source #

parse a TypeScheme using forallT, typeVars, dotT and parseType

varDecls and genVarDecls

varDecls :: AParser st [VarDecl] Source #

comma separated var with varDeclType

varDeclType :: [Id] -> [Token] -> AParser st [VarDecl] Source #

a type (parseType) following a colon

makeVarDecls :: [Id] -> [Token] -> Type -> Range -> [VarDecl] Source #

attach the Type to every Var

genVarDecls :: AParser st [GenVarDecl] Source #

either like varDecls or declared type variables. A GenVarDecl may later become a GenTypeVarDecl.

patterns

tokenPattern :: TokenMode -> AParser st Term Source #

different legal TermTokens possibly excluding funS or equalS for case or let patterns resp.

primPattern :: TokenMode -> AParser st Term Source #

tokenPattern or BracketTerm

mkMixfixTerm :: [Term] -> Term Source #

mixPattern :: TokenMode -> AParser st Term Source #

several typedPattern

typedPattern :: TokenMode -> AParser st Term Source #

a possibly typed (parseType) pattern

asPattern :: TokenMode -> AParser st Term Source #

top-level pattern (possibly AsPattern)

pattern :: AParser st Term Source #

an unrestricted asPattern

myChoice :: [(AParser st Token, a)] -> AParser st (a, Token) Source #

lamDot :: AParser st (Partiality, Token) Source #

a Total or Partial lambda dot

lamPattern :: AParser st [Term] Source #

patterns between lamS and lamDot

terms

tToken :: TokenMode -> AParser st Token Source #

Tokens that may occur in Terms including literals scanFloat, scanString but excluding ifS, whenS and elseS to allow a quantifier after whenS. In case-terms also barS will be excluded on the top-level.