Institute of Information and Computing Sciences

Utrecht University
P.O. Box 80.089
3508 TB Utrecht
The Netherlands
http://www.generic-haskell.org

A
The Generic H SKELL User’s Guide
A
The Generic H SKELL Team

Dæv Clarke
Ralf Hinze
Johan Jeuring
Andres Löh
Jan de Wit

[email protected]

November 1, 2001

Version 0.99 (Amber)

Contents

A
1 What is Generic H SKELL? 4
1.1 Generic Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
A
1.2 Generic H SKELL overview . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Installation 5
2.1 System requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Installing the binary distribution . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Building from source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Running gh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5 Compiling and running the generated code . . . . . . . . . . . . . . . . . 6
A
3 Generic H SKELL: The Language 7
3.1 Special Parentheses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Kind-indexed types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Type-indexed values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.4 Generic application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.5 Generic abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.6 Type-indexed types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.7 Generated function naming . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.8 Haskell compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4 Library 12
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.2 Module Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.3 Module Collect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.4 Module Compare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.5 Module Eq . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.6 Module Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.7 Module MapM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.8 Module ReadShow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.9 Module Reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.10 Module Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.11 Module ZipWith . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

5 Future Work 16

2
6 Meta-information 17
6.1 Contact . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.2 Caveats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.3 Known bugs and limitations . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.4 Change Log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.5 Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.6 Copyright information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3
 A
1 What is Generic H SKELL?

1.1 Generic Programming

Software development often consists of designing datatypes around which functionality is
added. Some functionality is datatype specific, whereas other functionality is defined on
almost all datatypes in such a way that it depends only on the structure of the datatype.
A function that works on many datatypes in this way is called a generic (or polytypic)
function. Examples of generic functionality include storing a value in a database, editing
a value, comparing two values for equality, pretty-printing a value.
Since datatypes often change and new datatypes are introduced, we have developed
A
Generic H SKELL, an extension of the functional programming language Haskell [5]
that supports generic definitions, to save the programmer from (re)writing instances
A
of generic functions. Generic H SKELL extends Haskell with, among other things, a
construct for defining type-indexed values with kind-indexed types, based on recent work
by Hinze [2]. These values can be specialised to all Haskell datatypes, facilitating wider
application of generic programming than provided by earlier systems such as PolyP [4].

A
1.2 Generic H SKELL overview
A
Generic H SKELL extends Haskell with a number of features.
• type-indexed values are defined as a value indexed over the various Haskell type
constructors (unit, primitive types, sums, products, and user-defined type con-
structors). The resulting type-indexed value can be specialised to any type.
• kind-indexed types are types indexed over kinds, defined by giving a case for both
∗ and κ → κ0 . Instances are obtained by applying the kind-indexed type to a kind.
• generic definitions can be used by applying them to a type or kind. This is called
generic application. The result is a type or value, depending on which sort of
generic definition is applied.
• generic abstraction allows generic definitions to take a type parameter. Such a
definition can apply only to types of a single kind.
• type-indexed types are types which are indexed over the type constructors. These
can be used to give types to more involved generic values. The resulting type-
indexed types can be specialised to any type.

4
2 Installation

2.1 System requirements

