Copyright	(c) Sebastian Fischer 2006 Björn Peemöller 2011
License	BSD-3-clause
Maintainer	bjp@informatik.uni-kiel.de
Stability	experimental
Portability	portable
Safe Haskell	Safe
Language	Haskell2010

Curry.FlatCurry.Goodies

Description

This library provides selector functions, test and update operations as well as some useful auxiliary functions for FlatCurry 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 FlatCurry 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.

Synopsis

type Update a b = (b -> b) -> a -> a
trProg :: (String -> [String] -> [TypeDecl] -> [FuncDecl] -> [OpDecl] -> a) -> Prog -> a
progName :: Prog -> String
progImports :: Prog -> [String]
progTypes :: Prog -> [TypeDecl]
progFuncs :: Prog -> [FuncDecl]
progOps :: Prog -> [OpDecl]
updProg :: (String -> String) -> ([String] -> [String]) -> ([TypeDecl] -> [TypeDecl]) -> ([FuncDecl] -> [FuncDecl]) -> ([OpDecl] -> [OpDecl]) -> Prog -> Prog
updProgName :: Update Prog String
updProgImports :: Update Prog [String]
updProgTypes :: Update Prog [TypeDecl]
updProgFuncs :: Update Prog [FuncDecl]
updProgOps :: Update Prog [OpDecl]
allVarsInProg :: Prog -> [VarIndex]
updProgExps :: Update Prog Expr
rnmAllVarsInProg :: Update Prog VarIndex
updQNamesInProg :: Update Prog QName
rnmProg :: String -> Prog -> Prog
trType :: (QName -> Visibility -> [TVarIndex] -> [ConsDecl] -> a) -> (QName -> Visibility -> [TVarIndex] -> TypeExpr -> a) -> TypeDecl -> a
typeName :: TypeDecl -> QName
typeVisibility :: TypeDecl -> Visibility
typeParams :: TypeDecl -> [TVarIndex]
typeConsDecls :: TypeDecl -> [ConsDecl]
typeSyn :: TypeDecl -> TypeExpr
isTypeSyn :: TypeDecl -> Bool
isDataTypeDecl :: TypeDecl -> Bool
isExternalType :: TypeDecl -> Bool
isPublicType :: TypeDecl -> Bool
updType :: (QName -> QName) -> (Visibility -> Visibility) -> ([TVarIndex] -> [TVarIndex]) -> ([ConsDecl] -> [ConsDecl]) -> (TypeExpr -> TypeExpr) -> TypeDecl -> TypeDecl
updTypeName :: Update TypeDecl QName
updTypeVisibility :: Update TypeDecl Visibility
updTypeParams :: Update TypeDecl [TVarIndex]
updTypeConsDecls :: Update TypeDecl [ConsDecl]
updTypeSynonym :: Update TypeDecl TypeExpr
updQNamesInType :: Update TypeDecl QName
trCons :: (QName -> Int -> Visibility -> [TypeExpr] -> a) -> ConsDecl -> a
consName :: ConsDecl -> QName
consArity :: ConsDecl -> Int
consVisibility :: ConsDecl -> Visibility
isPublicCons :: ConsDecl -> Bool
consArgs :: ConsDecl -> [TypeExpr]
updCons :: (QName -> QName) -> (Int -> Int) -> (Visibility -> Visibility) -> ([TypeExpr] -> [TypeExpr]) -> ConsDecl -> ConsDecl
updConsName :: Update ConsDecl QName
updConsArity :: Update ConsDecl Int
updConsVisibility :: Update ConsDecl Visibility
updConsArgs :: Update ConsDecl [TypeExpr]
updQNamesInConsDecl :: Update ConsDecl QName
tVarIndex :: TypeExpr -> TVarIndex
domain :: TypeExpr -> TypeExpr
range :: TypeExpr -> TypeExpr
tConsName :: TypeExpr -> QName
tConsArgs :: TypeExpr -> [TypeExpr]
trTypeExpr :: (TVarIndex -> a) -> (QName -> [a] -> a) -> (a -> a -> a) -> ([TVarIndex] -> a -> a) -> TypeExpr -> a
isTVar :: TypeExpr -> Bool
isTCons :: TypeExpr -> Bool
isFuncType :: TypeExpr -> Bool
isForallType :: TypeExpr -> Bool
updTVars :: (TVarIndex -> TypeExpr) -> TypeExpr -> TypeExpr
updTCons :: (QName -> [TypeExpr] -> TypeExpr) -> TypeExpr -> TypeExpr
updFuncTypes :: (TypeExpr -> TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr
updForallTypes :: ([TVarIndex] -> TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr
argTypes :: TypeExpr -> [TypeExpr]
typeArity :: TypeExpr -> Int
resultType :: TypeExpr -> TypeExpr
allVarsInTypeExpr :: TypeExpr -> [TVarIndex]
allTypeCons :: TypeExpr -> [QName]
rnmAllVarsInTypeExpr :: (TVarIndex -> TVarIndex) -> TypeExpr -> TypeExpr
updQNamesInTypeExpr :: (QName -> QName) -> TypeExpr -> TypeExpr
trOp :: (QName -> Fixity -> Integer -> a) -> OpDecl -> a
opName :: OpDecl -> QName
opFixity :: OpDecl -> Fixity
opPrecedence :: OpDecl -> Integer
updOp :: (QName -> QName) -> (Fixity -> Fixity) -> (Integer -> Integer) -> OpDecl -> OpDecl
updOpName :: Update OpDecl QName
updOpFixity :: Update OpDecl Fixity
updOpPrecedence :: Update OpDecl Integer
trFunc :: (QName -> Int -> Visibility -> TypeExpr -> Rule -> a) -> FuncDecl -> a
funcName :: FuncDecl -> QName
funcArity :: FuncDecl -> Int
funcVisibility :: FuncDecl -> Visibility
funcType :: FuncDecl -> TypeExpr
funcRule :: FuncDecl -> Rule
updFunc :: (QName -> QName) -> (Int -> Int) -> (Visibility -> Visibility) -> (TypeExpr -> TypeExpr) -> (Rule -> Rule) -> FuncDecl -> FuncDecl
updFuncName :: Update FuncDecl QName
updFuncArity :: Update FuncDecl Int
updFuncVisibility :: Update FuncDecl Visibility
updFuncType :: Update FuncDecl TypeExpr
updFuncRule :: Update FuncDecl Rule
isPublicFunc :: FuncDecl -> Bool
isExternal :: FuncDecl -> Bool
allVarsInFunc :: FuncDecl -> [VarIndex]
funcArgs :: FuncDecl -> [VarIndex]
funcBody :: FuncDecl -> Expr
funcRHS :: FuncDecl -> [Expr]
rnmAllVarsInFunc :: Update FuncDecl VarIndex
updQNamesInFunc :: Update FuncDecl QName
updFuncArgs :: Update FuncDecl [VarIndex]
updFuncBody :: Update FuncDecl Expr
trRule :: ([VarIndex] -> Expr -> a) -> (String -> a) -> Rule -> a
ruleArgs :: Rule -> [VarIndex]
ruleBody :: Rule -> Expr
ruleExtDecl :: Rule -> String
isRuleExternal :: Rule -> Bool
updRule :: ([VarIndex] -> [VarIndex]) -> (Expr -> Expr) -> (String -> String) -> Rule -> Rule
updRuleArgs :: Update Rule [VarIndex]
updRuleBody :: Update Rule Expr
updRuleExtDecl :: Update Rule String
allVarsInRule :: Rule -> [VarIndex]
rnmAllVarsInRule :: Update Rule VarIndex
updQNamesInRule :: Update Rule QName
trCombType :: a -> (Int -> a) -> a -> (Int -> a) -> CombType -> a
isCombTypeFuncCall :: CombType -> Bool
isCombTypeFuncPartCall :: CombType -> Bool
isCombTypeConsCall :: CombType -> Bool
isCombTypeConsPartCall :: CombType -> Bool
varNr :: Expr -> VarIndex
literal :: Expr -> Literal
combType :: Expr -> CombType
combName :: Expr -> QName
combArgs :: Expr -> [Expr]
missingCombArgs :: Expr -> Int
letBinds :: Expr -> [(VarIndex, Expr)]
letBody :: Expr -> Expr
freeVars :: Expr -> [VarIndex]
freeExpr :: Expr -> Expr
orExps :: Expr -> [Expr]
caseType :: Expr -> CaseType
caseExpr :: Expr -> Expr
caseBranches :: Expr -> [BranchExpr]
isVar :: Expr -> Bool
isLit :: Expr -> Bool
isComb :: Expr -> Bool
isLet :: Expr -> Bool
isFree :: Expr -> Bool
isOr :: Expr -> Bool
isCase :: Expr -> Bool
trExpr :: (VarIndex -> a) -> (Literal -> a) -> (CombType -> QName -> [a] -> a) -> ([(VarIndex, a)] -> a -> a) -> ([VarIndex] -> a -> a) -> (a -> a -> a) -> (CaseType -> a -> [b] -> a) -> (Pattern -> a -> b) -> (a -> TypeExpr -> a) -> Expr -> a
updVars :: (VarIndex -> Expr) -> Expr -> Expr
updLiterals :: (Literal -> Expr) -> Expr -> Expr
updCombs :: (CombType -> QName -> [Expr] -> Expr) -> Expr -> Expr
updLets :: ([(VarIndex, Expr)] -> Expr -> Expr) -> Expr -> Expr
updFrees :: ([VarIndex] -> Expr -> Expr) -> Expr -> Expr
updOrs :: (Expr -> Expr -> Expr) -> Expr -> Expr
updCases :: (CaseType -> Expr -> [BranchExpr] -> Expr) -> Expr -> Expr
updBranches :: (Pattern -> Expr -> BranchExpr) -> Expr -> Expr
updTypeds :: (Expr -> TypeExpr -> Expr) -> Expr -> Expr
isFuncCall :: Expr -> Bool
isFuncPartCall :: Expr -> Bool
isConsCall :: Expr -> Bool
isConsPartCall :: Expr -> Bool
isGround :: Expr -> Bool
allVars :: Expr -> [VarIndex]
rnmAllVars :: Update Expr VarIndex
updQNames :: Update Expr QName
trBranch :: (Pattern -> Expr -> a) -> BranchExpr -> a
branchPattern :: BranchExpr -> Pattern
branchExpr :: BranchExpr -> Expr
updBranch :: (Pattern -> Pattern) -> (Expr -> Expr) -> BranchExpr -> BranchExpr
updBranchPattern :: Update BranchExpr Pattern
updBranchExpr :: Update BranchExpr Expr
trPattern :: (QName -> [VarIndex] -> a) -> (Literal -> a) -> Pattern -> a
patCons :: Pattern -> QName
patArgs :: Pattern -> [VarIndex]
patLiteral :: Pattern -> Literal
isConsPattern :: Pattern -> Bool
updPattern :: (QName -> QName) -> ([VarIndex] -> [VarIndex]) -> (Literal -> Literal) -> Pattern -> Pattern
updPatCons :: (QName -> QName) -> Pattern -> Pattern
updPatArgs :: ([VarIndex] -> [VarIndex]) -> Pattern -> Pattern
updPatLiteral :: (Literal -> Literal) -> Pattern -> Pattern
patExpr :: Pattern -> Expr
isPublic :: Visibility -> Bool

Documentation

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

Update of a type's component

trProg :: (String -> [String] -> [TypeDecl] -> [FuncDecl] -> [OpDecl] -> a) -> Prog -> a Source #

transform program

progName :: Prog -> String Source #

get name from program

progImports :: Prog -> [String] Source #

get imports from program

progTypes :: Prog -> [TypeDecl] Source #

get type declarations from program

progFuncs :: Prog -> [FuncDecl] Source #

get functions from program

progOps :: Prog -> [OpDecl] Source #

get infix operators from program

updProg :: (String -> String) -> ([String] -> [String]) -> ([TypeDecl] -> [TypeDecl]) -> ([FuncDecl] -> [FuncDecl]) -> ([OpDecl] -> [OpDecl]) -> Prog -> Prog Source #

update program

updProgName :: Update Prog String Source #

update name of program

updProgImports :: Update Prog [String] Source #

update imports of program

updProgTypes :: Update Prog [TypeDecl] Source #

update type declarations of program

updProgFuncs :: Update Prog [FuncDecl] Source #

update functions of program

updProgOps :: Update Prog [OpDecl] Source #

update infix operators of program

allVarsInProg :: Prog -> [VarIndex] Source #

get all program variables (also from patterns)

updProgExps :: Update Prog Expr Source #

lift transformation on expressions to program

rnmAllVarsInProg :: Update Prog VarIndex Source #

rename programs variables

updQNamesInProg :: Update Prog QName Source #

update all qualified names in program

rnmProg :: String -> Prog -> Prog Source #

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

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

transform type declaration

typeName :: TypeDecl -> QName Source #

get name of type declaration

typeVisibility :: TypeDecl -> Visibility Source #

get visibility of type declaration

typeParams :: TypeDecl -> [TVarIndex] Source #

get type parameters of type declaration

typeConsDecls :: TypeDecl -> [ConsDecl] Source #

get constructor declarations from type declaration

typeSyn :: TypeDecl -> TypeExpr Source #

get synonym of type declaration

isTypeSyn :: TypeDecl -> Bool Source #

is type declaration a type synonym?

isDataTypeDecl :: TypeDecl -> Bool Source #

is type declaration declaring a regular type?

isExternalType :: TypeDecl -> Bool Source #

is type declaration declaring an external type?

isPublicType :: TypeDecl -> Bool Source #

Is the TypeDecl public?

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

update type declaration

updTypeName :: Update TypeDecl QName Source #

update name of type declaration

updTypeVisibility :: Update TypeDecl Visibility Source #

update visibility of type declaration

updTypeParams :: Update TypeDecl [TVarIndex] Source #

update type parameters of type declaration

updTypeConsDecls :: Update TypeDecl [ConsDecl] Source #

update constructor declarations of type declaration

updTypeSynonym :: Update TypeDecl TypeExpr Source #

update synonym of type declaration

updQNamesInType :: Update TypeDecl QName Source #

update all qualified names in type declaration

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

transform constructor declaration

consName :: ConsDecl -> QName Source #

get name of constructor declaration

consArity :: ConsDecl -> Int Source #

get arity of constructor declaration

consVisibility :: ConsDecl -> Visibility Source #

get visibility of constructor declaration

isPublicCons :: ConsDecl -> Bool Source #

Is the constructor declaration public?

consArgs :: ConsDecl -> [TypeExpr] Source #

get arguments of constructor declaration

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

update constructor declaration

updConsName :: Update ConsDecl QName Source #

update name of constructor declaration

updConsArity :: Update ConsDecl Int Source #

update arity of constructor declaration

updConsVisibility :: Update ConsDecl Visibility Source #

update visibility of constructor declaration

updConsArgs :: Update ConsDecl [TypeExpr] Source #

update arguments of constructor declaration

updQNamesInConsDecl :: Update ConsDecl QName Source #

update all qualified names in constructor declaration

tVarIndex :: TypeExpr -> TVarIndex Source #

get index from type variable

domain :: TypeExpr -> TypeExpr Source #

get domain from functional type

range :: TypeExpr -> TypeExpr Source #

get range from functional type

tConsName :: TypeExpr -> QName Source #

get name from constructed type

tConsArgs :: TypeExpr -> [TypeExpr] Source #

get arguments from constructed type

trTypeExpr :: (TVarIndex -> a) -> (QName -> [a] -> a) -> (a -> a -> a) -> ([TVarIndex] -> a -> a) -> TypeExpr -> a Source #

transform type expression

isTVar :: TypeExpr -> Bool Source #

is type expression a type variable?

isTCons :: TypeExpr -> Bool Source #

is type declaration a constructed type?

isFuncType :: TypeExpr -> Bool Source #

is type declaration a functional type?

isForallType :: TypeExpr -> Bool Source #

is type declaration a forall type?

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

update all type variables

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

update all type constructors

updFuncTypes :: (TypeExpr -> TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr Source #

update all functional types

updForallTypes :: ([TVarIndex] -> TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr Source #

update all forall types

argTypes :: TypeExpr -> [TypeExpr] Source #

get argument types from functional type

typeArity :: TypeExpr -> Int Source #

Compute the arity of a TypeExpr

resultType :: TypeExpr -> TypeExpr Source #

get result type from (nested) functional type

allVarsInTypeExpr :: TypeExpr -> [TVarIndex] Source #

get indexes of all type variables

allTypeCons :: TypeExpr -> [QName] Source #

yield the list of all contained type constructors

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

rename variables in type expression

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

update all qualified names in type expression

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

transform operator declaration

opName :: OpDecl -> QName Source #

get name from operator declaration

opFixity :: OpDecl -> Fixity Source #

get fixity of operator declaration

opPrecedence :: OpDecl -> Integer Source #

get precedence of operator declaration

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

update operator declaration

updOpName :: Update OpDecl QName Source #

update name of operator declaration

updOpFixity :: Update OpDecl Fixity Source #

update fixity of operator declaration

updOpPrecedence :: Update OpDecl Integer Source #

update precedence of operator declaration

trFunc :: (QName -> Int -> Visibility -> TypeExpr -> Rule -> a) -> FuncDecl -> a Source #

transform function

funcName :: FuncDecl -> QName Source #

get name of function

funcArity :: FuncDecl -> Int Source #

get arity of function

funcVisibility :: FuncDecl -> Visibility Source #

get visibility of function

funcType :: FuncDecl -> TypeExpr Source #

get type of function

funcRule :: FuncDecl -> Rule Source #

get rule of function

updFunc :: (QName -> QName) -> (Int -> Int) -> (Visibility -> Visibility) -> (TypeExpr -> TypeExpr) -> (Rule -> Rule) -> FuncDecl -> FuncDecl Source #

update function

updFuncName :: Update FuncDecl QName Source #

update name of function

updFuncArity :: Update FuncDecl Int Source #

update arity of function

updFuncVisibility :: Update FuncDecl Visibility Source #

update visibility of function

updFuncType :: Update FuncDecl TypeExpr Source #

update type of function

updFuncRule :: Update FuncDecl Rule Source #

update rule of function

isPublicFunc :: FuncDecl -> Bool Source #

is function public?

isExternal :: FuncDecl -> Bool Source #

is function externally defined?

allVarsInFunc :: FuncDecl -> [VarIndex] Source #

get variable names in a function declaration

funcArgs :: FuncDecl -> [VarIndex] Source #

get arguments of function, if not externally defined

funcBody :: FuncDecl -> Expr Source #

get body of function, if not externally defined

funcRHS :: FuncDecl -> [Expr] Source #

get the right-hand-sides of a FuncDecl

rnmAllVarsInFunc :: Update FuncDecl VarIndex Source #

rename all variables in function

updQNamesInFunc :: Update FuncDecl QName Source #

update all qualified names in function

updFuncArgs :: Update FuncDecl [VarIndex] Source #

update arguments of function, if not externally defined

updFuncBody :: Update FuncDecl Expr Source #

update body of function, if not externally defined

trRule :: ([VarIndex] -> Expr -> a) -> (String -> a) -> Rule -> a Source #

transform rule

ruleArgs :: Rule -> [VarIndex] Source #

get rules arguments if it's not external

ruleBody :: Rule -> Expr Source #

get rules body if it's not external

ruleExtDecl :: Rule -> String Source #

get rules external declaration

isRuleExternal :: Rule -> Bool Source #

is rule external?

updRule :: ([VarIndex] -> [VarIndex]) -> (Expr -> Expr) -> (String -> String) -> Rule -> Rule Source #

update rule

updRuleArgs :: Update Rule [VarIndex] Source #

update rules arguments

updRuleBody :: Update Rule Expr Source #

update rules body

updRuleExtDecl :: Update Rule String Source #

update rules external declaration

allVarsInRule :: Rule -> [VarIndex] Source #

get variable names in a functions rule

rnmAllVarsInRule :: Update Rule VarIndex Source #

rename all variables in rule

updQNamesInRule :: Update Rule QName Source #

update all qualified names in rule

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

transform combination type

isCombTypeFuncCall :: CombType -> Bool Source #

is type of combination FuncCall?

isCombTypeFuncPartCall :: CombType -> Bool Source #

is type of combination FuncPartCall?

isCombTypeConsCall :: CombType -> Bool Source #

is type of combination ConsCall?

isCombTypeConsPartCall :: CombType -> Bool Source #

is type of combination ConsPartCall?

varNr :: Expr -> VarIndex Source #

get internal number of variable

literal :: Expr -> Literal Source #

get literal if expression is literal expression

combType :: Expr -> CombType Source #

get combination type of a combined expression

combName :: Expr -> QName Source #

get name of a combined expression

combArgs :: Expr -> [Expr] Source #

get arguments of a combined expression

missingCombArgs :: Expr -> Int Source #

get number of missing arguments if expression is combined

letBinds :: Expr -> [(VarIndex, Expr)] Source #

get indices of varoables in let declaration

letBody :: Expr -> Expr Source #

get body of let declaration

freeVars :: Expr -> [VarIndex] Source #

get variable indices from declaration of free variables

freeExpr :: Expr -> Expr Source #

get expression from declaration of free variables

orExps :: Expr -> [Expr] Source #

get expressions from or-expression

caseType :: Expr -> CaseType Source #

get case-type of case expression

caseExpr :: Expr -> Expr Source #

get scrutinee of case expression

caseBranches :: Expr -> [BranchExpr] Source #

get branch expressions from case expression

isVar :: Expr -> Bool Source #

is expression a variable?

isLit :: Expr -> Bool Source #

is expression a literal expression?

isComb :: Expr -> Bool Source #

is expression combined?

isLet :: Expr -> Bool Source #

is expression a let expression?

isFree :: Expr -> Bool Source #

is expression a declaration of free variables?

isOr :: Expr -> Bool Source #

is expression an or-expression?

isCase :: Expr -> Bool Source #

is expression a case expression?

trExpr :: (VarIndex -> a) -> (Literal -> a) -> (CombType -> QName -> [a] -> a) -> ([(VarIndex, a)] -> a -> a) -> ([VarIndex] -> a -> a) -> (a -> a -> a) -> (CaseType -> a -> [b] -> a) -> (Pattern -> a -> b) -> (a -> TypeExpr -> a) -> Expr -> a Source #