Curry.FlatCurry.Typed.Goodies

This library provides selector functions, test and update operations as well as some useful auxiliary functions for TypedFlatCurry data terms. Most of the provided functions are based on general transformation functions that replace constructors with user-defined functions. For recursive datatypes the transformations are defined inductively over the term structure. This is quite usual for transformations on TypedFlatCurry terms, so the provided functions can be used to implement specific transformations without having to explicitly state the recursion. Essentially, the tedious part of such transformations - descend in fairly complex term structures - is abstracted away, which hopefully makes the code more clear and brief.

Documentation

trTProg :: (String -> [String] -> [TypeDecl] -> [TFuncDecl] -> [OpDecl] -> b) -> TProg -> b

transform program

tProgName :: TProg -> String

get name from program

tProgImports :: TProg -> [String]

get imports from program

tProgTypes :: TProg -> [TypeDecl]

get type declarations from program

tProgTFuncs :: TProg -> [TFuncDecl]

get functions from program

tProgOps :: TProg -> [OpDecl]

get infix operators from program

updTProg :: (String -> String) -> ([String] -> [String]) -> ([TypeDecl] -> [TypeDecl]) -> ([TFuncDecl] -> [TFuncDecl]) -> ([OpDecl] -> [OpDecl]) -> TProg -> TProg

update program

updTProgName :: Update TProg String

update name of program

updTProgImports :: Update TProg [String]

update imports of program

updTProgTypes :: Update TProg [TypeDecl]

update type declarations of program

updTProgTFuncs :: Update TProg [TFuncDecl]

update functions of program

updTProgOps :: Update TProg [OpDecl]

update infix operators of program

allVarsInTProg :: TProg -> [(VarIndex, TypeExpr)]

get all program variables (also from patterns)

updTProgTExps :: Update TProg TExpr

lift transformation on expressions to program

rnmAllVarsInTProg :: Update TProg VarIndex

rename programs variables

updQNamesInTProg :: Update TProg QName

update all qualified names in program

rnmTProg :: String -> TProg -> TProg

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

trTFunc :: (QName -> Int -> Visibility -> TypeExpr -> TRule -> b) -> TFuncDecl -> b

transform function

tFuncName :: TFuncDecl -> QName

get name of function

tFuncArity :: TFuncDecl -> Int

get arity of function

tFuncVisibility :: TFuncDecl -> Visibility

get visibility of function

tFuncType :: TFuncDecl -> TypeExpr

get type of function

tFuncTRule :: TFuncDecl -> TRule

get rule of function

updTFunc :: (QName -> QName) -> (Int -> Int) -> (Visibility -> Visibility) -> (TypeExpr -> TypeExpr) -> (TRule -> TRule) -> TFuncDecl -> TFuncDecl

update function

updTFuncName :: Update TFuncDecl QName

update name of function

updTFuncArity :: Update TFuncDecl Int

update arity of function

updTFuncVisibility :: Update TFuncDecl Visibility

update visibility of function

updFuncType :: Update TFuncDecl TypeExpr

update type of function

updTFuncTRule :: Update TFuncDecl TRule

update rule of function

isPublicTFunc :: TFuncDecl -> Bool

is function public?

isExternal :: TFuncDecl -> Bool

is function externally defined?

allVarsInTFunc :: TFuncDecl -> [(VarIndex, TypeExpr)]

get variable names in a function declaration

tFuncArgs :: TFuncDecl -> [(VarIndex, TypeExpr)]

get arguments of function, if not externally defined

tFuncBody :: TFuncDecl -> TExpr

get body of function, if not externally defined

tFuncRHS :: TFuncDecl -> [TExpr]

get the right-hand-sides of a FuncDecl

rnmAllVarsInTFunc :: Update TFuncDecl VarIndex

rename all variables in function

updQNamesInTFunc :: Update TFuncDecl QName

update all qualified names in function

updTFuncArgs :: Update TFuncDecl [(VarIndex, TypeExpr)]

update arguments of function, if not externally defined

