Module FlatCurry.Annotated.Goodies

Exported Datatypes

Exported Functions

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

transform program

progName :: AProg a -> String   

get name from program

progImports :: AProg a -> [String]   

get imports from program

progTypes :: AProg a -> [TypeDecl]   

get type declarations from program

progFuncs :: AProg a -> [AFuncDecl a]   

get functions from program

progOps :: AProg a -> [OpDecl]   

get infix operators from program

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

update program

updProgName :: (String -> String) -> AProg a -> AProg a   

update name of program

updProgImports :: ([String] -> [String]) -> AProg a -> AProg a   

update imports of program

updProgTypes :: ([TypeDecl] -> [TypeDecl]) -> AProg a -> AProg a   

update type declarations of program

updProgFuncs :: ([AFuncDecl a] -> [AFuncDecl a]) -> AProg a -> AProg a   

update functions of program

updProgOps :: ([OpDecl] -> [OpDecl]) -> AProg a -> AProg a   

update infix operators of program

allVarsInProg :: AProg a -> [Int]   

get all program variables (also from patterns)

updProgExps :: (AExpr a -> AExpr a) -> AProg a -> AProg a   

lift transformation on expressions to program

rnmAllVarsInProg :: (Int -> Int) -> AProg a -> AProg a   

rename programs variables

updQNamesInProg :: ((String, String) -> (String, String)) -> AProg a -> AProg a   

update all qualified names in program

rnmProg :: String -> AProg a -> AProg a   

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

trType :: ((String, String) -> Visibility -> [(Int, Kind)] -> [ConsDecl] -> a) -> ((String, String) -> Visibility -> [(Int, Kind)] -> TypeExpr -> a) -> ((String, String) -> Visibility -> [(Int, Kind)] -> NewConsDecl -> a) -> TypeDecl -> a   

transform type declaration

typeName :: TypeDecl -> (String, String)   

get name of type declaration

typeVisibility :: TypeDecl -> Visibility   

get visibility of type declaration

typeParams :: TypeDecl -> [(Int, Kind)]   

get type parameters of type declaration

typeConsDecls :: TypeDecl -> [ConsDecl]   

get constructor declarations from type declaration

typeSyn :: TypeDecl -> TypeExpr   

get synonym of type declaration

isTypeData :: TypeDecl -> Bool   

is type declaration a basic data type?

isTypeSyn :: TypeDecl -> Bool   

is type declaration a type synonym?

isTypeNew :: TypeDecl -> Bool   

is type declaration a newtype?

updType :: ((String, String) -> (String, String)) -> (Visibility -> Visibility) -> ([(Int, Kind)] -> [(Int, Kind)]) -> ([ConsDecl] -> [ConsDecl]) -> (NewConsDecl -> NewConsDecl) -> (TypeExpr -> TypeExpr) -> TypeDecl -> TypeDecl   

update type declaration

updTypeName :: ((String, String) -> (String, String)) -> TypeDecl -> TypeDecl   

update name of type declaration

updTypeVisibility :: (Visibility -> Visibility) -> TypeDecl -> TypeDecl   

update visibility of type declaration

updTypeParams :: ([(Int, Kind)] -> [(Int, Kind)]) -> TypeDecl -> TypeDecl   

update type parameters of type declaration

updTypeConsDecls :: ([ConsDecl] -> [ConsDecl]) -> TypeDecl -> TypeDecl   

update constructor declarations of type declaration

updTypeNewConsDecl :: (NewConsDecl -> NewConsDecl) -> TypeDecl -> TypeDecl   

update newtype constructor declaration of type declaration

updTypeSynonym :: (TypeExpr -> TypeExpr) -> TypeDecl -> TypeDecl   

update synonym of type declaration

updQNamesInType :: ((String, String) -> (String, String)) -> TypeDecl -> TypeDecl   

update all qualified names in type declaration

trCons :: ((String, String) -> Int -> Visibility -> [TypeExpr] -> a) -> ConsDecl -> a   

transform constructor declaration

consName :: ConsDecl -> (String, String)   

get name of constructor declaration

consArity :: ConsDecl -> Int   

get arity of constructor declaration

consVisibility :: ConsDecl -> Visibility   

get visibility of constructor declaration

