GOFER(1) GOFER(1)
NAME
gofer, gofc - Gofer programming language interpreter and compiler
SYNOPSIS
gofer
gofc [file] ...
DESCRIPTION
Gofer is an interactive functional programming environment (i.e. an
interpreter) supporting a language based on the draft report for
Haskell version 1.2, including the following features:
o Lazy functional language features such as
lazy evaluation, higher order functions, pattern matching,
etc.
o Wide range of built-in types
with provision for defining new free datatypes and type
synonyms.
o Polymorphic type system
with provision for overloading based on a system of type
classes.
o Full Haskell 1.2 expression and pattern syntax
including lambda, case, conditional and let expressions,
list comprehensions, operator sections, and wildcard, as and
irrefutable patterns.
o Partial implementation of Haskell 1.2 I/O
enabling the use of simple interactive programs and programs
reading and writing text files.
o Constructor classes and overloaded monad comprehensions.
o Simple minded compiler/translator gofc
with runtime system for generation of standalone
applications.
o Runs on PC compatible computers,
but also works on Sun and other workstations.
Gofer is intended as an experimental language, particularly where type
classes are involved. Gofer extends the Haskell type class system in
several ways:
o Type classes with multiple parameters.
o Instances of type classes
may be defined non-overlapping, but otherwise arbitrary types.
o Predicates in contexts
may involve arbitrary type expressions, not just type variables
as in Haskell.
o Basic approach to dictionary construction is different,
based on the approach described in a posting to the Haskell
mailing list early in Feburary 1991. The resulting system
ensures that all dictionaries are constructed before evaluation
begins, avoiding repeated construction and enabling the shared
evaluation of overloaded constants in dictionaries.
- 1 - Formatted: April 19, 2024
GOFER(1) GOFER(1)
The most significant features of Haskell not currently supported are:
modules, arrays, overloaded numeric constants, default declarations,
derived instances, contexts in datatype definitions.
INTERPRETER
The Gofer interpreter is usually entered by giving the command
`gofer'.
Most commands in Gofer take the form of a colon followed by one or
more characters which distinguish one command from another. There
are two commands which are particularly worth remembering:
o :q exits the Gofer interpreter.
On most systems, you can also exit from Gofer by typing the end
of file character (^D).
o :? prints a list of all the commands,
which can be useful if you forget the name of the command that
you want to use.
Note that the interrupt key (^C on most systems) can be used at
any time whilst using Gofer to abandon the process of reading in a
file of function definitions or the evaluation of an expression.
When the interrupt key is detected, Gofer prints the string
"{Interrupted!}" and prints the "? " prompt so that further commands
can be entered.
COMPILER
Compiling a program with gofc is very much like starting up the Gofer
interpreter. The compiler starts by reading the prelude and then
loads the script files specified by the command line. These scripts
must contain a definition for the value main :: Dialogue which will be
the dialogue expression that is evaluated when the compiled program is
executed.
For example, if the file apr1.gs contains the simple program:
main :: Dialogue
main = appendChan "stdout" "Hello, world\n" exit done
then this can be compiled with the following command.
gofc apr1.gs
The output is written to the file apr1.c -- i.e. the name obtained by
removing the .gs suffix and replacing it with a .c suffix. Other
filename suffixes that are treated in a similar way are:
.prj .gp for Gofer project files
.prelude for Gofer prelude files
.gof .gs for Gofer scripts
.has .hs for Haskell scripts
.lhs .lit for literate scripts
.lgs .verb
If no recognized suffix is found then the name of the output file is
obtained simply by appending the .c suffix to the input name. Be
careful; if you take an input file called `prog' and compile it to
`prog.c' using gofc, make sure that you do not compile the C program
in such a way that the output is also called `prog' since this will
overwrite your original source code! For this reason, you should
always using file extensions such as .gs if you are using gofc.
- 2 - Formatted: April 19, 2024
GOFER(1) GOFER(1)
If you run gofc with multiple script files, then the name of the
output file is based on the last script file to be loaded. For
example, the command `gofc prog1.gs prog2.gs' produces an output file
`prog2.c'.
The compiler gofc also works with project files, using the name of the
project file to determine the name of the output file. For example,
the miniProlog interpreter can be compiled using:
gofc + miniProlog.prj
You can also specify Gofer command line options as part of the command
line used to run gofc. Think of it like this; use exactly the same
command line to start Gofc as you would have done to start Gofer (ok,
replacing the command `gofer' with `gofc') so that you could start
your program immediately by evaluating the main expression.
FILES
The files in /usr/local/lib/Gofer/lib contain various preludes and
header files for the Gofer compiler.
SEE ALSO
Documentation about how to run the system is in the directory
/usr/local/lib/Gofer/docs
For starters see the file ch03 in that directory. See the file
release.228 in that directory for more about the compiler.
sml(1)
AUTHOR
Gofer was written by Mark P. Jones and has benefited greatly from
suggestions, comments and bug reports from its users. This manual
page was prepared by Gary Leavens.
- 3 - Formatted: April 19, 2024