updTFuncBody :: Update TFuncDecl TExpr

update body of function, if not externally defined

trTRule :: ([(VarIndex, TypeExpr)] -> TExpr -> b) -> (TypeExpr -> String -> b) -> TRule -> b

transform rule

tRuleArgs :: TRule -> [(VarIndex, TypeExpr)]

get rules arguments if it's not external

tRuleBody :: TRule -> TExpr

get rules body if it's not external

tRuleExtDecl :: TRule -> String

get rules external declaration

isTRuleExternal :: TRule -> Bool

is rule external?

updTRule :: (TypeExpr -> TypeExpr) -> ([(VarIndex, TypeExpr)] -> [(VarIndex, TypeExpr)]) -> (TExpr -> TExpr) -> (String -> String) -> TRule -> TRule

update rule

updTRuleType :: Update TRule TypeExpr

update rules TypeExpr

updTRuleArgs :: Update TRule [(VarIndex, TypeExpr)]

update rules arguments

updTRuleBody :: Update TRule TExpr

update rules body

updTRuleExtDecl :: Update TRule String

update rules external declaration

allVarsInTRule :: TRule -> [(VarIndex, TypeExpr)]

get variable names in a functions rule

rnmAllVarsInTRule :: Update TRule VarIndex

rename all variables in rule

updQNamesInTRule :: Update TRule QName

update all qualified names in rule

varNr :: TExpr -> VarIndex

get internal number of variable

literal :: TExpr -> Literal

get literal if expression is literal expression

combType :: TExpr -> CombType

get combination type of a combined expression

combName :: TExpr -> QName

get name of a combined expression

combArgs :: TExpr -> [TExpr]

get arguments of a combined expression

missingCombArgs :: TExpr -> Int

get number of missing arguments if expression is combined

letBinds :: TExpr -> [((VarIndex, TypeExpr), TExpr)]

get indices of variables in let declaration

letBody :: TExpr -> TExpr

get body of let declaration

freeVars :: TExpr -> [(VarIndex, TypeExpr)]

get variable indices from declaration of free variables

freeExpr :: TExpr -> TExpr

get expression from declaration of free variables

orExps :: TExpr -> [TExpr]

get expressions from or-expression

caseType :: TExpr -> CaseType

get case-type of case expression

caseExpr :: TExpr -> TExpr

get scrutinee of case expression

caseBranches :: TExpr -> [TBranchExpr]

get branch expressions from case expression

isTVarE :: TExpr -> Bool

is expression a variable?

isTLit :: TExpr -> Bool

is expression a literal expression?

isTComb :: TExpr -> Bool

is expression combined?

isTLet :: TExpr -> Bool

is expression a let expression?

isTFree :: TExpr -> Bool

is expression a declaration of free variables?

isTOr :: TExpr -> Bool

is expression an or-expression?

isTCase :: TExpr -> Bool

is expression a case expression?

trTExpr :: (TypeExpr -> VarIndex -> b) -> (TypeExpr -> Literal -> b) -> (TypeExpr -> CombType -> QName -> [b] -> b) -> ([((VarIndex, TypeExpr), b)] -> b -> b) -> ([(VarIndex, TypeExpr)] -> b -> b) -> (b -> b -> b) -> (CaseType -> b -> [c] -> b) -> (TPattern -> b -> c) -> (b -> TypeExpr -> b) -> TExpr -> b

transform expression

updVars :: (TypeExpr -> VarIndex -> TExpr) -> TExpr -> TExpr

update all variables in given expression

updLiterals :: (TypeExpr -> Literal -> TExpr) -> TExpr -> TExpr

update all literals in given expression

updCombs :: (TypeExpr -> CombType -> QName -> [TExpr] -> TExpr) -> TExpr -> TExpr

update all combined expressions in given expression

updLets :: ([((VarIndex, TypeExpr), TExpr)] -> TExpr -> TExpr) -> TExpr -> TExpr

update all let expressions in given expression

updFrees :: ([(VarIndex, TypeExpr)] -> TExpr -> TExpr) -> TExpr -> TExpr

