This module provides some additional goodies for annotated FlatCurry.
Author: Jan Tikovsky
Version: October 2017
| extendAnn
                  ::  a -> (a,Maybe Int,Bool)Extend given annotation to default IDAnnannotation | 
| tyAnn
                  ::  (TypeExpr,Maybe Int,Bool) -> TypeExprSelect type annotation | 
| cidAnn
                  ::  (TypeExpr,Maybe Int,Bool) -> IntSelect case identifier annotation | 
| litAnn
                  ::  (TypeExpr,Maybe Int,Bool) -> BoolSelect literal annotation | 
| mkFunType
                  ::  [TypeExpr] -> TypeExpr -> TypeExprGenerate a functional FlatCurry type expression from a list of argument types and a result type | 
| hasName
                  ::  (String,String) -> AFuncDecl a -> Bool | 
| prel
                  ::  String -> (String,String)Qualification of Prelude functions | 
| qualPrel
                  ::  (String,a) -> ((String,String),a)Qualify first component of a tuple with "Prelude" | 
| isDict
                  ::  (String,String) -> BoolCheck whether the qualified name represents a dictionary | 
| failedExpr
                  ::  (TypeExpr,Maybe Int,Bool) -> AExpr (TypeExpr,Maybe Int,Bool)Annotated FlatCurry expression representing failed | 
| mkOr
                  ::  AExpr (TypeExpr,Maybe Int,Bool) -> AExpr (TypeExpr,Maybe Int,Bool) -> AExpr (TypeExpr,Maybe Int,Bool)smart constructor for a nondeterministic choice in FlatCurry | 
| boolType
                  ::  TypeExprRepresentation of some basic types in FlatCurry | 
| intType
                  ::  TypeExpr | 
| charType
                  ::  TypeExpr | 
| floatType
                  ::  TypeExpr | 
| listType
                  ::  TypeExpr -> TypeExpr | 
| unitType
                  ::  TypeExprExtended annotation for () | 
| boolAnn
                  ::  (TypeExpr,Maybe Int,Bool)Representation of extended annotations Extended annotation for Bool | 
| intAnn
                  ::  (TypeExpr,Maybe Int,Bool)Extended annotation for Int | 
| charAnn
                  ::  (TypeExpr,Maybe Int,Bool)Extended annotation for Char | 
| floatAnn
                  ::  (TypeExpr,Maybe Int,Bool)Extended annotation for Float | 
| listAnn
                  ::  TypeExpr -> (TypeExpr,Maybe Int,Bool)Extended annotation for the list type constructor | 
| tplAnn
                  ::  [TypeExpr] -> (TypeExpr,Maybe Int,Bool)Extended annotation for the tuple type constructor | 
| condAnn
                  ::  TypeExpr -> (TypeExpr,Maybe Int,Bool)Extended annotations of Prelude functions Extended annotation for type Bool -> a -> a | 
| ampAnn
                  ::  (TypeExpr,Maybe Int,Bool)Extended annotation for type Bool -> Bool -> Bool | 
| unifyAnn
                  ::  (TypeExpr,Maybe Int,Bool) -> (TypeExpr,Maybe Int,Bool)Extended annotation for type a -> a -> Bool | 
| trueExpr
                  ::  AExpr (TypeExpr,Maybe Int,Bool)FlatCurry expressions Annotated FlatCurry expression representing True | 
| falseExpr
                  ::  AExpr (TypeExpr,Maybe Int,Bool)Annotated FlatCurry expression representing False | 
| nil
                  ::  AExpr (TypeExpr,Maybe Int,Bool)Annotated FlatCurry expression representing [] | 
| cons
                  ::  TypeExpr -> [AExpr (TypeExpr,Maybe Int,Bool)] -> AExpr (TypeExpr,Maybe Int,Bool)Annotated FlatCurry expression representing : | 
| tpl
                  ::  [TypeExpr] -> [AExpr (TypeExpr,Maybe Int,Bool)] -> AExpr (TypeExpr,Maybe Int,Bool)FlatCurry expression representing (,) | 
| isBoolType
                  ::  TypeExpr -> BoolCheck if the given FlatCurry type is a boolean type | 
| isOtherwise
                  ::  AExpr a -> BoolCheck if the given FlatCurry expression is otherwise | 
| hasBoolType
                  ::  AExpr (TypeExpr,Maybe Int,Bool) -> Bool | 
