Curry.FlatCurry.Annotated.Goodies

TODO

Documentation

trAProg :: (String -> [String] -> [TypeDecl] -> [AFuncDecl a] -> [OpDecl] -> b) -> AProg a -> b

transform program

aProgName :: AProg a -> String

get name from program

aProgImports :: AProg a -> [String]

get imports from program

aProgTypes :: AProg a -> [TypeDecl]

get type declarations from program

aProgAFuncs :: AProg a -> [AFuncDecl a]

get functions from program

aProgOps :: AProg a -> [OpDecl]

get infix operators from program

updAProg :: (String -> String) -> ([String] -> [String]) -> ([TypeDecl] -> [TypeDecl]) -> ([AFuncDecl a] -> [AFuncDecl a]) -> ([OpDecl] -> [OpDecl]) -> AProg a -> AProg a

update program

updAProgName :: Update (AProg a) String

update name of program

updAProgImports :: Update (AProg a) [String]

update imports of program

updAProgTypes :: Update (AProg a) [TypeDecl]

update type declarations of program

updAProgAFuncs :: Update (AProg a) [AFuncDecl a]

update functions of program

updAProgOps :: Update (AProg a) [OpDecl]

update infix operators of program

allVarsInAProg :: AProg a -> [(VarIndex, a)]

get all program variables (also from patterns)

updAProgAExps :: Update (AProg a) (AExpr a)

lift transformation on expressions to program

rnmAllVarsInAProg :: Update (AProg a) VarIndex

rename programs variables

updQNamesInAProg :: Update (AProg a) QName

update all qualified names in program

rnmAProg :: String -> AProg a -> AProg a

rename program (update name of and all qualified names in program)

trAFunc :: (QName -> Int -> Visibility -> TypeExpr -> ARule a -> b) -> AFuncDecl a -> b

transform function

aFuncName :: AFuncDecl a -> QName

get name of function

aFuncArity :: AFuncDecl a -> Int

get arity of function

aFuncVisibility :: AFuncDecl a -> Visibility

get visibility of function

aFuncType :: AFuncDecl a -> TypeExpr

get type of function

aFuncARule :: AFuncDecl a -> ARule a

get rule of function

updAFunc :: (QName -> QName) -> (Int -> Int) -> (Visibility -> Visibility) -> (TypeExpr -> TypeExpr) -> (ARule a -> ARule a) -> AFuncDecl a -> AFuncDecl a

update function

updAFuncName :: Update (AFuncDecl a) QName

update name of function

updAFuncArity :: Update (AFuncDecl a) Int

update arity of function

updAFuncVisibility :: Update (AFuncDecl a) Visibility

update visibility of function

updFuncType :: Update (AFuncDecl a) TypeExpr

update type of function

updAFuncARule :: Update (AFuncDecl a) (ARule a)

update rule of function

isPublicAFunc :: AFuncDecl a -> Bool

is function public?

isExternal :: AFuncDecl a -> Bool

is function externally defined?

allVarsInAFunc :: AFuncDecl a -> [(VarIndex, a)]

get variable names in a function declaration

aFuncArgs :: AFuncDecl a -> [(VarIndex, a)]

get arguments of function, if not externally defined

aFuncBody :: AFuncDecl a -> AExpr a

get body of function, if not externally defined

aFuncRHS :: AFuncDecl a -> [AExpr a]

get the right-hand-sides of a FuncDecl

rnmAllVarsInAFunc :: Update (AFuncDecl a) VarIndex

rename all variables in function

updQNamesInAFunc :: Update (AFuncDecl a) QName

update all qualified names in function

updAFuncArgs :: Update (AFuncDecl a) [(VarIndex, a)]

update arguments of function, if not externally defined

updAFuncBody :: Update (AFuncDecl a) (AExpr a)

update body of function, if not externally defined

trARule :: (a -> [(VarIndex, a)] -> AExpr a -> b) -> (a -> String -> b) -> ARule a -> b

transform rule

aRuleAnnot :: ARule a -> a

get rules annotation

aRuleArgs :: ARule a -> [(VarIndex, a)]

get rules arguments if it's not external

aRuleBody :: ARule a -> AExpr a

get rules body if it's not external

aRuleExtDecl :: ARule a -> String

get rules external declaration

isARuleExternal :: ARule a -> Bool

is rule external?

updARule :: (a -> b) -> ([(VarIndex, a)] -> [(VarIndex, b)]) -> (AExpr a -> AExpr b) -> (String -> String) -> ARule a -> ARule b

update rule

updARuleAnnot :: Update (ARule a) a

update rules annotation

updARuleArgs :: Update (ARule a) [(VarIndex, a)]

update rules arguments

updARuleBody :: Update (ARule a) (AExpr a)

update rules body

updARuleExtDecl :: Update (ARule a) String

update rules external declaration

allVarsInARule :: ARule a -> [(VarIndex, a)]

get variable names in a functions rule

rnmAllVarsInARule :: Update (ARule a) VarIndex

rename all variables in rule

updQNamesInARule :: Update (ARule a) QName

update all qualified names in rule

annot :: AExpr a -> a

get annoation of an expression

varNr :: AExpr a -> VarIndex

get internal number of variable

literal :: AExpr a -> Literal

get literal if expression is literal expression

combType :: AExpr a -> CombType

get combination type of a combined expression

combName :: AExpr a -> (QName, a)

get name of a combined expression

combArgs :: AExpr a -> [AExpr a]

get arguments of a combined expression

missingCombArgs :: AExpr a -> Int

get number of missing arguments if expression is combined