update all free declarations in given expression

updOrs :: (TExpr -> TExpr -> TExpr) -> TExpr -> TExpr

update all or expressions in given expression

updCases :: (CaseType -> TExpr -> [TBranchExpr] -> TExpr) -> TExpr -> TExpr

update all case expressions in given expression

updBranches :: (TPattern -> TExpr -> TBranchExpr) -> TExpr -> TExpr

update all case branches in given expression

updTypeds :: (TExpr -> TypeExpr -> TExpr) -> TExpr -> TExpr

update all typed expressions in given expression

isFuncCall :: TExpr -> Bool

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

isFuncPartCall :: TExpr -> Bool

is expression a partial function call?

isConsCall :: TExpr -> Bool

is expression a call of a constructor?

isConsPartCall :: TExpr -> Bool

is expression a partial constructor call?

isGround :: TExpr -> Bool

is expression fully evaluated?

allVars :: TExpr -> [(VarIndex, TypeExpr)]

get all variables (also pattern variables) in expression

rnmAllVars :: Update TExpr VarIndex

rename all variables (also in patterns) in expression

updQNames :: Update TExpr QName

update all qualified names in expression

trTBranch :: (TPattern -> TExpr -> b) -> TBranchExpr -> b

transform branch expression

tBranchTPattern :: TBranchExpr -> TPattern

get pattern from branch expression

tBranchTExpr :: TBranchExpr -> TExpr

get expression from branch expression

updTBranch :: (TPattern -> TPattern) -> (TExpr -> TExpr) -> TBranchExpr -> TBranchExpr

update branch expression

updTBranchTPattern :: Update TBranchExpr TPattern

update pattern of branch expression

updTBranchTExpr :: Update TBranchExpr TExpr

update expression of branch expression

trTPattern :: (TypeExpr -> QName -> [(VarIndex, TypeExpr)] -> b) -> (TypeExpr -> Literal -> b) -> TPattern -> b

transform pattern

tPatCons :: TPattern -> QName

get name from constructor pattern

tPatArgs :: TPattern -> [(VarIndex, TypeExpr)]

get arguments from constructor pattern

tPatLiteral :: TPattern -> Literal

get literal from literal pattern

isConsPattern :: TPattern -> Bool

is pattern a constructor pattern?

updTPattern :: (TypeExpr -> TypeExpr) -> (QName -> QName) -> ([(VarIndex, TypeExpr)] -> [(VarIndex, TypeExpr)]) -> (Literal -> Literal) -> TPattern -> TPattern

update pattern

updTPatType :: (TypeExpr -> TypeExpr) -> TPattern -> TPattern

update TypeExpr of pattern

updTPatCons :: (QName -> QName) -> TPattern -> TPattern

update constructors name of pattern

updTPatArgs :: ([(VarIndex, TypeExpr)] -> [(VarIndex, TypeExpr)]) -> TPattern -> TPattern

update arguments of constructor pattern

updTPatLiteral :: (Literal -> Literal) -> TPattern -> TPattern

update literal of pattern

tPatExpr :: TPattern -> TExpr

build expression from pattern

type Update a b = (b -> b) -> a -> a

Update of a type's component

trType :: (QName -> Visibility -> [TVarIndex] -> [ConsDecl] -> a) -> (QName -> Visibility -> [TVarIndex] -> TypeExpr -> a) -> TypeDecl -> a

transform type declaration

typeName :: TypeDecl -> QName

get name of type declaration

typeVisibility :: TypeDecl -> Visibility

get visibility of type declaration

typeParams :: TypeDecl -> [TVarIndex]

get type parameters of type declaration

typeConsDecls :: TypeDecl -> [ConsDecl]

get constructor declarations from type declaration

typeSyn :: TypeDecl -> TypeExpr

get synonym of type declaration

isTypeSyn :: TypeDecl -> Bool

is type declaration a type synonym?

isDataTypeDecl :: TypeDecl -> Bool

is type declaration declaring a regular type?

isExternalType :: TypeDecl -> Bool