| isConj
                  ::  AExpr a -> BoolCheck if the given FlatCurry expression is a boolean conjunction | 
| isDisj
                  ::  AExpr a -> BoolCheck if the given FlatCurry expression is a boolean disjunction | 
| truePat
                  ::  APattern (TypeExpr,Maybe Int,Bool)FlatCurry pattern FlatCurry Truepattern | 
| falsePat
                  ::  APattern (TypeExpr,Maybe Int,Bool)FlatCurry Falsepattern | 
| resArgTypes
                  ::  TypeExpr -> [TypeExpr]Get the result type followed by the argument types in given order | 
| patVars
                  ::  APattern a -> [Int]Select the pattern variables of a given pattern | 
| getVarIdx
                  ::  AExpr a -> [Int]Get the variable index of a FlatCurry expression | 
| getTyVars
                  ::  TypeExpr -> [Int]Get all type variables of a given FlatCurry type expression | 
| eqPattern
                  ::  APattern a -> APattern a -> BoolCheck if two pattern are equal | 
| findFunc
                  ::  (String,String) -> [AFuncDecl a] -> Maybe (AFuncDecl a)Find the function declaration for given qualified name | 
| findBranch
                  ::  APattern a -> [ABranchExpr a] -> Maybe (Int,[Int],AExpr a)Find the matching branch for a given pattern | 
| addPartCallArg
                  ::  a -> CombType -> ((String,String),a) -> [AExpr a] -> AExpr a -> AExpr aAdd an argument to a partial call | 
| isPartCall
                  ::  CombType -> BoolCheck if given combination type is a partial call | 
| combine
                  ::  (String,String) -> (String,String) -> AExpr (TypeExpr,Maybe Int,Bool) -> [AExpr (TypeExpr,Maybe Int,Bool)] -> [AExpr (TypeExpr,Maybe Int,Bool)] -> AExpr (TypeExpr,Maybe Int,Bool)Combine given expressions lists with =:=or=:<=and resulting
unifications with& | 
| getMainBody
                  ::  AProg a -> Maybe (AExpr a)Get the rhs expression of the main function of the given FlatCurry program | 
Extended annotations for concolic testing Extended FlatCurry annotation for concolic testing providing
              Type synonym: IDAnn a = (a,Maybe VarIndex,Bool)
            
Concolic testing annotation with type information
              Type synonym: TypeAnn = IDAnn TypeExpr
            
| 
                       
                      Extend given annotation to default  
 | 
| 
                       Select type annotation 
 | 
| 
                       Select literal annotation 
 | 
| 
                       Generate a functional FlatCurry type expression from a list of argument types and a result type | 
| 
                       Qualification of Prelude functions 
 | 
| 
                       Qualify first component of a tuple with "Prelude" 
 | 
| 
                       Check whether the qualified name represents a dictionary | 
| 
                       
                      Annotated FlatCurry expression representing  
 | 
| 
                       smart constructor for a nondeterministic choice in FlatCurry | 
| Representation of some basic types in FlatCurry 
 | 
| 
                       
 | 
| 
                      Extended annotation for  
 | 
| 
                       
                      Representation of extended annotations
Extended annotation for  
 | 
| 
                       
                      Extended annotation for  
 | 
| 
                       
                      Extended annotation for  
 | 
| 
                       Extended annotation for the tuple type constructor | 
| 
                       
                      Extended annotations of Prelude functions
Extended annotation for type  | 
| 
                       
                      Extended annotation for type  | 
| 
                       
                      FlatCurry expressions
Annotated FlatCurry expression representing  
 | 
| 
                       
                      Annotated FlatCurry expression representing  
 | 
| 
                       
                      Annotated FlatCurry expression representing  | 
| 
                       
                      FlatCurry expression representing  | 
| 
                       Check if the given FlatCurry type is a boolean type | 
| 
                       
                      Check if the given FlatCurry expression is  | 
| 
                       | 
| 
                       
                      FlatCurry pattern
FlatCurry  
 | 
| 
                       
                      FlatCurry  
 | 
| 
                       Get the result type followed by the argument types in given order | 
| 
                       Find the function declaration for given qualified name | 
| 
                       Find the matching branch for a given pattern | 
| 
                       Add an argument to a partial call | 
| 
                       Check if given combination type is a partial call | 
| 
                       
                      Combine given expressions lists with  | 
| 
                       Get the rhs expression of the main function of the given FlatCurry program |