Module "Flat.curry"

Library to support meta-programming in Curry.
This library contains a definition for representing FlatCurry programs in Curry (type "Prog") and an I/O action to read Curry programs and transform them into this representation (function "readFlatCurry").

Author: Michael Hanus

Version: March 2001

Exported names:

Functions:
prim_readFlatCurryFile | readFlatCurry | readFlatCurryFile | readFlatCurryWithParseOptions | splitFlatModName

Summary of exported functions:

readFlatCurry :: String -> IO Prog

I/O action which parses a Curry program and returns the corresponding FlatCurry program.

readFlatCurryWithParseOptions :: String -> FrontendParams -> IO Prog

I/O action which reads a FlatCurry program from a file with respect to some parser options.

readFlatCurryFile :: String -> IO Prog

I/O action which reads a FlatCurry program from a file in ".fcy" format.

prim_readFlatCurryFile :: String -> IO Prog

splitFlatModName :: String -> (String,String)

Splits an internal name into a pair of module name and name in local module.

Imported modules:

Char
Directory
Distribution
Prelude

Exported datatypes:

TVarIndex

The data type for representing type variables. They are represented by (TVar i) where i is a type variable index.

Type synonym: TVarIndex = Int

VarIndex

Data types for representing object variables. Object variables occurring in expressions are represented by (Var i) where i is a variable index.

Type synonym: VarIndex = Int

Prog

Data type for representing a Curry module in the intermediate form. A value of this data type has the form (Prog modname imports typedecls functions opdecls translation_table) where modname: name of this module, imports: list of modules names that are imported, typedecls, opdecls, functions, translation_table: see below

Constructors:

Prog:: String -> [String] -> [TypeDecl] -> [FuncDecl] -> [OpDecl] -> [Translation] -> Prog

TypeDecl

Data type for representing definitions of algebraic data types.

A data type definition of the form


data t x1...xn = ...| c t1....tkc |...


is represented by the FlatCurry term


(Type t [i1,...,in] [...(Cons c kc [t1,...,tkc])...])


where each ij is the index of the type variable xj


Note: the type variable indices are unique inside each type declaration
      and are usually numbered from 0


Thus, a data type declaration consists of the name of the data type,
a list of type parameters and a list of constructor declarations.

Constructors:

Type:: String -> [Int] -> [ConsDecl] -> TypeDecl

ConsDecl

A constructor declaration consists of the name and arity of the constructor and a list of the argument types of the constructor.

Constructors:

Cons:: String -> Int -> [TypeExpr] -> ConsDecl

TypeExpr

Data type for type expressions. A type expression is either a type variable, a function type, or a type constructor application.
Note: the names of the predefined type constructors are "Int", "Float", "Bool", "Char", "IO", "Success", "()" (unit type), "(,...,)" (tuple types), "[]" (list type)

Constructors:

TVar:: Int -> TypeExpr
FuncType:: TypeExpr -> TypeExpr -> TypeExpr
TCons:: String -> [TypeExpr] -> TypeExpr

OpDecl

Data type for operator declarations. An operator declaration "fix p n" in Curry corresponds to the FlatCurry term (Op n fix p).

Constructors:

Op:: String -> Fixity -> Int -> OpDecl

Fixity

Data types for the different choices for the fixity of an operator.

Constructors:

InfixOp:: Fixity
InfixlOp:: Fixity
InfixrOp:: Fixity

FuncDecl

Data type for representing function declarations.

A function declaration in FlatCurry is a term of the form


 (Func name arity type (Rule [i_1,...,i_arity] e))


and represents the function "name" with definition


  name :: type
  name x_1...x_arity = e


where each i_j is the index of the variable x_j


Note: the variable indices are unique inside each function declaration
      and are usually numbered from 0


External functions are represented as (Func name arity type (External s))
where s is the external name associated to this function.


Thus, a function declaration consists of the name, arity, type, and rule.