is type declaration declaring an external type?

isPublicType :: TypeDecl -> Bool

Is the TypeDecl public?

updType :: (QName -> QName) -> (Visibility -> Visibility) -> ([TVarIndex] -> [TVarIndex]) -> ([ConsDecl] -> [ConsDecl]) -> (TypeExpr -> TypeExpr) -> TypeDecl -> TypeDecl

update type declaration

updTypeName :: Update TypeDecl QName

update name of type declaration

updTypeVisibility :: Update TypeDecl Visibility

update visibility of type declaration

updTypeParams :: Update TypeDecl [TVarIndex]

update type parameters of type declaration

updTypeConsDecls :: Update TypeDecl [ConsDecl]

update constructor declarations of type declaration

updTypeSynonym :: Update TypeDecl TypeExpr

update synonym of type declaration

updQNamesInType :: Update TypeDecl QName

update all qualified names in type declaration

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

transform constructor declaration

consName :: ConsDecl -> QName

get name of constructor declaration

consArity :: ConsDecl -> Int

get arity of constructor declaration

consVisibility :: ConsDecl -> Visibility

get visibility of constructor declaration

isPublicCons :: ConsDecl -> Bool

Is the constructor declaration public?

consArgs :: ConsDecl -> [TypeExpr]

get arguments of constructor declaration

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

update constructor declaration

updConsName :: Update ConsDecl QName

update name of constructor declaration

updConsArity :: Update ConsDecl Int

update arity of constructor declaration

updConsVisibility :: Update ConsDecl Visibility

update visibility of constructor declaration

updConsArgs :: Update ConsDecl [TypeExpr]

update arguments of constructor declaration

updQNamesInConsDecl :: Update ConsDecl QName

update all qualified names in constructor declaration

tVarIndex :: TypeExpr -> TVarIndex

get index from type variable

domain :: TypeExpr -> TypeExpr

get domain from functional type

range :: TypeExpr -> TypeExpr

get range from functional type

tConsName :: TypeExpr -> QName

get name from constructed type

tConsArgs :: TypeExpr -> [TypeExpr]

get arguments from constructed type

trTypeExpr :: (TVarIndex -> a) -> (QName -> [a] -> a) -> (a -> a -> a) -> ([TVarIndex] -> 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?

updTVars :: (TVarIndex -> TypeExpr) -> TypeExpr -> TypeExpr

update all type variables

updTCons :: (QName -> [TypeExpr] -> TypeExpr) -> TypeExpr -> TypeExpr

update all type constructors

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

update all functional types

argTypes :: TypeExpr -> [TypeExpr]

get argument types from functional type

typeArity :: TypeExpr -> Int

Compute the arity of a TypeExpr

resultType :: TypeExpr -> TypeExpr

get result type from (nested) functional type

allVarsInTypeExpr :: TypeExpr -> [TVarIndex]

get indexes of all type variables

allTypeCons :: TypeExpr -> [QName]

yield the list of all contained type constructors

rnmAllVarsInTypeExpr :: (TVarIndex -> TVarIndex) -> TypeExpr -> TypeExpr

rename variables in type expression

updQNamesInTypeExpr :: (QName -> QName) -> TypeExpr -> TypeExpr

update all qualified names in type expression

trOp :: (QName -> Fixity -> Integer -> a) -> OpDecl -> a

transform operator declaration

opName :: OpDecl -> QName

get name from operator declaration

opFixity :: OpDecl -> Fixity

get fixity of operator declaration

opPrecedence :: OpDecl -> Integer

get precedence of operator declaration

updOp :: (QName -> QName) -> (Fixity -> Fixity) -> (Integer -> Integer) -> OpDecl -> OpDecl

update operator declaration

updOpName :: Update OpDecl QName

update name of operator declaration

updOpFixity :: Update OpDecl Fixity

update fixity of operator declaration

updOpPrecedence :: Update OpDecl Integer

update precedence of operator declaration

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?

isPublic :: Visibility -> Bool

Is this a public Visibility?