1.1 Overview of Gauche
Gauche is a script interpreter based on Scheme.
Gauche conforms the language standard
"Revised^5 Report on the Algorithmic Language Scheme"
and supports various common libraries defined in SRFIs
The goal of Gauche is to provide a handy tool for
programmers and system administrators to handle
daily works conveniently and efficiently in the production environment.
There are lots of Scheme implementations available, and each
of them has its design emphasis and weeknesses. Gauche is
designed with emphasis on the following criteria.
- Quick startup
- One of the situation Gauche is aiming at is in the production
environment, where you write ten-lines throw-away script that
may invoked very frequently. This includes CGI scripts as well.
Gauche includes a set of most common features in its executable,
while splits less common stuffs into libraries which are to be loaded
on demand, to make itself start quickly.
- Multibyte strings
- We can no longer live happily in ASCII-only or 1-byte-per-character world.
The practical language implementations are required to handle
multibyte (wide) characters.
Gauche supports multibyte strings natively, providing robust and
consistent support than ad hoc library-level implementation.
See section 2.2 Multibyte Strings, for details.
- Modular development
- Gauche has a simple module system to separate namespaces,
which allows the developers to work in parallel without
worrying name collision.
- Integrated object system
- A powerful CLOS-like object system with MetaObject protocol
(mostly compatible with STklos and Guile) is provided.
- System interface
- Although Scheme abstracts lots of details of the machine,
sometimes you have to bypass these high-level layers and
go down to the basement to make things work.
Gauche has built-in support of most of POSIX.1 system calls.
Other modules, such as networking module, usually provide
both high-level abstract interface and low-level interface
close to system calls.
- Enhanced I/O
- No real application can be written without dealing with I/O.
Scheme neatly abstracts I/O as a port, but defines least operations on it.
Gauche uses a port object as a unified abstraction, providing
utility functions to operate on the underlying I/O system.
See section 6.18 Input and Output, for the basic I/O support.
On the other hand, Gauche is not designed for
applications such like high-performance number cruncher or
very large scale database handling. It is an interpreter, after all.
You can still use Gauche as a "glue" language for such applications,
however. For example, you can write a performance-critical part
in another language that compiles to native code, and use Gauche to set up.
This document was generated
by Ken Dickey on November, 28 2002