A
Generic H SKELL is written in Haskell 98. Minor parts require rank-2-polymorphism,
as implemented, for example, by GHC and Hugs. The package has been tested with
GHC and comes with a Makefile suitable to build it using GHC. Although parts of
the system are written using the Utrecht University’s attribute grammar system ag and
Hinze’s frown :-( parser generator, these tools are not required to build the compiler.
A
The code generated by Generic H SKELL is Haskell 98 compliant, except that functions
generated for higher kinded types require rank-n-polymorphism. (Fortunately higher-
kinded types are not particular common for most applications.)
Two kinds of distribution are available: Binary and Source.
The binary distribution includes a gh compiler binary and can be used together with
A
any Haskell system, as it translates Generic H SKELL input files into ordinary Haskell
files. We currently provide binaries for Linux, Solaris, and Windows. In principle, we
can provide binaries for any platform supported by GHC.
The source distribution includes the Haskell code for the gh compiler which has been
generated from our compiler source using both ag and frown :-(. GHC is required to
compile this distribution. Configuration files are provided.
At present, the compiler source may only be obtained by emailing info@generic-
haskell.org.

2.2 Installing the binary distribution

Installation is simple. Instructions for Unix users are as follows. Windows users must
consult the INSTALL file.

./configure --prefix=install_path

--prefix=install path is optional and defaults to /usr/local/.

Next run (GNU make is required):

make install

This will result in the binary gh being installed in the directory ${prefix}/bin.

5
2.3 Building from source
Building from source requires exactly the same command sequence as installing the
binary distribution. The difference of course is the amount of work which subsequently
occurs.

2.4 Running gh
A
The Generic H SKELL compiler is called gh. There are essentially two modes for
running it.
If you call gh without supplying a file to process, you will be asked for a file name.
Specify an input file relative to your working directory, and the compiler will process
the file and generate an output file with the same basename as the input file, but the
extension .hs.
Alternatively, input files can be specified on the command line.
A number of command line options are also available:

Usage: gh [options...] files...

-v --verbose (number of v’s controls the verbosity)
-V --version, --release show version info
-h, -? --help show help
-L DIR --library=DIR add DIR to search path

The first level of verbosity (no -v flag) produces only error messages. The second level
(-v) in addition provides some diagnostic information and warnings. The third level
(-vv) in addition provides debugging information.

2.5 Compiling and running the generated code

A
The Generic H SKELL compiler generates ordinary Haskell code. This can be run
using GHC, Hugs, or any other Haskell compiler. Ensure that you include the path to
GHPrelude.hs, which can be found in the lib subdirectory, in your compiler’s search
path.

6
 A
3 Generic H SKELL: The Language

A
The Generic H SKELL compiler implements a number of extensions to Haskell. These
are described briefly here. Further information can be found by consulting the literature
[2, 1, for example] and the examples included in the distribution (in examples/*.ghs).

3.1 Special Parentheses

Kind-indexed and type-indexed definitions take a (single) kind or type argument which
is wrapped by special parentheses. The parentheses {[ ]} (i.e., {[ ]}) wraps a kind
argument, whereas {| |} (i.e., {| |}) wraps a type argument.

3.2 Kind-indexed types

Type-indexed values (may) possess kind-indexed types. Kind-indexed types are defined
A
in Generic H SKELL using a new top-level declaration which has the following syntax:

type hConid i{[∗]} t1 . . . tn = htypei

type hConid i{[k → l ]} t1 . . . tn = htypei

A case is defined for both kind ∗ and for higher kinds k → l . To a certain degree
the k → l case is predetermined, depending on the number of arguments [2]. This is
exemplified by the k → l case in the following example.

Example The kind-indexed type for the generic map function is defined as:

type Map{[∗]} t1 t2 = t1 → t2
type Map{[k → l ]} t1 t2 = forall u v . Map{[k ]} u v → Map{[l ]} (t1 u) (t2 v )

Note that both cases have the same number of arguments and an equal number of
variables introduced by the forall.

7
3.3 Type-indexed values
A
Generic H SKELL introduces a new top-level declaration for type-indexed values. A
type-indexed value is defined using the following syntax.

hVarid i {| t :: k |} :: htypei
hVarid i {| hstypei |} . . . = . . .

where

hstypei ::= Unit | :+: | :*: | Fun | Con hvar i | Label hvar i | htyconi

Firstly, we must declare the type of the type-indexed value. This is generally an ex-
pression involving a kind- or type-indexed type. Then we provide its definition which is
indexed over the constructors (hstypei).
Corresponding to each hstypei is a regular Haskell data or type declaration. It is impor-
tant to know these so that the appropriate pattern can be employed in the appropriate
case of a generic definition.

data Unit = Unit

data Sum a b = Inl a | Inr b
-- Sum corresponds to :+: in type indices
data Prod a b = a:*:b
-- Prod corresponds to :*: in type indices
type Fun = (→)
data Con a = Con ConDescr a
data Label a = Label LabelDescr a

These are defined in the file GHPrelude.hs which is automatically imported by the
generated code. Consult GHPrelude.hs for details of ConDescr and LabelDescr and for
other auxiliary functions.
Naturally, these identifiers should not be used in the remainder of a program in a way
that clashes with their use in generic definitions, following the usual scoping rules of
Haskell.

Example The type-indexed value for the generic map function is defined as:

map{|t :: k |} :: Map{[k ]} t t
map{|Unit|} Unit = Unit
map{|:+:|} mA mB (Inl a) = Inl (mA a)
map{|:+:|} mA mB (Inr b) = Inr (mB b)
map{|:*:|} mA mB (a:*:b) = mA a:*:mB b
map{|Con c|} m (Con d b) = Con d (m b)

8
 map{|Label l |} m (Label l b) = Label l (m b)
map{|(→)|} = error "cannot map over function type"
map{|Int|} i = i
map{|Char |} c = c

This function can also be implemented in a point-free style (see examples/Map.ghs).

Generics defined over htyconi Type-indexed values (and later types) can be defined
over (possibly user-defined) type constructors. This covers the case for Int and Char ,
as illustrated above. Additional cases such as the following are also possible (though in
this case superfluous):

map{|List|} m Nil = Nil

map{|List|} m (Cons a as) = Cons (m a) (map{|List|} m as)

for the user defined type

data List a = Nil | Cons a (List a)

Notice the call map{|List|} m as on the right-hand side of this definition. This is required
since List is a recursive type.

3.4 Generic application

A type-indexed value can be specialised to a value by applying it to a type. Generic
application extends the syntax of expressions (haexpi) as follows:

haexpi ::= . . .
| hVarid i{|htypei|}

Similarly, a kind-indexed type can be specialised to a type by supplying the kind at

which the definition is to be applied. The syntax of type expressions (hgtyconi) is thus
extended as follows:

hgtyconi ::= . . .
| hConid i{[hkind i]}

Example Given the datatype:

data BinTree a = Empty | Node a (BinTree a) (BinTree a)

The map function for BinTree is map{|BinTree|}. The type of map{|BinTree|} is

Map{[∗ → ∗]} BinTree BinTree, which is (a → b) → (BinTree a → BinTree b).

9
3.5 Generic abstraction
A type variable (of fixed kind) can be abstracted generically from an expression using a
kind of generic abstraction. Declarations take the following form:

hVarid i {| t :: hkind i |} :: htypei

hVarid i {| t |} . . . = hexpi

Here t is a type variable of the given kind, where hkind i ranges over grounded kinds
(i.e., those without kind variables).
An example is the so-called categorical strength:

strength{|t :: ∗ → ∗|} :: t a → b → t (a, b)

strength{|t|} ta b = map{|t|} (λx → (x , b)) ta

3.6 Type-indexed types

Type-indexed types [3] can be defined just as type-indexed values, except that the right-
hand side of a definition is a constructor followed by a type. Thus the syntax consists
of a collection of definitions, indexed over the type constructors, of the form:

type hConid i{|hstypei|} tv1 . . . tvn = hconi htypei

New constructors (hconi) must be introduced for each case of such a definition — each
case will be compiled into a newtype declaration.
A type-indexed type can be specialised to a type by supplying its type argument.

hgtyconi ::= . . .
| hConid i{|htypei|}

Example The type-indexed type FMap is defined as follows:

type FMap{[Unit]} v = FMU (Maybe v )

type FMap{[:+:]} fma fmb v = FMP (fma v , fmb v )
type FMap{[:*:]} fma fmb v = FMT (fma (fmb v ))
type FMap{[Con]} fm v = FMC (fm v )
type FMap{[Label ]} fm v = FML (fm v )

FMap can be used anywhere a type can by supplying FMap with its type parameter,
for example in the following:

type Lookup{[∗]} t = forall v . FMap{[t]} v → t → Maybe v

type Lookup{[k → l ]} t = forall a . Lookup{[k ]} a → Lookup{[l ]} (t a)

10
The constructors introduced in the definition of FMap can be used in pattern matching.

lookup{|t :: k |} :: Lookup{[k ]} t
lookup{|Unit|} (FMU fm) Unit = fm
lookup{|:+:|} lA lB (FMP (fma, fmb)) (Inl a) = lA fma a
lookup{|:+:|} lA lB (FMP (fma, fmb)) (Inr b) = lB fmb b
lookup{|:*:|} lA lB (FMT fma) (a:*:b) = do {fmb ← lA fma a; lB fmb b }
lookup{|Con d |} l (FMC fm) (Con b) = l fm b
lookup{|Label d |} l (FML fm) (Label b) = l fm b

Note: This feature is experimental and subject to revision.

3.7 Generated function naming

A
The Generic H SKELL programmer must (unfortunately) be aware of the names which
the compiler uses in the generated Haskell source in order to avoid name clashes.
For a type-indexed value with with name poly, the name of the code generated for this
function for type Type is polyType. This is the name of the function poly{|Type|}. Thus
map for BinTree (or map{|BinTree|}) is called mapBinTree. There are a number of
exceptions. The suffixes for type constructors [ ], (, ), (, , ) and (→) are LIST , TUPLE2 ,
TUPLE3 , Fun, respectively. Thus the generated map functions for these types are
mapLIST , mapTUPLE2 , and so forth.
With this in mind, a programmer may link ordinary Haskell code with code generated
A
by the Generic H SKELL compiler by using the names just described.

3.8 Haskell compatibility

A
Generic H SKELL parses all Haskell programs, except when one of the following prob-
lems occur:
A
• The token forall is an additional keyword in Generic H SKELL. As this is already
the case in the extensions provided by many Haskell implementations, it should
hopefully not cause too much trouble.
• The special parentheses for type and kind arguments, i.e. {|, |}, {[, ]}, are all handled
as a single token. Unfortunately, some pieces of regular Haskell code can trick the
lexer and result in parse errors. For example, in
do {[x ] ← action; return x }
the initial {[ is treated as a single token {[ rather than the two tokens { and [ which
an Haskell programmer would expect. In other instances, sequences such as +|}
are considered as the operator +| followed by a }, since | may occur in operators,
whereas {|+ is considered as the token {| followed by +.
The required fix in both cases is to insert a space in the appropriate place, for
example by writing instead do { [x ] ← action; return x }.

11
4 Library

4.1 Introduction
A
Provided with the Generic H SKELL system is a library of useful generic functions.
These are summarised below; for the details, consult the library itself (in subdirectory
lib). We give the types of the generic functions for kind ∗ and ∗ → ∗, and usually a
short description.

A
Naming conventions When generic functions defined in the Generic H SKELL library
have an equivalent in the Haskell Prelude or libraries, the name of the generic function
is prefixed with a ‘g’.

4.2 Module Bounds

gminBound , gmaxBound {|t :: ∗|} :: t
gminBound , gmaxBound {|t :: ∗ → ∗|} :: a → t a

These are slight generalizations of the minBound and maxBound members of the Bounded
class. They have the property that for all types t

forall a :: t . gminBound {|t|} 6 a 6 gmaxBound {|t|}

However, these functions are also defined for types for which Bounded is not derivable;
i.e. types which are not enumerations or simple product types (see [5, Appendix D]).
For kinds other than ∗, the first parameters are not used: they can be ⊥.

4.3 Module Collect

The functions in this module collect information about types and values of these types.

constructorOf {|t :: ∗|} :: t → ConDescr

constructorOf {|t :: ∗ → ∗|} :: (a → ConDescr ) → t a → ConDescr

constructorOf returns a description of the topmost constructor in a value.

12
 constructors{|t :: ∗|} :: [ConDescr ]
constructors{|t :: ∗ → ∗|} :: [ConDescr ] → [ConDescr ]

constructors returns a list of descriptions of all topmost constructors used in a datatype.

labelsOf {|t :: ∗|} :: t → [LabelDescr ]

labelsOf {|t :: ∗ → ∗|} :: (a → LabelDescr ) → t a → LabelDescr

labelsOf returns a list of descriptions of labels in a value, or the empty list when the
current type constructor has no labels.

constructorsAndLabels{|t :: ∗|} :: [(ConDescr , [LabelDescr ])]

constructorsAndLabels{|t :: ∗ → ∗|} :: [(ConDescr , [LabelDescr ])]
→ [(ConDescr , [LabelDescr ])]

constructorsAndLabels combines the above information: it returns a list of all construc-

tors, paired with the labels present in the given type constructor.
For kinds other than ∗, the first parameters are not used. Again, consult GHPrelude.hs
for details of ConDescr and LabelDescr .

4.4 Module Compare

gcompare{|t :: ∗|} :: t → t → Ordering
gcompare{|t :: ∗ → ∗|} :: (a → b → Ordering) → t a → t b → Ordering

gcompare is the generic version of compare in the Ord class.

4.5 Module Eq
eq{|t :: ∗|} :: t → t → Bool
eq{|t :: ∗ → ∗|} :: (a → b → Bool ) → t a → t b → Bool

eq is the generic version of (==) in the Eq class.

4.6 Module Map

gmap{|t :: ∗|} :: t → t
gmap{|t :: ∗ → ∗|} :: (a → b) → t a → t b

gmap is the generic version of fmap in class Functor .

13
4.7 Module MapM
mapMl , mapMr {|t :: ∗|} :: (Functor m, Monad m) ⇒ t → m t
mapMl , mapMr {|t :: ∗ → ∗|} :: (Functor m, Monad m) ⇒ (a → m b) → t a → m (t b)

These are the generic versions of the monadic map mapM in the Prelude. mapMl
traverses a datastructure from left to right (just like mapM ) while mapMr does this from
right to left. The Monad in the context should also be an instance of class Functor , but
that’s usually not problematic.

4.8 Module ReadShow

gshowsPrec{|t :: ∗|} :: Bool → Int → t → ShowS
gshowsPrec{|t :: ∗ → ∗|} :: (Bool → Int → a → ShowS ) →
Bool → Int → t a → ShowS

greadsPrec{|t :: ∗|} :: Bool → Int → ReadS t

greadsPrec{|t :: ∗ → ∗|} :: (Bool → Int → ReadS a) →
Bool → Int → ReadS (t a)

The generic versions of show and read (in classes Show and Read ).
The extra argument of type Bool is used internally to specify whether field labels are to
be printed (and separated by commas). It should usually be False.
Since calling these functions is a bit cumbersome, specialisations are provided:

gshow {|t :: ∗|} :: t → String

gshow1 {|t :: ∗ → ∗|} :: Show a ⇒ t a → String
gread {|t :: ∗|} :: String → t
gread1 {|t :: ∗ → ∗|} :: Read a ⇒ String → t a

4.9 Module Reduce

rreduce{|t :: ∗|} :: t →b→b
rreduce{|t :: ∗ → ∗|} :: (a → b → b) → t a → b → b
lreduce{|t :: ∗|} :: b→t →b
lreduce{|t :: ∗ → ∗|} :: (b → a → b) → b → t a → b

rreduce is a generic version of foldr (note the reversed order of the last two arguments!),
while lreduce is a generic foldl . See [1, section 5.4].

crush{|t :: ∗ → ∗|} :: (a → a → a) → a → t a → a

14
crush is an instance of lreduce with a slightly more familiar type.
The following functions are all defined in terms of the above functions, and most have
counterparts in the Haskell Prelude:

gsum, gproduct{|t :: ∗ → ∗|} :: Num a ⇒ t a → a

gand , gor {|t :: ∗ → ∗|} :: t Bool → a
flatten{|t :: ∗ → ∗|} :: t a → [a ]
count{|t :: ∗ → ∗|} :: t a → Int
comp{|t :: ∗ → ∗|} :: t (a → a) → (a → a)
gconcat{|t :: ∗ → ∗|} :: t [a ] → [a ]
gall , gany{|t :: ∗ → ∗|} :: (a → Bool ) → t a → Bool
gelem{|t :: ∗ → ∗|} :: Eq a ⇒ a → t a → Bool

flatten collects all values of type a in a list, and comp composes all functions contained
in a datatype.

4.10 Module Table

See [1, section 5.6] and the code in lib/Table.ghs.

4.11 Module ZipWith

gzipWith{|t :: ∗|} :: (t, t) → Maybe t
gzipWith{|t :: ∗ → ∗|} :: ((a, b) → Maybe c) → (t a, t b) → Maybe (t c)

A generic version of zipWith, with the difference that in case the structures don’t match,
Nothing is returned.

gunzipWith{|t :: ∗|} :: t → (t, t)

gunzipWith{|t :: ∗ → ∗|} :: (a → (b, c)) → t a → (t b, t c)

gunzipWith is a generic version of unzip.

gzip{|t :: ∗ → ∗|} :: t a → t b → Maybe (t (a, b))

gunzip{|t :: ∗ → ∗|} :: t (a, b) → (t a, t b)

These functions are more direct generalizations of zip and unzip respectively. They are
defined as instances of gzipWith and gunzipWith.

15
5 Future Work

In the future, we plan to continue our work on the compiler. Among the many possible
extensions and improvements, we are initially considering:
• support for POPL-style definitions
• full support for modules
• adding a type checker
• a view mechanism (i.e. implicit maps between data types); better support for
fixpoints
• improved support for type-indexed data types
• XML, generic traversals, . . .
A
As we have not yet decided what the next major release of the Generic H SKELL
compiler will look like, these topics are subject to change. Any input and feedback is
welcome!

16
6 Meta-information

6.1 Contact
A A
The Generic H SKELL Project For information regarding the Generic H SKELL
project send email to [email protected].

Mailing List A low volume mailing list exists. Currently it serves as a place for dis-
A
tributing information relevant to Generic H SKELL and for announcing our project
meetings. This is the appropriate forum for general language discussions and whatnot.
The address is [email protected]. To subscribe to the mailing
list send an email to [email protected].

Bug Reports Bugs can be reported to [email protected].

6.2 Caveats
A
The Generic H SKELL compiler is a research prototype. Many of its features, especially
the more experimental ones, may change as we gain more experience and understanding.
It should be noted that the compiler does not perform type checking of the Generic
A A
H SKELL source language. Thus type errors in Generic H SKELL source will often
only be discovered when the generated Haskell source is compiled.

6.3 Known bugs and limitations

1. Qualified names are not handled correctly in many parts of the compiler. If you
want to have reliable behaviour, then avoid using any qualified names in your
A
Generic H SKELL source files.
2. Export/import lists for modules are ignored by the compiler, which will lead to
A
unwanted results if used for Generic H SKELL source files.
3. Imported types are not specialised for imported generic definitions. (This is not
really a bug or a limitation, but rather prevents a generic function from being
specialised to a specific type twice.)

17
 4. The constructor descriptors for user-defined data types that have infix constructors
with non-default fixity will be generated incorrectly with the default fixity.
5. Usage of the keyword forall in types is a bit tricky. There are places where it is
needed, and others where it may cause strange errors. This will be clarified in the
future. Let the examples guide you for now.
6. We have not yet decided how to deal with generic definitions which are declared
across module boundaries. Any behaviour that these may give is incidental and
should not be considered as definitive.
7. Type-indexed data types do not work well with modules. All specialisations have
to be generated in the module in which they are defined.
8. A datatype (or newtype) which has a parameter of higher kinded type that does
not appear in the right hand side of the definition produces a bug in the Haskell
code generated by gh. The datatype Y below exhibits the behaviour.
data X a = X a
data Y b = Y (X (Y X ))
Parameter b has kind ∗ → ∗, but it does not occur in Y (X (Y X )). We do not
imagine that such types are very common, so the bug will remain for now.

6.4 Change Log

Amber (0.99) Everything is new. This is the first release.

6.5 Acknowledgements
Thanks to Ralf Hinze for frown :-(, to Arthur Baars and Doaitse Swiestra for ag, and
to Simon Marlow and Sven Panne for the original Happy Haskell grammar.

6.6 Copyright information

A
gh – a compiler for Generic H SKELL.
A
Copyright c 2001 The Generic H SKELL Team. Utrecht University
This library is free software; you can redistribute it and/or modify it under the terms of
the GNU Lesser General Public License as published by the Free Software Foundation;
either version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FIT-
NESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
for more details.
You should have received a copy of the GNU Lesser General Public License along with
this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite
330, Boston, MA 02111-1307 USA

18
Bibliography

[1] Ralf Hinze. Generic Programs and Proofs. 2000. Habilitationsschrift, Bonn Univer-
sity.

[2] Ralf Hinze. Polytypic values possess polykinded types. In Roland Backhouse and
José Nuno Oliveira, editors, Mathematics of Program Construction, volume 1837 of
LNCS, pages 2–27. Springer-Verlag, 2000.

[3] Ralf Hinze, Johan Jeuring, and Andres Löh. Type-indexed datatypes. Unpublished,
2001. http://www.cs.uu.nl/~johanj/publications/tidata.ps.

[4] P. Jansson and J. Jeuring. PolyP — a polytypic programming language extension.

In Conference Record of POPL ’97: The 24th ACM SIGPLAN-SIGACT Symposium
on Principles of Programming Languages, pages 470–482. ACM Press, 1997.

[5] Simon Peyton Jones, John Hughes (editors), et al. Haskell 98 — A non-strict, purely
functional language. Available from http://haskell.org, February 1999.

19