Constructors:

Func:: String -> Int -> TypeExpr -> Rule -> FuncDecl

Rule

A rule is either a list of formal parameters together with an expression or an "External" tag.

Constructors:

Rule:: [Int] -> Expr -> Rule
External:: String -> Rule

CaseType

Data type for classifying case expressions. Case expressions can be either flexible or rigid in Curry.

Constructors:

Rigid:: CaseType
Flex:: CaseType

CombType

Data type for classifying combinations (i.e., a function/constructor applied to some arguments).

Constructors:

FuncCall:: CombType
ConsCall:: CombType
PartCall:: CombType

Expr

Data types for representing expressions.

Constructors:

Var:: Int -> Expr
Lit:: Literal -> Expr
Comb:: CombType -> String -> [Expr] -> Expr
Apply:: Expr -> Expr -> Expr
Constr:: [Int] -> Expr -> Expr
Or:: Expr -> Expr -> Expr
Case:: CaseType -> Expr -> [BranchExpr] -> Expr
Let:: [(Int,Expr)] -> Expr -> Expr
Choice:: Expr -> Expr
GuardedExpr:: [Int] -> Expr -> Expr -> Expr

BranchExpr

Data types for representing branches in a case expressions.

Branches "(c x1...xn) -> e" in case expressions are represented as


  (Branch (Pattern c [i1,...,in]) e)


where each ij is the index of the pattern variable xj, or as


  (Branch (LPattern (Intc i)) e)


for integers as branch patterns (similarly for other literals
like float or character constants).

Constructors:

Branch:: Pattern -> Expr -> BranchExpr

Pattern

Data type for representing patterns in case expressions.

Constructors:

Pattern:: String -> [Int] -> Pattern
LPattern:: Literal -> Pattern

Literal

Data type for representing literals occurring in an expression or case branch. It is either an integer, a float, or a character constant.

Constructors:

Intc:: Int -> Literal
Floatc:: Float -> Literal
Charc:: Char -> Literal

Translation

Data type for translating external into internal names. Each module contains a translation table to translate the external names (visible to the user) into internal names (used in the implementation). Usually, the internal names are prefixed by the name of the module (except for the prelude). Thus, the translation table is a list of elements of the form (Trans name internal_name).

Constructors:

Trans:: String -> String -> Translation

Exported functions:

readFlatCurry :: String -> IO Prog

I/O action which parses a Curry program and returns the corresponding FlatCurry program. Thus, the argument is the file name without suffix ".curry" (or ".lcurry") and the result is a FlatCurry term representing this program.

readFlatCurryWithParseOptions :: String -> FrontendParams -> IO Prog

I/O action which reads a FlatCurry program from a file with respect to some parser options. This I/O action is used by the standard action readFlatCurry. It is currently predefined only in Curry2Prolog.

Example call: (readFlatCurryWithParseOptions progfile options)

Parameters:
: progfile - the program file name (without suffix ".curry")
: options - parameters passed to the front end

readFlatCurryFile :: String -> IO Prog

I/O action which reads a FlatCurry program from a file in ".fcy" format. In contrast to readFlatCurry, this action does not parse a source program. Thus, the argument must be the name of an existing file (with suffix ".fcy") containing a FlatCurry program in ".fcy" format and the result is a FlatCurry term representing this program. It is currently predefined only in Curry2Prolog.

prim_readFlatCurryFile :: String -> IO Prog

Further infos:

externally defined

splitFlatModName :: String -> (String,String)

Splits an internal name into a pair of module name and name in local module.

Example call: (splitFlatModName intname)

Parameters:
: intname - the internal name of a (type) constructor or function occurring in the FlatCurry program

Returns:: (mod,lname) where mod is the module name and lname the local name of the parameter in this module

Further infos:

incompletely defined

Generated by CurryDoc (Version 0.4.1 of June 7, 2007) at Aug 28 15:38:16 2008