Qualified names.

In FlatCurry all names are qualified to avoid name clashes. The first component is the module name and the second component the unqualified name as it occurs in the source program.

Representation of variables.

Type variables are represented by (TVar i) where i is a type variable index.

Visibility of various entities.

A FlatCurry module.

A value of this data type has the form

Prog modname imports typedecls functions opdecls

where

modname

Name of this module

imports

List of modules names that are imported

typedecls

Type declarations

funcdecls

Function declarations

opdecls

Operator declarations

Declaration of algebraic data type or type synonym.

A data type declaration 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.

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)

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

Operator declarations.

An operator declaration fix p n in Curry corresponds to the FlatCurry term (Op n fix p).

Note: the constructor definition of Op differs from the original PAKCS definition using Haskell type Integer instead of Int for representing the precedence.

Fixity of an operator.

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.

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

Data type for representing expressions.

Remarks:

1. if-then-else expressions are represented as function calls:

(if e1 then e2 else e3)

is represented as

(Comb FuncCall (Prelude,"if_then_else") [e1,e2,e3])

1. Higher order applications are represented as calls to the (external) function apply. For instance, the rule

app f x = f x

is represented as

(Rule  [0,1] (Comb FuncCall (Prelude,"apply") [Var 0, Var 1]))

1. A conditional rule is represented as a call to an external function cond where the first argument is the condition (a constraint).

For instance, the rule

equal2 x | x=:=2 = success

is represented as

  (Rule [0]
      (Comb FuncCall (Prelude,"cond")
            [Comb FuncCall (Prelude,"=:=") [Var 0, Lit (Intc 2)],
            Comb FuncCall (Prelude,"success") []]))
  

1. Functions with evaluation annotation choice are represented by a rule whose right-hand side is enclosed in a call to the external function Prelude.commit. Furthermore, all rules of the original definition must be represented by conditional expressions (i.e., (cond [c,e])) after pattern matching.

Example:

  m eval choice
  m [] y = y
  m x [] = x
  

is translated into (note that the conditional branches can be also wrapped with Free declarations in general):

  Rule [0,1]
    (Comb FuncCall (Prelude,"commit")
      [Or (Case Rigid (Var 0)
            [(Pattern (Prelude,"[]") []
                (Comb FuncCall (Prelude,"cond")
                      [Comb FuncCall (Prelude,"success") [],
                        Var 1]))] )
          (Case Rigid (Var 1)
            [(Pattern (Prelude,"[]") []
                (Comb FuncCall (Prelude,"cond")
                      [Comb FuncCall (Prelude,"success") [],
                        Var 0]))] )])
  

Operational meaning of (Prelude.commit e): evaluate e with local search spaces and commit to the first (Comb FuncCall (Prelude,"cond") [c,ge]) in e whose constraint c is satisfied

Data type for representing literals.

A literal is either an integer, a float, or a character constant.

Note: The constructor definition of Intc differs from the original PAKCS definition. It uses Haskell type Integer instead of Int to provide an unlimited range of integer numbers. Furthermore, float values are represented with Haskell type Double instead of Float.

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

Classification of case expressions, either flexible or rigid.

Branches in a case expression.

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

(Branch (Pattern (m,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).

Patterns in case expressions.