Pi is a programming (better a specification) language. It was developed in 1984 and is used at some German universities (for example at University of Potsdam).
It was made to develop specifications. Specifcations are provisional programs. They are not for making real programs which can be shipped, but to formulate a given problem into an algorithm, implement this algorithm, test it and show it to client to verify, that that is what he wanted. Then you can start making the real program basing on this specification.
The given Pi-Compiler (can be downloaded from http://www.cs.uni-potsdam.de/~owilhelm/Manuskripte/Pi/pi.zip ) translates the given specification into Haskell (in fact the compiler is buggy so there is a pre-compiler which translates the given code, so that the compiler understands it and a post-compiler, so that the Haskell-code is working).

How to write a Pi-specification (please make yourself familiar with specifications before reading the following):
As stated in specification it consists of the export, the import, the common parameters and the body. In the first three there are only the signatures of the operations and types ( in import and common parameters are these which are not in this module (specification) ). A signature is the first line of an operation (ex. in C int add (int x, int y) ).
To show you how this all works I show you a short specification of the natural numbers + 0 ({0,1,...}):

this is what is exported.

```cem NAT
type view specification

export

type Nat

constructor null : -> Nat
constructor successor: Nat -> Nat
operation null : -> Nat
operation successor: Nat -> Nat
operation add : Nat,Nat -> Nat
operation one : -> Nat
operation two : -> Nat
```

The import is empty as we only import one specification, but this is also needed to be exported
```import
```

```common parameters
type Logic
operation true : -> Logic
operation false : -> Logic
constructor true : -> Logic
constructor false : -> Logic
```

Now the body
```body
construction of type Nat is internal
constructor null : -> Nat
constructor successor: Nat -> Nat

operation add : Nat,Nat -> Nat
variables x,y : Nat
equations