letBinds :: AExpr a -> [((VarIndex, a), AExpr a)]

get indices of varoables in let declaration

letBody :: AExpr a -> AExpr a

get body of let declaration

freeVars :: AExpr a -> [(VarIndex, a)]

get variable indices from declaration of free variables

freeExpr :: AExpr a -> AExpr a

get expression from declaration of free variables

orExps :: AExpr a -> [AExpr a]

get expressions from or-expression

caseType :: AExpr a -> CaseType

get case-type of case expression

caseExpr :: AExpr a -> AExpr a

get scrutinee of case expression

caseBranches :: AExpr a -> [ABranchExpr a]

get branch expressions from case expression

isAVar :: AExpr a -> Bool

is expression a variable?

isALit :: AExpr a -> Bool

is expression a literal expression?

isAComb :: AExpr a -> Bool

is expression combined?

isALet :: AExpr a -> Bool

is expression a let expression?

isAFree :: AExpr a -> Bool

is expression a declaration of free variables?

isAOr :: AExpr a -> Bool

is expression an or-expression?

isACase :: AExpr a -> Bool

is expression a case expression?

trAExpr :: (a -> VarIndex -> b) -> (a -> Literal -> b) -> (a -> CombType -> (QName, a) -> [b] -> b) -> (a -> [((VarIndex, a), b)] -> b -> b) -> (a -> [(VarIndex, a)] -> b -> b) -> (a -> b -> b -> b) -> (a -> CaseType -> b -> [c] -> b) -> (APattern a -> b -> c) -> (a -> b -> TypeExpr -> b) -> AExpr a -> b

transform expression

updVars :: (a -> VarIndex -> AExpr a) -> AExpr a -> AExpr a

update all variables in given expression

updLiterals :: (a -> Literal -> AExpr a) -> AExpr a -> AExpr a

update all literals in given expression

updCombs :: (a -> CombType -> (QName, a) -> [AExpr a] -> AExpr a) -> AExpr a -> AExpr a

update all combined expressions in given expression

updLets :: (a -> [((VarIndex, a), AExpr a)] -> AExpr a -> AExpr a) -> AExpr a -> AExpr a

update all let expressions in given expression

updFrees :: (a -> [(VarIndex, a)] -> AExpr a -> AExpr a) -> AExpr a -> AExpr a

update all free declarations in given expression

updOrs :: (a -> AExpr a -> AExpr a -> AExpr a) -> AExpr a -> AExpr a

update all or expressions in given expression

updCases :: (a -> CaseType -> AExpr a -> [ABranchExpr a] -> AExpr a) -> AExpr a -> AExpr a

update all case expressions in given expression

updBranches :: (APattern a -> AExpr a -> ABranchExpr a) -> AExpr a -> AExpr a

update all case branches in given expression

updTypeds :: (a -> AExpr a -> TypeExpr -> AExpr a) -> AExpr a -> AExpr a

update all typed expressions in given expression

isFuncCall :: AExpr a -> Bool

is expression a call of a function where all arguments are provided?

isFuncPartCall :: AExpr a -> Bool

is expression a partial function call?

isConsCall :: AExpr a -> Bool

is expression a call of a constructor?

isConsPartCall :: AExpr a -> Bool

is expression a partial constructor call?

isGround :: AExpr a -> Bool

is expression fully evaluated?

allVars :: AExpr a -> [(VarIndex, a)]

get all variables (also pattern variables) in expression

rnmAllVars :: Update (AExpr a) VarIndex

rename all variables (also in patterns) in expression

updQNames :: Update (AExpr a) QName

update all qualified names in expression

trABranch :: (APattern a -> AExpr a -> b) -> ABranchExpr a -> b

transform branch expression

aBranchAPattern :: ABranchExpr a -> APattern a

get pattern from branch expression

aBranchAExpr :: ABranchExpr a -> AExpr a

get expression from branch expression

updABranch :: (APattern a -> APattern a) -> (AExpr a -> AExpr a) -> ABranchExpr a -> ABranchExpr a

update branch expression

updABranchAPattern :: Update (ABranchExpr a) (APattern a)

update pattern of branch expression

updABranchAExpr :: Update (ABranchExpr a) (AExpr a)

update expression of branch expression

trAPattern :: (a -> (QName, a) -> [(VarIndex, a)] -> b) -> (a -> Literal -> b) -> APattern a -> b

transform pattern

aPatAnnot :: APattern a -> a

get annotation from pattern

aPatCons :: APattern a -> (QName, a)

get name from constructor pattern

aPatArgs :: APattern a -> [(VarIndex, a)]

get arguments from constructor pattern

aPatLiteral :: APattern a -> Literal

get literal from literal pattern

isConsPattern :: APattern a -> Bool

is pattern a constructor pattern?

updAPattern :: (a -> a) -> ((QName, a) -> (QName, a)) -> ([(VarIndex, a)] -> [(VarIndex, a)]) -> (Literal -> Literal) -> APattern a -> APattern a

update pattern

updAPatAnnot :: (a -> a) -> APattern a -> APattern a

update annotation of pattern

updAPatCons :: ((QName, a) -> (QName, a)) -> APattern a -> APattern a

update constructors name of pattern

updAPatArgs :: ([(VarIndex, a)] -> [(VarIndex, a)]) -> APattern a -> APattern a

update arguments of constructor pattern

updAPatLiteral :: (Literal -> Literal) -> APattern a -> APattern a

update literal of pattern

aPatExpr :: APattern a -> AExpr a

build expression from pattern

module Curry.FlatCurry.Goodies