PolyP reference manual

Flag summary

polyp [--version] [-v] {-p Preludefile.hs} {-r f[:D]} [polypcode.phs]

--version

Prints the PolyP compiler version and exits

-v

Verbatim - print information about the compiler phases while compiling

-p file

Read explicit type information from file before starting.

-r value[:type constructor|all]

Start polytypic instantiation from value (default is from main). If value is polytypic, the desired datatype constructor D must be given.

Compiler phases

  chase {-i ImportDir} PolyPModule.phs  > PolyPcode.Phs

  polyp [-v] {-p ExplTypes.hs} {-r f[:D]}] PolyPcode.Phs > Haskellcode.Hs

  [cat Prefix.hs Haskellcode.Hs         > Haskellcode.hs]

The main translation phase

The output is Haskell code and can be loaded in hugs or compiled with a Haskell compiler. Sometimes the generated code is rejected as a Haskell program due to the lack of explicit type declarations of top level overloaded function. In this case these declarations have to be supplied by hand. The simplest way to do this is to put them in a separate file and then cat it together with the polyp output. If the flag -v (verbose) is used, the different phases of the PolyP compilation give progress reports in a Haskell comment in the output file:

• the parser reports the names of the successfully parsed declarations,
• the dependency analysis reports a dependency ordered list of groups of mutually recursive declarations,
• the type checker reports the types of all top level declarations
• and the instance generation just reports the generated code.

The flag -p is used when you want to use Haskell functions that are not in the built in part of the Haskell prelude. If you list the types of these functions in a file ExplTypes.hs and call PolyP with polyp -p ExplTypes.hs PolyPCode.Phs you can use the listed functions in the definitions in PolyPCode.Phs. Note that the file ExplTypes.hs must contain only explicit type declarations, and that these are only read by PolyP, not included in the output. The definitions of these functions should be placed in a separate file and prepended to the PolyP output or loaded in hugs in some other way.

Polytypic program construction tips

• Try to separate the essentially polytypic part from the pure Haskell parts. This helps by keeping the PolyP input small thus simplifying debugging and by giving you the full power of Haskell to write the non-polytypic part, instead of the restricted subset that PolyP can handle. The way to achieve the separation in practice is to work with some Haskell files, some polytypic files and one file containing explicit type declarations of the Haskell definitions needed in the polytypic part. If these types are collected in the file Types.hs, invoke PolyP by polyp -p Types.hs Code.Phs.
• Use as few polytypic constructs as possible. The polytypic construct is powerful, but difficult to use. Often one more general polytypic function can solve a number of related polytypic problems given different parameters.
• Use the polytypic library PolyLib. Code reuse is always very often possible with this supply of generic combinators. Using these predefined definitions in your code makes it shorter, and easier to read as the function names are more well known.

A sample Makefile