consArgs :: ConsDecl -> [TypeExpr]   

get arguments of constructor declaration

updCons :: ((String, String) -> (String, String)) -> (Int -> Int) -> (Visibility -> Visibility) -> ([TypeExpr] -> [TypeExpr]) -> ConsDecl -> ConsDecl   

update constructor declaration

updConsName :: ((String, String) -> (String, String)) -> ConsDecl -> ConsDecl   

update name of constructor declaration

updConsArity :: (Int -> Int) -> ConsDecl -> ConsDecl   

update arity of constructor declaration

updConsVisibility :: (Visibility -> Visibility) -> ConsDecl -> ConsDecl   

update visibility of constructor declaration

updConsArgs :: ([TypeExpr] -> [TypeExpr]) -> ConsDecl -> ConsDecl   

update arguments of constructor declaration

updQNamesInConsDecl :: ((String, String) -> (String, String)) -> ConsDecl -> ConsDecl   

update all qualified names in constructor declaration

trNewCons :: ((String, String) -> Visibility -> TypeExpr -> a) -> NewConsDecl -> a   

transform newtype constructor declaration

newConsArg :: NewConsDecl -> TypeExpr   

newConsName :: NewConsDecl -> (String, String)   

newConsVisibility :: NewConsDecl -> Visibility   

updNewCons :: ((String, String) -> (String, String)) -> (Visibility -> Visibility) -> (TypeExpr -> TypeExpr) -> NewConsDecl -> NewConsDecl   

update newtype constructor declaration

updNewConsName :: ((String, String) -> (String, String)) -> NewConsDecl -> NewConsDecl   

update name of newtype constructor declaration

updNewConsVisibility :: (Visibility -> Visibility) -> NewConsDecl -> NewConsDecl   

update visibility of newtype constructor declaration

updNewConsArg :: (TypeExpr -> TypeExpr) -> NewConsDecl -> NewConsDecl   

update argument of newtype constructor declaration

updQNamesInNewConsDecl :: ((String, String) -> (String, String)) -> NewConsDecl -> NewConsDecl   

tVarIndex :: TypeExpr -> Int   

get index from type variable

domain :: TypeExpr -> TypeExpr   

get domain from functional type

range :: TypeExpr -> TypeExpr   

get range from functional type

tConsName :: TypeExpr -> (String, String)   

get name from constructed type

tConsArgs :: TypeExpr -> [TypeExpr]   

get arguments from constructed type

trTypeExpr :: (Int -> a) -> ((String, String) -> [a] -> a) -> (a -> a -> a) -> ([(Int, Kind)] -> a -> a) -> TypeExpr -> a   

transform type expression

isTVar :: TypeExpr -> Bool   

is type expression a type variable?

isTCons :: TypeExpr -> Bool   

is type declaration a constructed type?

isFuncType :: TypeExpr -> Bool   

is type declaration a functional type?

isForallType :: TypeExpr -> Bool   

is type declaration a forall type?

updTVars :: (Int -> TypeExpr) -> TypeExpr -> TypeExpr   

update all type variables

updTCons :: ((String, String) -> [TypeExpr] -> TypeExpr) -> TypeExpr -> TypeExpr   

update all type constructors

