This library provides some useful operations to write programs that generate AbstractCurry programs in a more compact and readable way.
Version: February 2016
| (~>)
                  :: CTypeExpr -> CTypeExpr -> CTypeExprA function type. | 
| baseType
                  :: (String,String) -> CTypeExprA base type. | 
| listType
                  :: CTypeExpr -> CTypeExprConstructs a list type from an element type. | 
| tupleType
                  :: [CTypeExpr] -> CTypeExprConstructs a tuple type from list of component types. | 
| ioType
                  :: CTypeExpr -> CTypeExprConstructs an IO type from a type. | 
| maybeType
                  :: CTypeExpr -> CTypeExprConstructs a Maybe type from element type. | 
| stringType
                  :: CTypeExprThe type expression of the String type. | 
| intType
                  :: CTypeExprThe type expression of the Int type. | 
| floatType
                  :: CTypeExprThe type expression of the Float type. | 
| boolType
                  :: CTypeExprThe type expression of the Bool type. | 
| charType
                  :: CTypeExprThe type expression of the Char type. | 
| unitType
                  :: CTypeExprThe type expression of the unit type. | 
| dateType
                  :: CTypeExprThe type expression of the Time.CalendarTime type. | 
| cfunc
                  :: (String,String) -> Int -> CVisibility -> CTypeExpr -> [CRule] -> CFuncDeclConstructs a function declaration from a given qualified function name, arity, visibility, type expression and list of defining rules. | 
| cmtfunc
                  :: String -> (String,String) -> Int -> CVisibility -> CTypeExpr -> [CRule] -> CFuncDeclConstructs a function declaration from a given comment, qualified function name, arity, visibility, type expression and list of defining rules. | 
| simpleRule
                  :: [CPattern] -> CExpr -> CRuleConstructs a simple rule with a pattern list and an unconditional right-hand side. | 
| simpleRuleWithLocals
                  :: [CPattern] -> CExpr -> [CLocalDecl] -> CRuleConstructs a simple rule with a pattern list, an unconditional right-hand side, and local declarations. | 
| guardedRule
                  :: [CPattern] -> [(CExpr,CExpr)] -> [CLocalDecl] -> CRuleConstructs a rule with a possibly guarded right-hand side and local declarations. | 
| noGuard
                  :: CExpr -> (CExpr,CExpr)Constructs a guarded expression with the trivial guard. | 
| applyF
                  :: (String,String) -> [CExpr] -> CExprAn application of a qualified function name to a list of arguments. | 
| applyE
                  :: CExpr -> [CExpr] -> CExprAn application of an expression to a list of arguments. | 
| constF
                  :: (String,String) -> CExprA constant, i.e., an application without arguments. | 
| applyV
                  :: (Int,String) -> [CExpr] -> CExprAn application of a variable to a list of arguments. | 
| applyJust
                  :: CExpr -> CExpr | 
| applyMaybe
                  :: CExpr -> CExpr -> CExpr -> CExpr | 
| tupleExpr
                  :: [CExpr] -> CExprConstructs a tuple expression from list of component expressions. | 
| letExpr
                  :: [CLocalDecl] -> CExpr -> CExpr | 
| cBranch
                  :: CPattern -> CExpr -> (CPattern,CRhs)Constructs from a pattern and an expression a branch for a case expression. | 
| tuplePattern
                  :: [CPattern] -> CPatternConstructs a tuple pattern from list of component patterns. | 
| pVars
                  :: Int -> [CPattern]Constructs, for given n, a list of n PVars starting from 0. | 
| pInt
                  :: Int -> CPatternConverts an integer into an AbstractCurry expression. | 
| pFloat
                  :: Float -> CPatternConverts a float into an AbstractCurry expression. | 
| pChar
                  :: Char -> CPatternConverts a character into a pattern. | 
| pNil
                  :: CPatternConstructs an empty list pattern. | 
| listPattern
                  :: [CPattern] -> CPatternConstructs a list pattern from list of component patterns. | 
| stringPattern
                  :: String -> CPatternConverts a string into a pattern representing this string. | 
| list2ac
                  :: [CExpr] -> CExprConverts a list of AbstractCurry expressions into an AbstractCurry representation of this list. | 
| cInt
                  :: Int -> CExprConverts an integer into an AbstractCurry expression. | 
| cFloat
                  :: Float -> CExprConverts a float into an AbstractCurry expression. | 
| cChar
                  :: Char -> CExprConverts a character into an AbstractCurry expression. | 
| string2ac
                  :: String -> CExprConverts a string into an AbstractCurry represention of this string. | 
| toVar
                  :: Int -> CExprConverts an index i into a variable named xi. | 
| cvar
                  :: String -> CExprConverts a string into a variable with index 1. | 
| cpvar
                  :: String -> CPatternConverts a string into a pattern variable with index 1. | 
| ctvar
                  :: String -> CTypeExprConverts a string into a type variable with index 1. | 
| 
                       A function type. 
 | 
| 
                       A base type. 
 | 
| 
                       Constructs a list type from an element type. 
 | 
| 
                       Constructs an IO type from a type. 
 | 
| 
                       Constructs a Maybe type from element type. 
 | 
| The type expression of the String type. 
 | 
| The type expression of the Int type. 
 | 
| The type expression of the Float type. 
 | 
| The type expression of the Bool type. 
 | 
| The type expression of the Char type. 
 | 
| The type expression of the unit type. 
 | 
| The type expression of the Time.CalendarTime type. 
 | 
| 
                       Constructs a function declaration from a given qualified function name, arity, visibility, type expression and list of defining rules. 
 | 
| 
                       Constructs a function declaration from a given comment, qualified function name, arity, visibility, type expression and list of defining rules. 
 | 
| 
                       Constructs a simple rule with a pattern list and an unconditional right-hand side. 
 | 
| 
                       Constructs a simple rule with a pattern list, an unconditional right-hand side, and local declarations. 
 | 
| 
                       
                      Constructs a rule with a possibly guarded right-hand side
and local declarations.
A simple right-hand side is constructed if there is only one
 | 
| 
                       Constructs a guarded expression with the trivial guard. 
 | 
| 
                       An application of a qualified function name to a list of arguments. | 
| 
                       | 
| 
                       | 
| 
                       Constructs from a pattern and an expression a branch for a case expression. 
 | 
| 
                       Constructs a tuple pattern from list of component patterns. | 
| Converts an integer into an AbstractCurry expression. 
 | 
| Converts a float into an AbstractCurry expression. 
 | 
| Converts a character into a pattern. 
 | 
| Constructs an empty list pattern. 
 | 
| 
                       Constructs a list pattern from list of component patterns. 
 | 
| 
                       Converts a string into a pattern representing this string. | 
| Converts a list of AbstractCurry expressions into an AbstractCurry representation of this list. | 
| Converts an integer into an AbstractCurry expression. 
 | 
| Converts a float into an AbstractCurry expression. 
 | 
| Converts a character into an AbstractCurry expression. 
 | 
| Converts a string into an AbstractCurry represention of this string. 
 | 
| Converts a string into a variable with index 1. 
 | 
| Converts a string into a pattern variable with index 1. 
 |