updFuncTypes :: (TypeExpr -> TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr   

update all functional types

updForallTypes :: ([(Int, Kind)] -> TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr   

update all forall types

argTypes :: TypeExpr -> [TypeExpr]   

get argument types from functional type

Further infos:

• solution complete, i.e., able to compute all solutions

resultType :: TypeExpr -> TypeExpr   

get result type from (nested) functional type

Further infos:

• solution complete, i.e., able to compute all solutions

rnmAllVarsInTypeExpr :: (Int -> Int) -> TypeExpr -> TypeExpr   

rename variables in type expression

updQNamesInTypeExpr :: ((String, String) -> (String, String)) -> TypeExpr -> TypeExpr   

update all qualified names in type expression

trOp :: ((String, String) -> Fixity -> Int -> a) -> OpDecl -> a   

transform operator declaration

opName :: OpDecl -> (String, String)   

get name from operator declaration

opFixity :: OpDecl -> Fixity   

get fixity of operator declaration

opPrecedence :: OpDecl -> Int   

get precedence of operator declaration

updOp :: ((String, String) -> (String, String)) -> (Fixity -> Fixity) -> (Int -> Int) -> OpDecl -> OpDecl   

update operator declaration

updOpName :: ((String, String) -> (String, String)) -> OpDecl -> OpDecl   

update name of operator declaration

updOpFixity :: (Fixity -> Fixity) -> OpDecl -> OpDecl   

update fixity of operator declaration

updOpPrecedence :: (Int -> Int) -> OpDecl -> OpDecl   

update precedence of operator declaration

trFunc :: ((String, String) -> Int -> Visibility -> TypeExpr -> ARule a -> b) -> AFuncDecl a -> b   

transform function

funcName :: AFuncDecl a -> (String, String)   

get name of function

funcArity :: AFuncDecl a -> Int   

get arity of function

funcVisibility :: AFuncDecl a -> Visibility   

get visibility of function

funcType :: AFuncDecl a -> TypeExpr   

get type of function

funcRule :: AFuncDecl a -> ARule a   

get rule of function

updFunc :: ((String, String) -> (String, String)) -> (Int -> Int) -> (Visibility -> Visibility) -> (TypeExpr -> TypeExpr) -> (ARule a -> ARule a) -> AFuncDecl a -> AFuncDecl a   

update function

updFuncName :: ((String, String) -> (String, String)) -> AFuncDecl a -> AFuncDecl a   

update name of function

updFuncArity :: (Int -> Int) -> AFuncDecl a -> AFuncDecl a   

update arity of function

updFuncVisibility :: (Visibility -> Visibility) -> AFuncDecl a -> AFuncDecl a   

update visibility of function

updFuncType :: (TypeExpr -> TypeExpr) -> AFuncDecl a -> AFuncDecl a   

update type of function

updFuncRule :: (ARule a -> ARule a) -> AFuncDecl a -> AFuncDecl a   

update rule of function

isExternal :: AFuncDecl a -> Bool   

is function externally defined?

allVarsInFunc :: AFuncDecl a -> [Int]   

get variable names in a function declaration

funcArgs :: AFuncDecl a -> [(Int, a)]   

get arguments of function, if not externally defined

funcBody :: AFuncDecl a -> AExpr a   

get body of function, if not externally defined

funcRHS :: AFuncDecl a -> [AExpr a]   

Further infos:

• partially defined

rnmAllVarsInFunc :: (Int -> Int) -> AFuncDecl a -> AFuncDecl a   

rename all variables in function

updQNamesInFunc :: ((String, String) -> (String, String)) -> AFuncDecl a -> AFuncDecl a   

update all qualified names in function

updFuncArgs :: ([(Int, a)] -> [(Int, a)]) -> AFuncDecl a -> AFuncDecl a   

update arguments of function, if not externally defined

updFuncBody :: (AExpr a -> AExpr a) -> AFuncDecl a -> AFuncDecl a   

update body of function, if not externally defined

trRule :: (a -> [(Int, a)] -> AExpr a -> b) -> (a -> String -> b) -> ARule a -> b   

transform rule

ruleArgs :: ARule a -> [(Int, a)]   

get rules arguments if it's not external

ruleBody :: ARule a -> AExpr a   

get rules body if it's not external

ruleExtDecl :: ARule a -> String   

get rules external declaration

isRuleExternal :: ARule a -> Bool   

is rule external?

updRule :: (a -> a) -> ([(Int, a)] -> [(Int, a)]) -> (AExpr a -> AExpr a) -> (String -> String) -> ARule a -> ARule a   

update rule

updRuleArgs :: ([(Int, a)] -> [(Int, a)]) -> ARule a -> ARule a   

update rules arguments

updRuleBody :: (AExpr a -> AExpr a) -> ARule a -> ARule a   

update rules body

updRuleExtDecl :: (String -> String) -> ARule a -> ARule a   

update rules external declaration

allVarsInRule :: ARule a -> [Int]   

get variable names in a functions rule

rnmAllVarsInRule :: (Int -> Int) -> ARule a -> ARule a   

rename all variables in rule

updQNamesInRule :: ((String, String) -> (String, String)) -> ARule a -> ARule a   

update all qualified names in rule

trCombType :: a -> (Int -> a) -> a -> (Int -> a) -> CombType -> a   

transform combination type

isCombTypeFuncCall :: CombType -> Bool   

is type of combination FuncCall?

isCombTypeFuncPartCall :: CombType -> Bool   

is type of combination FuncPartCall?

isCombTypeConsCall :: CombType -> Bool   

is type of combination ConsCall?

isCombTypeConsPartCall :: CombType -> Bool   

is type of combination ConsPartCall?

missingArgs :: CombType -> Int   

varNr :: AExpr a -> Int   

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 -> (String, String)   

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 -> [((Int, a), AExpr a)]   

get indices of variables in let declaration

letBody :: AExpr a -> AExpr a   

get body of let declaration

freeVars :: AExpr a -> [Int]   

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

isVar :: AExpr a -> Bool   

is expression a variable?

isLit :: AExpr a -> Bool   

is expression a literal expression?

isComb :: AExpr a -> Bool   

is expression combined?

isLet :: AExpr a -> Bool   

is expression a let expression?

isFree :: AExpr a -> Bool   

is expression a declaration of free variables?

isOr :: AExpr a -> Bool   

is expression an or-expression?

isCase :: AExpr a -> Bool   

is expression a case expression?

trExpr :: (a -> Int -> b) -> (a -> Literal -> b) -> (a -> CombType -> ((String, String), a) -> [b] -> b) -> (a -> [((Int, a), b)] -> b -> b) -> (a -> [(Int, 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 -> Int -> 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 -> ((String, String), a) -> [AExpr a] -> AExpr a) -> AExpr a -> AExpr a   

update all combined expressions in given expression

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

update all let expressions in given expression

updFrees :: (a -> [(Int, 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 -> [Int]   

get all variables (also pattern variables) in expression

rnmAllVars :: (Int -> Int) -> AExpr a -> AExpr a   

rename all variables (also in patterns) in expression

updQNames :: ((String, String) -> (String, String)) -> AExpr a -> AExpr a   

update all qualified names in expression

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

transform branch expression

branchPattern :: ABranchExpr a -> APattern a   

get pattern from branch expression

branchExpr :: ABranchExpr a -> AExpr a   

get expression from branch expression

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

update branch expression

updBranchPattern :: (APattern a -> APattern a) -> ABranchExpr a -> ABranchExpr a   

update pattern of branch expression

updBranchExpr :: (AExpr a -> AExpr a) -> ABranchExpr a -> ABranchExpr a   

update expression of branch expression

trPattern :: (a -> ((String, String), a) -> [(Int, a)] -> b) -> (a -> Literal -> b) -> APattern a -> b   

transform pattern

patCons :: APattern a -> (String, String)   

get name from constructor pattern

patArgs :: APattern a -> [(Int, a)]   

get arguments from constructor pattern

patLiteral :: APattern a -> Literal   

get literal from literal pattern

isConsPattern :: APattern a -> Bool   

is pattern a constructor pattern?

updPattern :: (((String, String), a) -> ((String, String), a)) -> ([(Int, a)] -> [(Int, a)]) -> (Literal -> Literal) -> APattern a -> APattern a   

update pattern

updPatCons :: ((String, String) -> (String, String)) -> APattern a -> APattern a   

update constructors name of pattern

updPatArgs :: ([(Int, a)] -> [(Int, a)]) -> APattern a -> APattern a   

update arguments of constructor pattern

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

update literal of pattern

patExpr :: APattern a -> AExpr a   

build expression from pattern

annRule :: ARule a -> a   

Further infos:

• solution complete, i.e., able to compute all solutions

annExpr :: AExpr a -> a   

Extract the annotation of an annotated expression.

Further infos:

• solution complete, i.e., able to compute all solutions

annPattern :: APattern a -> a   

Extract the annotation of an annotated pattern.

Further infos:

• solution complete, i.e., able to compute all solutions

unAnnProg :: AProg a -> Prog   

unAnnFuncDecl :: AFuncDecl a -> FuncDecl   

unAnnRule :: ARule a -> Rule   

unAnnExpr :: AExpr a -> Expr   

Remove annotation from an expression. Since there is no information about the types of free and let-bound variables available, the artificial type Prelude.UNKNONW is inserted for them.

unAnnPattern :: APattern a -> Pattern